1
2
3 #include "ccm.h"
4
5
6 using namespace std;
7
8
9
10
11
12
13
14 #ifdef HAVE_EXPLICIT_STRUCT_OPS
15 Components::InvalidName::InvalidName()
16 {
17 }
18
19 Components::InvalidName::InvalidName( const InvalidName& _s )
20 {
21 }
22
23 Components::InvalidName::~InvalidName()
24 {
25 }
26
27 Components::InvalidName&
28 Components::InvalidName::operator=( const InvalidName& _s )
29 {
30 return *this;
31 }
32 #endif
33
34 class _Marshaller_Components_InvalidName : public ::CORBA::StaticTypeInfo {
35 typedef ::Components::InvalidName _MICO_T;
36 public:
37 StaticValueType create () const;
38 void assign (StaticValueType dst, const StaticValueType src) const;
39 void free (StaticValueType) const;
40 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
41 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
42 };
43
44
45 ::CORBA::StaticValueType _Marshaller_Components_InvalidName::create() const
46 {
47 return (StaticValueType) new _MICO_T;
48 }
49
50 void _Marshaller_Components_InvalidName::assign( StaticValueType d, const StaticValueType s ) const
51 {
52 *(_MICO_T*) d = *(_MICO_T*) s;
53 }
54
55 void _Marshaller_Components_InvalidName::free( StaticValueType v ) const
56 {
57 delete (_MICO_T*) v;
58 }
59
60 ::CORBA::Boolean _Marshaller_Components_InvalidName::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
61 {
62 string repoid;
63 return
64 dc.except_begin( repoid ) &&
65 dc.except_end();
66 }
67
68 void _Marshaller_Components_InvalidName::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
69 {
70 ec.except_begin( "IDL:omg.org/Components/InvalidName:1.0" );
71 ec.except_end();
72 }
73
74 ::CORBA::StaticTypeInfo *_marshaller_Components_InvalidName;
75
76 void Components::InvalidName::_throwit() const
77 {
78 #ifdef HAVE_EXCEPTIONS
79 #ifdef HAVE_STD_EH
80 throw *this;
81 #else
82 throw InvalidName_var( (Components::InvalidName*)_clone() );
83 #endif
84 #else
85 CORBA::Exception::_throw_failed( _clone() );
86 #endif
87 }
88
89 const char *Components::InvalidName::_repoid() const
90 {
91 return "IDL:omg.org/Components/InvalidName:1.0";
92 }
93
94 void Components::InvalidName::_encode( CORBA::DataEncoder &_en ) const
95 {
96 _marshaller_Components_InvalidName->marshal( _en, (void*) this );
97 }
98
99 void Components::InvalidName::_encode_any( CORBA::Any & ) const
100 {
101
102 assert(0);
103 }
104
105 CORBA::Exception *Components::InvalidName::_clone() const
106 {
107 return new InvalidName( *this );
108 }
109
110 Components::InvalidName *Components::InvalidName::_downcast( CORBA::Exception *_ex )
111 {
112 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidName:1.0" ) )
113 return (InvalidName *) _ex;
114 return NULL;
115 }
116
117 const Components::InvalidName *Components::InvalidName::_downcast( const CORBA::Exception *_ex )
118 {
119 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidName:1.0" ) )
120 return (InvalidName *) _ex;
121 return NULL;
122 }
123
124
125 #ifdef HAVE_EXPLICIT_STRUCT_OPS
126 Components::InvalidConfiguration::InvalidConfiguration()
127 {
128 }
129
130 Components::InvalidConfiguration::InvalidConfiguration( const InvalidConfiguration& _s )
131 {
132 }
133
134 Components::InvalidConfiguration::~InvalidConfiguration()
135 {
136 }
137
138 Components::InvalidConfiguration&
139 Components::InvalidConfiguration::operator=( const InvalidConfiguration& _s )
140 {
141 return *this;
142 }
143 #endif
144
145 class _Marshaller_Components_InvalidConfiguration : public ::CORBA::StaticTypeInfo {
146 typedef ::Components::InvalidConfiguration _MICO_T;
147 public:
148 StaticValueType create () const;
149 void assign (StaticValueType dst, const StaticValueType src) const;
150 void free (StaticValueType) const;
151 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
152 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
153 };
154
155
156 ::CORBA::StaticValueType _Marshaller_Components_InvalidConfiguration::create() const
157 {
158 return (StaticValueType) new _MICO_T;
159 }
160
161 void _Marshaller_Components_InvalidConfiguration::assign( StaticValueType d, const StaticValueType s ) const
162 {
163 *(_MICO_T*) d = *(_MICO_T*) s;
164 }
165
166 void _Marshaller_Components_InvalidConfiguration::free( StaticValueType v ) const
167 {
168 delete (_MICO_T*) v;
169 }
170
171 ::CORBA::Boolean _Marshaller_Components_InvalidConfiguration::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
172 {
173 string repoid;
174 return
175 dc.except_begin( repoid ) &&
176 dc.except_end();
177 }
178
179 void _Marshaller_Components_InvalidConfiguration::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
180 {
181 ec.except_begin( "IDL:omg.org/Components/InvalidConfiguration:1.0" );
182 ec.except_end();
183 }
184
185 ::CORBA::StaticTypeInfo *_marshaller_Components_InvalidConfiguration;
186
187 void Components::InvalidConfiguration::_throwit() const
188 {
189 #ifdef HAVE_EXCEPTIONS
190 #ifdef HAVE_STD_EH
191 throw *this;
192 #else
193 throw InvalidConfiguration_var( (Components::InvalidConfiguration*)_clone() );
194 #endif
195 #else
196 CORBA::Exception::_throw_failed( _clone() );
197 #endif
198 }
199
200 const char *Components::InvalidConfiguration::_repoid() const
201 {
202 return "IDL:omg.org/Components/InvalidConfiguration:1.0";
203 }
204
205 void Components::InvalidConfiguration::_encode( CORBA::DataEncoder &_en ) const
206 {
207 _marshaller_Components_InvalidConfiguration->marshal( _en, (void*) this );
208 }
209
210 void Components::InvalidConfiguration::_encode_any( CORBA::Any & ) const
211 {
212
213 assert(0);
214 }
215
216 CORBA::Exception *Components::InvalidConfiguration::_clone() const
217 {
218 return new InvalidConfiguration( *this );
219 }
220
221 Components::InvalidConfiguration *Components::InvalidConfiguration::_downcast( CORBA::Exception *_ex )
222 {
223 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidConfiguration:1.0" ) )
224 return (InvalidConfiguration *) _ex;
225 return NULL;
226 }
227
228 const Components::InvalidConfiguration *Components::InvalidConfiguration::_downcast( const CORBA::Exception *_ex )
229 {
230 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidConfiguration:1.0" ) )
231 return (InvalidConfiguration *) _ex;
232 return NULL;
233 }
234
235
236 #ifdef HAVE_EXPLICIT_STRUCT_OPS
237 Components::AlreadyConnected::AlreadyConnected()
238 {
239 }
240
241 Components::AlreadyConnected::AlreadyConnected( const AlreadyConnected& _s )
242 {
243 }
244
245 Components::AlreadyConnected::~AlreadyConnected()
246 {
247 }
248
249 Components::AlreadyConnected&
250 Components::AlreadyConnected::operator=( const AlreadyConnected& _s )
251 {
252 return *this;
253 }
254 #endif
255
256 class _Marshaller_Components_AlreadyConnected : public ::CORBA::StaticTypeInfo {
257 typedef ::Components::AlreadyConnected _MICO_T;
258 public:
259 StaticValueType create () const;
260 void assign (StaticValueType dst, const StaticValueType src) const;
261 void free (StaticValueType) const;
262 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
263 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
264 };
265
266
267 ::CORBA::StaticValueType _Marshaller_Components_AlreadyConnected::create() const
268 {
269 return (StaticValueType) new _MICO_T;
270 }
271
272 void _Marshaller_Components_AlreadyConnected::assign( StaticValueType d, const StaticValueType s ) const
273 {
274 *(_MICO_T*) d = *(_MICO_T*) s;
275 }
276
277 void _Marshaller_Components_AlreadyConnected::free( StaticValueType v ) const
278 {
279 delete (_MICO_T*) v;
280 }
281
282 ::CORBA::Boolean _Marshaller_Components_AlreadyConnected::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
283 {
284 string repoid;
285 return
286 dc.except_begin( repoid ) &&
287 dc.except_end();
288 }
289
290 void _Marshaller_Components_AlreadyConnected::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
291 {
292 ec.except_begin( "IDL:omg.org/Components/AlreadyConnected:1.0" );
293 ec.except_end();
294 }
295
296 ::CORBA::StaticTypeInfo *_marshaller_Components_AlreadyConnected;
297
298 void Components::AlreadyConnected::_throwit() const
299 {
300 #ifdef HAVE_EXCEPTIONS
301 #ifdef HAVE_STD_EH
302 throw *this;
303 #else
304 throw AlreadyConnected_var( (Components::AlreadyConnected*)_clone() );
305 #endif
306 #else
307 CORBA::Exception::_throw_failed( _clone() );
308 #endif
309 }
310
311 const char *Components::AlreadyConnected::_repoid() const
312 {
313 return "IDL:omg.org/Components/AlreadyConnected:1.0";
314 }
315
316 void Components::AlreadyConnected::_encode( CORBA::DataEncoder &_en ) const
317 {
318 _marshaller_Components_AlreadyConnected->marshal( _en, (void*) this );
319 }
320
321 void Components::AlreadyConnected::_encode_any( CORBA::Any & ) const
322 {
323
324 assert(0);
325 }
326
327 CORBA::Exception *Components::AlreadyConnected::_clone() const
328 {
329 return new AlreadyConnected( *this );
330 }
331
332 Components::AlreadyConnected *Components::AlreadyConnected::_downcast( CORBA::Exception *_ex )
333 {
334 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/AlreadyConnected:1.0" ) )
335 return (AlreadyConnected *) _ex;
336 return NULL;
337 }
338
339 const Components::AlreadyConnected *Components::AlreadyConnected::_downcast( const CORBA::Exception *_ex )
340 {
341 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/AlreadyConnected:1.0" ) )
342 return (AlreadyConnected *) _ex;
343 return NULL;
344 }
345
346
347 #ifdef HAVE_EXPLICIT_STRUCT_OPS
348 Components::InvalidConnection::InvalidConnection()
349 {
350 }
351
352 Components::InvalidConnection::InvalidConnection( const InvalidConnection& _s )
353 {
354 }
355
356 Components::InvalidConnection::~InvalidConnection()
357 {
358 }
359
360 Components::InvalidConnection&
361 Components::InvalidConnection::operator=( const InvalidConnection& _s )
362 {
363 return *this;
364 }
365 #endif
366
367 class _Marshaller_Components_InvalidConnection : public ::CORBA::StaticTypeInfo {
368 typedef ::Components::InvalidConnection _MICO_T;
369 public:
370 StaticValueType create () const;
371 void assign (StaticValueType dst, const StaticValueType src) const;
372 void free (StaticValueType) const;
373 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
374 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
375 };
376
377
378 ::CORBA::StaticValueType _Marshaller_Components_InvalidConnection::create() const
379 {
380 return (StaticValueType) new _MICO_T;
381 }
382
383 void _Marshaller_Components_InvalidConnection::assign( StaticValueType d, const StaticValueType s ) const
384 {
385 *(_MICO_T*) d = *(_MICO_T*) s;
386 }
387
388 void _Marshaller_Components_InvalidConnection::free( StaticValueType v ) const
389 {
390 delete (_MICO_T*) v;
391 }
392
393 ::CORBA::Boolean _Marshaller_Components_InvalidConnection::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
394 {
395 string repoid;
396 return
397 dc.except_begin( repoid ) &&
398 dc.except_end();
399 }
400
401 void _Marshaller_Components_InvalidConnection::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
402 {
403 ec.except_begin( "IDL:omg.org/Components/InvalidConnection:1.0" );
404 ec.except_end();
405 }
406
407 ::CORBA::StaticTypeInfo *_marshaller_Components_InvalidConnection;
408
409 void Components::InvalidConnection::_throwit() const
410 {
411 #ifdef HAVE_EXCEPTIONS
412 #ifdef HAVE_STD_EH
413 throw *this;
414 #else
415 throw InvalidConnection_var( (Components::InvalidConnection*)_clone() );
416 #endif
417 #else
418 CORBA::Exception::_throw_failed( _clone() );
419 #endif
420 }
421
422 const char *Components::InvalidConnection::_repoid() const
423 {
424 return "IDL:omg.org/Components/InvalidConnection:1.0";
425 }
426
427 void Components::InvalidConnection::_encode( CORBA::DataEncoder &_en ) const
428 {
429 _marshaller_Components_InvalidConnection->marshal( _en, (void*) this );
430 }
431
432 void Components::InvalidConnection::_encode_any( CORBA::Any & ) const
433 {
434
435 assert(0);
436 }
437
438 CORBA::Exception *Components::InvalidConnection::_clone() const
439 {
440 return new InvalidConnection( *this );
441 }
442
443 Components::InvalidConnection *Components::InvalidConnection::_downcast( CORBA::Exception *_ex )
444 {
445 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidConnection:1.0" ) )
446 return (InvalidConnection *) _ex;
447 return NULL;
448 }
449
450 const Components::InvalidConnection *Components::InvalidConnection::_downcast( const CORBA::Exception *_ex )
451 {
452 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidConnection:1.0" ) )
453 return (InvalidConnection *) _ex;
454 return NULL;
455 }
456
457
458 #ifdef HAVE_EXPLICIT_STRUCT_OPS
459 Components::NoConnection::NoConnection()
460 {
461 }
462
463 Components::NoConnection::NoConnection( const NoConnection& _s )
464 {
465 }
466
467 Components::NoConnection::~NoConnection()
468 {
469 }
470
471 Components::NoConnection&
472 Components::NoConnection::operator=( const NoConnection& _s )
473 {
474 return *this;
475 }
476 #endif
477
478 class _Marshaller_Components_NoConnection : public ::CORBA::StaticTypeInfo {
479 typedef ::Components::NoConnection _MICO_T;
480 public:
481 StaticValueType create () const;
482 void assign (StaticValueType dst, const StaticValueType src) const;
483 void free (StaticValueType) const;
484 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
485 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
486 };
487
488
489 ::CORBA::StaticValueType _Marshaller_Components_NoConnection::create() const
490 {
491 return (StaticValueType) new _MICO_T;
492 }
493
494 void _Marshaller_Components_NoConnection::assign( StaticValueType d, const StaticValueType s ) const
495 {
496 *(_MICO_T*) d = *(_MICO_T*) s;
497 }
498
499 void _Marshaller_Components_NoConnection::free( StaticValueType v ) const
500 {
501 delete (_MICO_T*) v;
502 }
503
504 ::CORBA::Boolean _Marshaller_Components_NoConnection::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
505 {
506 string repoid;
507 return
508 dc.except_begin( repoid ) &&
509 dc.except_end();
510 }
511
512 void _Marshaller_Components_NoConnection::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
513 {
514 ec.except_begin( "IDL:omg.org/Components/NoConnection:1.0" );
515 ec.except_end();
516 }
517
518 ::CORBA::StaticTypeInfo *_marshaller_Components_NoConnection;
519
520 void Components::NoConnection::_throwit() const
521 {
522 #ifdef HAVE_EXCEPTIONS
523 #ifdef HAVE_STD_EH
524 throw *this;
525 #else
526 throw NoConnection_var( (Components::NoConnection*)_clone() );
527 #endif
528 #else
529 CORBA::Exception::_throw_failed( _clone() );
530 #endif
531 }
532
533 const char *Components::NoConnection::_repoid() const
534 {
535 return "IDL:omg.org/Components/NoConnection:1.0";
536 }
537
538 void Components::NoConnection::_encode( CORBA::DataEncoder &_en ) const
539 {
540 _marshaller_Components_NoConnection->marshal( _en, (void*) this );
541 }
542
543 void Components::NoConnection::_encode_any( CORBA::Any & ) const
544 {
545
546 assert(0);
547 }
548
549 CORBA::Exception *Components::NoConnection::_clone() const
550 {
551 return new NoConnection( *this );
552 }
553
554 Components::NoConnection *Components::NoConnection::_downcast( CORBA::Exception *_ex )
555 {
556 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/NoConnection:1.0" ) )
557 return (NoConnection *) _ex;
558 return NULL;
559 }
560
561 const Components::NoConnection *Components::NoConnection::_downcast( const CORBA::Exception *_ex )
562 {
563 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/NoConnection:1.0" ) )
564 return (NoConnection *) _ex;
565 return NULL;
566 }
567
568
569 #ifdef HAVE_EXPLICIT_STRUCT_OPS
570 Components::ExceededConnectionLimit::ExceededConnectionLimit()
571 {
572 }
573
574 Components::ExceededConnectionLimit::ExceededConnectionLimit( const ExceededConnectionLimit& _s )
575 {
576 }
577
578 Components::ExceededConnectionLimit::~ExceededConnectionLimit()
579 {
580 }
581
582 Components::ExceededConnectionLimit&
583 Components::ExceededConnectionLimit::operator=( const ExceededConnectionLimit& _s )
584 {
585 return *this;
586 }
587 #endif
588
589 class _Marshaller_Components_ExceededConnectionLimit : public ::CORBA::StaticTypeInfo {
590 typedef ::Components::ExceededConnectionLimit _MICO_T;
591 public:
592 StaticValueType create () const;
593 void assign (StaticValueType dst, const StaticValueType src) const;
594 void free (StaticValueType) const;
595 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
596 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
597 };
598
599
600 ::CORBA::StaticValueType _Marshaller_Components_ExceededConnectionLimit::create() const
601 {
602 return (StaticValueType) new _MICO_T;
603 }
604
605 void _Marshaller_Components_ExceededConnectionLimit::assign( StaticValueType d, const StaticValueType s ) const
606 {
607 *(_MICO_T*) d = *(_MICO_T*) s;
608 }
609
610 void _Marshaller_Components_ExceededConnectionLimit::free( StaticValueType v ) const
611 {
612 delete (_MICO_T*) v;
613 }
614
615 ::CORBA::Boolean _Marshaller_Components_ExceededConnectionLimit::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
616 {
617 string repoid;
618 return
619 dc.except_begin( repoid ) &&
620 dc.except_end();
621 }
622
623 void _Marshaller_Components_ExceededConnectionLimit::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
624 {
625 ec.except_begin( "IDL:omg.org/Components/ExceededConnectionLimit:1.0" );
626 ec.except_end();
627 }
628
629 ::CORBA::StaticTypeInfo *_marshaller_Components_ExceededConnectionLimit;
630
631 void Components::ExceededConnectionLimit::_throwit() const
632 {
633 #ifdef HAVE_EXCEPTIONS
634 #ifdef HAVE_STD_EH
635 throw *this;
636 #else
637 throw ExceededConnectionLimit_var( (Components::ExceededConnectionLimit*)_clone() );
638 #endif
639 #else
640 CORBA::Exception::_throw_failed( _clone() );
641 #endif
642 }
643
644 const char *Components::ExceededConnectionLimit::_repoid() const
645 {
646 return "IDL:omg.org/Components/ExceededConnectionLimit:1.0";
647 }
648
649 void Components::ExceededConnectionLimit::_encode( CORBA::DataEncoder &_en ) const
650 {
651 _marshaller_Components_ExceededConnectionLimit->marshal( _en, (void*) this );
652 }
653
654 void Components::ExceededConnectionLimit::_encode_any( CORBA::Any & ) const
655 {
656
657 assert(0);
658 }
659
660 CORBA::Exception *Components::ExceededConnectionLimit::_clone() const
661 {
662 return new ExceededConnectionLimit( *this );
663 }
664
665 Components::ExceededConnectionLimit *Components::ExceededConnectionLimit::_downcast( CORBA::Exception *_ex )
666 {
667 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/ExceededConnectionLimit:1.0" ) )
668 return (ExceededConnectionLimit *) _ex;
669 return NULL;
670 }
671
672 const Components::ExceededConnectionLimit *Components::ExceededConnectionLimit::_downcast( const CORBA::Exception *_ex )
673 {
674 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/ExceededConnectionLimit:1.0" ) )
675 return (ExceededConnectionLimit *) _ex;
676 return NULL;
677 }
678
679
680 #ifdef HAVE_EXPLICIT_STRUCT_OPS
681 Components::CookieRequired::CookieRequired()
682 {
683 }
684
685 Components::CookieRequired::CookieRequired( const CookieRequired& _s )
686 {
687 }
688
689 Components::CookieRequired::~CookieRequired()
690 {
691 }
692
693 Components::CookieRequired&
694 Components::CookieRequired::operator=( const CookieRequired& _s )
695 {
696 return *this;
697 }
698 #endif
699
700 class _Marshaller_Components_CookieRequired : public ::CORBA::StaticTypeInfo {
701 typedef ::Components::CookieRequired _MICO_T;
702 public:
703 StaticValueType create () const;
704 void assign (StaticValueType dst, const StaticValueType src) const;
705 void free (StaticValueType) const;
706 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
707 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
708 };
709
710
711 ::CORBA::StaticValueType _Marshaller_Components_CookieRequired::create() const
712 {
713 return (StaticValueType) new _MICO_T;
714 }
715
716 void _Marshaller_Components_CookieRequired::assign( StaticValueType d, const StaticValueType s ) const
717 {
718 *(_MICO_T*) d = *(_MICO_T*) s;
719 }
720
721 void _Marshaller_Components_CookieRequired::free( StaticValueType v ) const
722 {
723 delete (_MICO_T*) v;
724 }
725
726 ::CORBA::Boolean _Marshaller_Components_CookieRequired::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
727 {
728 string repoid;
729 return
730 dc.except_begin( repoid ) &&
731 dc.except_end();
732 }
733
734 void _Marshaller_Components_CookieRequired::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
735 {
736 ec.except_begin( "IDL:omg.org/Components/CookieRequired:1.0" );
737 ec.except_end();
738 }
739
740 ::CORBA::StaticTypeInfo *_marshaller_Components_CookieRequired;
741
742 void Components::CookieRequired::_throwit() const
743 {
744 #ifdef HAVE_EXCEPTIONS
745 #ifdef HAVE_STD_EH
746 throw *this;
747 #else
748 throw CookieRequired_var( (Components::CookieRequired*)_clone() );
749 #endif
750 #else
751 CORBA::Exception::_throw_failed( _clone() );
752 #endif
753 }
754
755 const char *Components::CookieRequired::_repoid() const
756 {
757 return "IDL:omg.org/Components/CookieRequired:1.0";
758 }
759
760 void Components::CookieRequired::_encode( CORBA::DataEncoder &_en ) const
761 {
762 _marshaller_Components_CookieRequired->marshal( _en, (void*) this );
763 }
764
765 void Components::CookieRequired::_encode_any( CORBA::Any & ) const
766 {
767
768 assert(0);
769 }
770
771 CORBA::Exception *Components::CookieRequired::_clone() const
772 {
773 return new CookieRequired( *this );
774 }
775
776 Components::CookieRequired *Components::CookieRequired::_downcast( CORBA::Exception *_ex )
777 {
778 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/CookieRequired:1.0" ) )
779 return (CookieRequired *) _ex;
780 return NULL;
781 }
782
783 const Components::CookieRequired *Components::CookieRequired::_downcast( const CORBA::Exception *_ex )
784 {
785 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/CookieRequired:1.0" ) )
786 return (CookieRequired *) _ex;
787 return NULL;
788 }
789
790
791
792 Components::PortDescription::PortDescription ()
793 {
794 }
795
796 Components::PortDescription::~PortDescription ()
797 {
798 }
799
800 void *
801 Components::PortDescription::_narrow_helper (const char * repoid)
802 {
803 if (strcmp (repoid, "IDL:omg.org/Components/PortDescription:1.0") == 0) {
804 return (void *) this;
805 }
806 return NULL;
807 }
808
809 Components::PortDescription *
810 Components::PortDescription::_downcast (CORBA::ValueBase * vb)
811 {
812 void * p;
813 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/PortDescription:1.0")))) {
814 return (Components::PortDescription *) p;
815 }
816 return 0;
817 }
818
819 Components::PortDescription *
820 Components::PortDescription::_downcast (CORBA::AbstractBase * vb)
821 {
822 return _downcast (vb->_to_value());
823 }
824
825 CORBA::ValueDef_ptr
826 Components::PortDescription::get_value_def ()
827 {
828 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
829 CORBA::Object_var irobj =
830 orb->resolve_initial_references ("InterfaceRepository");
831 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
832 if (CORBA::is_nil (ifr)) {
833 return CORBA::ValueDef::_nil ();
834 }
835
836 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/PortDescription:1.0");
837 return CORBA::ValueDef::_narrow (cv);
838 }
839
840 void
841 Components::PortDescription::_copy_members (const PortDescription& other)
842 {
843 name (other.name());
844 type_id (other.type_id());
845 }
846
847 CORBA::ValueBase *
848 Components::PortDescription::_copy_value ()
849 {
850 vector<string> _dummy;
851 string _repo_id = "IDL:omg.org/Components/PortDescription:1.0";
852 PortDescription * _res = _downcast (_create (_dummy, _repo_id));
853 assert (_res != 0);
854 _res->_copy_members (*this);
855 return _res;
856 }
857
858 void
859 Components::PortDescription::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
860 {
861 repoids.push_back ("IDL:omg.org/Components/PortDescription:1.0");
862 chunked = FALSE;
863 }
864
865 void
866 Components::PortDescription::_marshal_members (CORBA::DataEncoder &ec)
867 {
868 const char * _name = name ();
869 CORBA::_stc_string->marshal (ec, &_name);
870 const char * _type_id = type_id ();
871 CORBA::_stc_string->marshal (ec, &_type_id);
872 }
873
874 CORBA::Boolean
875 Components::PortDescription::_demarshal_members (CORBA::DataDecoder &dc)
876 {
877 Components::FeatureName_var _name;
878 if (!CORBA::_stc_string->demarshal (dc, &_name._for_demarshal())) {
879 return FALSE;
880 }
881 name (_name);
882 CORBA::String_var _type_id;
883 if (!CORBA::_stc_string->demarshal (dc, &_type_id._for_demarshal())) {
884 return FALSE;
885 }
886 type_id (_type_id);
887 return TRUE;
888 }
889
890
891 class _Marshaller_Components_PortDescription : public ::CORBA::StaticTypeInfo {
892 typedef Components::PortDescription* _MICO_T;
893 public:
894 StaticValueType create () const;
895 void assign (StaticValueType dst, const StaticValueType src) const;
896 void free (StaticValueType) const;
897 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
898 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
899 };
900
901
902 ::CORBA::StaticValueType _Marshaller_Components_PortDescription::create() const
903 {
904 return (StaticValueType) new _MICO_T( 0 );
905 }
906
907 void _Marshaller_Components_PortDescription::assign( StaticValueType d, const StaticValueType s ) const
908 {
909 ::CORBA::remove_ref (*(_MICO_T*)d);
910 ::CORBA::add_ref (*(_MICO_T*)s);
911 *(_MICO_T*) d = *(_MICO_T*) s;
912 }
913
914 void _Marshaller_Components_PortDescription::free( StaticValueType v ) const
915 {
916 ::CORBA::remove_ref (*(_MICO_T*)v);
917 delete (_MICO_T*) v;
918 }
919
920 ::CORBA::Boolean _Marshaller_Components_PortDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
921 {
922 ::CORBA::ValueBase* vb = NULL;
923 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/PortDescription:1.0")) {
924 return FALSE;
925 }
926 *(_MICO_T *)v = ::Components::PortDescription::_downcast (vb);
927 if (vb && !*(_MICO_T *)v) {
928 ::CORBA::remove_ref (vb);
929 return FALSE;
930 }
931 return TRUE;
932 }
933
934 void _Marshaller_Components_PortDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
935 {
936 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
937 }
938
939 ::CORBA::StaticTypeInfo *_marshaller_Components_PortDescription;
940
941
942
943 OBV_Components::PortDescription::PortDescription ()
944 {
945 }
946
947 OBV_Components::PortDescription::PortDescription (const char* _name, const char* _type_id)
948 {
949 _m.name = _name;
950 _m.type_id = _type_id;
951 }
952
953 OBV_Components::PortDescription::~PortDescription ()
954 {
955 }
956
957 void OBV_Components::PortDescription::name( char *_p )
958 {
959 _m.name = _p;
960 }
961
962 void OBV_Components::PortDescription::name( const char *_p )
963 {
964 _m.name = _p;
965 }
966
967 void OBV_Components::PortDescription::name( const CORBA::String_var &_p )
968 {
969 _m.name = _p;
970 }
971
972 const char *OBV_Components::PortDescription::name() const
973 {
974 return _m.name;
975 }
976
977 void OBV_Components::PortDescription::type_id( char *_p )
978 {
979 _m.type_id = _p;
980 }
981
982 void OBV_Components::PortDescription::type_id( const char *_p )
983 {
984 _m.type_id = _p;
985 }
986
987 void OBV_Components::PortDescription::type_id( const CORBA::String_var &_p )
988 {
989 _m.type_id = _p;
990 }
991
992 const char *OBV_Components::PortDescription::type_id() const
993 {
994 return _m.type_id;
995 }
996
997
998
999 Components::Cookie::Cookie ()
1000 {
1001 }
1002
1003 Components::Cookie::~Cookie ()
1004 {
1005 }
1006
1007 void *
1008 Components::Cookie::_narrow_helper (const char * repoid)
1009 {
1010 if (strcmp (repoid, "IDL:omg.org/Components/Cookie:1.0") == 0) {
1011 return (void *) this;
1012 }
1013 return NULL;
1014 }
1015
1016 Components::Cookie *
1017 Components::Cookie::_downcast (CORBA::ValueBase * vb)
1018 {
1019 void * p;
1020 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/Cookie:1.0")))) {
1021 return (Components::Cookie *) p;
1022 }
1023 return 0;
1024 }
1025
1026 Components::Cookie *
1027 Components::Cookie::_downcast (CORBA::AbstractBase * vb)
1028 {
1029 return _downcast (vb->_to_value());
1030 }
1031
1032 CORBA::ValueDef_ptr
1033 Components::Cookie::get_value_def ()
1034 {
1035 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
1036 CORBA::Object_var irobj =
1037 orb->resolve_initial_references ("InterfaceRepository");
1038 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
1039 if (CORBA::is_nil (ifr)) {
1040 return CORBA::ValueDef::_nil ();
1041 }
1042
1043 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/Cookie:1.0");
1044 return CORBA::ValueDef::_narrow (cv);
1045 }
1046
1047 void
1048 Components::Cookie::_copy_members (const Cookie& other)
1049 {
1050 CookieValue (other.CookieValue());
1051 }
1052
1053 CORBA::ValueBase *
1054 Components::Cookie::_copy_value ()
1055 {
1056 vector<string> _dummy;
1057 string _repo_id = "IDL:omg.org/Components/Cookie:1.0";
1058 Cookie * _res = _downcast (_create (_dummy, _repo_id));
1059 assert (_res != 0);
1060 _res->_copy_members (*this);
1061 return _res;
1062 }
1063
1064 void
1065 Components::Cookie::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
1066 {
1067 repoids.push_back ("IDL:omg.org/Components/Cookie:1.0");
1068 chunked = FALSE;
1069 }
1070
1071 void
1072 Components::Cookie::_marshal_members (CORBA::DataEncoder &ec)
1073 {
1074 _CookieValue_seq & _CookieValue = CookieValue ();
1075 CORBA::_stcseq_octet->marshal (ec, &_CookieValue);
1076 }
1077
1078 CORBA::Boolean
1079 Components::Cookie::_demarshal_members (CORBA::DataDecoder &dc)
1080 {
1081 SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> _CookieValue;
1082 if (!CORBA::_stcseq_octet->demarshal (dc, &_CookieValue)) {
1083 return FALSE;
1084 }
1085 CookieValue (_CookieValue);
1086 return TRUE;
1087 }
1088
1089
1090 class _Marshaller_Components_Cookie : public ::CORBA::StaticTypeInfo {
1091 typedef Components::Cookie* _MICO_T;
1092 public:
1093 StaticValueType create () const;
1094 void assign (StaticValueType dst, const StaticValueType src) const;
1095 void free (StaticValueType) const;
1096 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1097 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1098 };
1099
1100
1101 ::CORBA::StaticValueType _Marshaller_Components_Cookie::create() const
1102 {
1103 return (StaticValueType) new _MICO_T( 0 );
1104 }
1105
1106 void _Marshaller_Components_Cookie::assign( StaticValueType d, const StaticValueType s ) const
1107 {
1108 ::CORBA::remove_ref (*(_MICO_T*)d);
1109 ::CORBA::add_ref (*(_MICO_T*)s);
1110 *(_MICO_T*) d = *(_MICO_T*) s;
1111 }
1112
1113 void _Marshaller_Components_Cookie::free( StaticValueType v ) const
1114 {
1115 ::CORBA::remove_ref (*(_MICO_T*)v);
1116 delete (_MICO_T*) v;
1117 }
1118
1119 ::CORBA::Boolean _Marshaller_Components_Cookie::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1120 {
1121 ::CORBA::ValueBase* vb = NULL;
1122 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/Cookie:1.0")) {
1123 return FALSE;
1124 }
1125 *(_MICO_T *)v = ::Components::Cookie::_downcast (vb);
1126 if (vb && !*(_MICO_T *)v) {
1127 ::CORBA::remove_ref (vb);
1128 return FALSE;
1129 }
1130 return TRUE;
1131 }
1132
1133 void _Marshaller_Components_Cookie::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1134 {
1135 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
1136 }
1137
1138 ::CORBA::StaticTypeInfo *_marshaller_Components_Cookie;
1139
1140
1141
1142 OBV_Components::Cookie::Cookie ()
1143 {
1144 }
1145
1146 OBV_Components::Cookie::Cookie (const _CookieValue_seq& _CookieValue)
1147 {
1148 _m.CookieValue = _CookieValue;
1149 }
1150
1151 OBV_Components::Cookie::~Cookie ()
1152 {
1153 }
1154
1155 void OBV_Components::Cookie::CookieValue( const SequenceTmpl< CORBA::Octet,MICO_TID_OCTET>& _p )
1156 {
1157 _m.CookieValue = _p;
1158 }
1159
1160 const OBV_Components::Cookie::_CookieValue_seq& OBV_Components::Cookie::CookieValue() const
1161 {
1162 return _m.CookieValue;
1163 }
1164
1165 OBV_Components::Cookie::_CookieValue_seq& OBV_Components::Cookie::CookieValue()
1166 {
1167 return _m.CookieValue;
1168 }
1169
1170
1171
1172 Components::EventBase::EventBase ()
1173 {
1174 }
1175
1176 Components::EventBase::~EventBase ()
1177 {
1178 }
1179
1180 void *
1181 Components::EventBase::_narrow_helper (const char * repoid)
1182 {
1183 if (strcmp (repoid, "IDL:omg.org/Components/EventBase:1.0") == 0) {
1184 return (void *) this;
1185 }
1186 return NULL;
1187 }
1188
1189 Components::EventBase *
1190 Components::EventBase::_downcast (CORBA::ValueBase * vb)
1191 {
1192 void * p;
1193 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/EventBase:1.0")))) {
1194 return (Components::EventBase *) p;
1195 }
1196 return 0;
1197 }
1198
1199 Components::EventBase *
1200 Components::EventBase::_downcast (CORBA::AbstractBase * vb)
1201 {
1202 return _downcast (vb->_to_value());
1203 }
1204
1205 CORBA::ValueDef_ptr
1206 Components::EventBase::get_value_def ()
1207 {
1208 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
1209 CORBA::Object_var irobj =
1210 orb->resolve_initial_references ("InterfaceRepository");
1211 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
1212 if (CORBA::is_nil (ifr)) {
1213 return CORBA::ValueDef::_nil ();
1214 }
1215
1216 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/EventBase:1.0");
1217 return CORBA::ValueDef::_narrow (cv);
1218 }
1219
1220 void
1221 Components::EventBase::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
1222 {
1223 repoids.push_back ("IDL:omg.org/Components/EventBase:1.0");
1224 chunked = FALSE;
1225 }
1226
1227 void
1228 Components::EventBase::_marshal_members (CORBA::DataEncoder &ec)
1229 {
1230 }
1231
1232 CORBA::Boolean
1233 Components::EventBase::_demarshal_members (CORBA::DataDecoder &dc)
1234 {
1235 return TRUE;
1236 }
1237
1238
1239 class _Marshaller_Components_EventBase : public ::CORBA::StaticTypeInfo {
1240 typedef Components::EventBase* _MICO_T;
1241 public:
1242 StaticValueType create () const;
1243 void assign (StaticValueType dst, const StaticValueType src) const;
1244 void free (StaticValueType) const;
1245 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1246 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1247 };
1248
1249
1250 ::CORBA::StaticValueType _Marshaller_Components_EventBase::create() const
1251 {
1252 return (StaticValueType) new _MICO_T( 0 );
1253 }
1254
1255 void _Marshaller_Components_EventBase::assign( StaticValueType d, const StaticValueType s ) const
1256 {
1257 ::CORBA::remove_ref (*(_MICO_T*)d);
1258 ::CORBA::add_ref (*(_MICO_T*)s);
1259 *(_MICO_T*) d = *(_MICO_T*) s;
1260 }
1261
1262 void _Marshaller_Components_EventBase::free( StaticValueType v ) const
1263 {
1264 ::CORBA::remove_ref (*(_MICO_T*)v);
1265 delete (_MICO_T*) v;
1266 }
1267
1268 ::CORBA::Boolean _Marshaller_Components_EventBase::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1269 {
1270 ::CORBA::ValueBase* vb = NULL;
1271 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/EventBase:1.0")) {
1272 return FALSE;
1273 }
1274 *(_MICO_T *)v = ::Components::EventBase::_downcast (vb);
1275 if (vb && !*(_MICO_T *)v) {
1276 ::CORBA::remove_ref (vb);
1277 return FALSE;
1278 }
1279 return TRUE;
1280 }
1281
1282 void _Marshaller_Components_EventBase::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1283 {
1284 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
1285 }
1286
1287 ::CORBA::StaticTypeInfo *_marshaller_Components_EventBase;
1288
1289
1290
1291 Components::FacetDescription::FacetDescription ()
1292 {
1293 }
1294
1295 Components::FacetDescription::~FacetDescription ()
1296 {
1297 }
1298
1299 void *
1300 Components::FacetDescription::_narrow_helper (const char * repoid)
1301 {
1302 void * p;
1303 if (strcmp (repoid, "IDL:omg.org/Components/FacetDescription:1.0") == 0) {
1304 return (void *) this;
1305 }
1306 if ((p = Components::PortDescription::_narrow_helper (repoid)) != NULL) {
1307 return p;
1308 }
1309 return NULL;
1310 }
1311
1312 Components::FacetDescription *
1313 Components::FacetDescription::_downcast (CORBA::ValueBase * vb)
1314 {
1315 void * p;
1316 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/FacetDescription:1.0")))) {
1317 return (Components::FacetDescription *) p;
1318 }
1319 return 0;
1320 }
1321
1322 Components::FacetDescription *
1323 Components::FacetDescription::_downcast (CORBA::AbstractBase * vb)
1324 {
1325 return _downcast (vb->_to_value());
1326 }
1327
1328 CORBA::ValueDef_ptr
1329 Components::FacetDescription::get_value_def ()
1330 {
1331 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
1332 CORBA::Object_var irobj =
1333 orb->resolve_initial_references ("InterfaceRepository");
1334 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
1335 if (CORBA::is_nil (ifr)) {
1336 return CORBA::ValueDef::_nil ();
1337 }
1338
1339 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/FacetDescription:1.0");
1340 return CORBA::ValueDef::_narrow (cv);
1341 }
1342
1343 void
1344 Components::FacetDescription::_copy_members (const FacetDescription& other)
1345 {
1346 facet_ref (other.facet_ref());
1347 }
1348
1349 CORBA::ValueBase *
1350 Components::FacetDescription::_copy_value ()
1351 {
1352 vector<string> _dummy;
1353 string _repo_id = "IDL:omg.org/Components/FacetDescription:1.0";
1354 FacetDescription * _res = _downcast (_create (_dummy, _repo_id));
1355 assert (_res != 0);
1356 _res->Components::PortDescription::_copy_members (*this);
1357 _res->_copy_members (*this);
1358 return _res;
1359 }
1360
1361 void
1362 Components::FacetDescription::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
1363 {
1364 repoids.push_back ("IDL:omg.org/Components/FacetDescription:1.0");
1365 chunked = FALSE;
1366 }
1367
1368 void
1369 Components::FacetDescription::_marshal_members (CORBA::DataEncoder &ec)
1370 {
1371 Components::PortDescription::_marshal_members (ec);
1372 CORBA::Object_ptr _facet_ref = facet_ref ();
1373 CORBA::_stc_Object->marshal (ec, &_facet_ref);
1374 }
1375
1376 CORBA::Boolean
1377 Components::FacetDescription::_demarshal_members (CORBA::DataDecoder &dc)
1378 {
1379 if (!Components::PortDescription::_demarshal_members (dc)) {
1380 return FALSE;
1381 }
1382 CORBA::Object_var _facet_ref;
1383 if (!CORBA::_stc_Object->demarshal (dc, &_facet_ref._for_demarshal())) {
1384 return FALSE;
1385 }
1386 facet_ref (_facet_ref);
1387 return TRUE;
1388 }
1389
1390
1391 class _Marshaller_Components_FacetDescription : public ::CORBA::StaticTypeInfo {
1392 typedef Components::FacetDescription* _MICO_T;
1393 public:
1394 StaticValueType create () const;
1395 void assign (StaticValueType dst, const StaticValueType src) const;
1396 void free (StaticValueType) const;
1397 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1398 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1399 };
1400
1401
1402 ::CORBA::StaticValueType _Marshaller_Components_FacetDescription::create() const
1403 {
1404 return (StaticValueType) new _MICO_T( 0 );
1405 }
1406
1407 void _Marshaller_Components_FacetDescription::assign( StaticValueType d, const StaticValueType s ) const
1408 {
1409 ::CORBA::remove_ref (*(_MICO_T*)d);
1410 ::CORBA::add_ref (*(_MICO_T*)s);
1411 *(_MICO_T*) d = *(_MICO_T*) s;
1412 }
1413
1414 void _Marshaller_Components_FacetDescription::free( StaticValueType v ) const
1415 {
1416 ::CORBA::remove_ref (*(_MICO_T*)v);
1417 delete (_MICO_T*) v;
1418 }
1419
1420 ::CORBA::Boolean _Marshaller_Components_FacetDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1421 {
1422 ::CORBA::ValueBase* vb = NULL;
1423 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/FacetDescription:1.0")) {
1424 return FALSE;
1425 }
1426 *(_MICO_T *)v = ::Components::FacetDescription::_downcast (vb);
1427 if (vb && !*(_MICO_T *)v) {
1428 ::CORBA::remove_ref (vb);
1429 return FALSE;
1430 }
1431 return TRUE;
1432 }
1433
1434 void _Marshaller_Components_FacetDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1435 {
1436 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
1437 }
1438
1439 ::CORBA::StaticTypeInfo *_marshaller_Components_FacetDescription;
1440
1441
1442
1443 OBV_Components::FacetDescription::FacetDescription ()
1444 {
1445 }
1446
1447 OBV_Components::FacetDescription::FacetDescription (CORBA::Object_ptr _facet_ref)
1448 {
1449 _m.facet_ref = CORBA::Object::_duplicate( _facet_ref );
1450 }
1451
1452 OBV_Components::FacetDescription::~FacetDescription ()
1453 {
1454 }
1455
1456 void OBV_Components::FacetDescription::facet_ref( CORBA::Object_ptr _p )
1457 {
1458 _m.facet_ref = CORBA::Object::_duplicate( _p );
1459 }
1460
1461 CORBA::Object_ptr OBV_Components::FacetDescription::facet_ref() const
1462 {
1463 return _m.facet_ref.in();
1464 }
1465
1466
1467
1468
1469
1470 Components::Navigation::~Navigation()
1471 {
1472 }
1473
1474 void *
1475 Components::Navigation::_narrow_helper( const char *_repoid )
1476 {
1477 if( strcmp( _repoid, "IDL:omg.org/Components/Navigation:1.0" ) == 0 )
1478 return (void *)this;
1479 return NULL;
1480 }
1481
1482 Components::Navigation_ptr
1483 Components::Navigation::_narrow( CORBA::Object_ptr _obj )
1484 {
1485 Components::Navigation_ptr _o;
1486 if( !CORBA::is_nil( _obj ) ) {
1487 void *_p;
1488 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/Navigation:1.0" )))
1489 return _duplicate( (Components::Navigation_ptr) _p );
1490 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/Navigation:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/Navigation:1.0")) {
1491 _o = new Components::Navigation_stub;
1492 _o->CORBA::Object::operator=( *_obj );
1493 return _o;
1494 }
1495 }
1496 return _nil();
1497 }
1498
1499 Components::Navigation_ptr
1500 Components::Navigation::_narrow( CORBA::AbstractBase_ptr _obj )
1501 {
1502 return _narrow (_obj->_to_object());
1503 }
1504
1505 class _Marshaller_Components_Navigation : public ::CORBA::StaticTypeInfo {
1506 typedef Components::Navigation_ptr _MICO_T;
1507 public:
1508 StaticValueType create () const;
1509 void assign (StaticValueType dst, const StaticValueType src) const;
1510 void free (StaticValueType) const;
1511 void release (StaticValueType) const;
1512 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1513 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1514 };
1515
1516
1517 ::CORBA::StaticValueType _Marshaller_Components_Navigation::create() const
1518 {
1519 return (StaticValueType) new _MICO_T( 0 );
1520 }
1521
1522 void _Marshaller_Components_Navigation::assign( StaticValueType d, const StaticValueType s ) const
1523 {
1524 *(_MICO_T*) d = ::Components::Navigation::_duplicate( *(_MICO_T*) s );
1525 }
1526
1527 void _Marshaller_Components_Navigation::free( StaticValueType v ) const
1528 {
1529 ::CORBA::release( *(_MICO_T *) v );
1530 delete (_MICO_T*) v;
1531 }
1532
1533 void _Marshaller_Components_Navigation::release( StaticValueType v ) const
1534 {
1535 ::CORBA::release( *(_MICO_T *) v );
1536 }
1537
1538 ::CORBA::Boolean _Marshaller_Components_Navigation::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1539 {
1540 ::CORBA::Object_ptr obj;
1541 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
1542 return FALSE;
1543 *(_MICO_T *) v = ::Components::Navigation::_narrow( obj );
1544 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
1545 ::CORBA::release (obj);
1546 return ret;
1547 }
1548
1549 void _Marshaller_Components_Navigation::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1550 {
1551 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
1552 ::CORBA::_stc_Object->marshal( ec, &obj );
1553 }
1554
1555 ::CORBA::StaticTypeInfo *_marshaller_Components_Navigation;
1556
1557
1558
1559
1560 Components::Navigation_stub::~Navigation_stub()
1561 {
1562 }
1563
1564 #ifndef MICO_CONF_NO_POA
1565
1566 void *
1567 POA_Components::Navigation::_narrow_helper (const char * repoid)
1568 {
1569 if (strcmp (repoid, "IDL:omg.org/Components/Navigation:1.0") == 0) {
1570 return (void *) this;
1571 }
1572 return NULL;
1573 }
1574
1575 POA_Components::Navigation *
1576 POA_Components::Navigation::_narrow (PortableServer::Servant serv)
1577 {
1578 void * p;
1579 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/Navigation:1.0")) != NULL) {
1580 serv->_add_ref ();
1581 return (POA_Components::Navigation *) p;
1582 }
1583 return NULL;
1584 }
1585
1586 Components::Navigation_stub_clp::Navigation_stub_clp ()
1587 {
1588 }
1589
1590 Components::Navigation_stub_clp::Navigation_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
1591 : CORBA::Object(*obj), PortableServer::StubBase(poa)
1592 {
1593 }
1594
1595 Components::Navigation_stub_clp::~Navigation_stub_clp ()
1596 {
1597 }
1598
1599 #endif // MICO_CONF_NO_POA
1600
1601 CORBA::Object_ptr Components::Navigation_stub::provide_facet( const char* _par_name )
1602 {
1603 CORBA::StaticAny _sa_name( CORBA::_stc_string, &_par_name );
1604 CORBA::Object_ptr _res;
1605 CORBA::StaticAny __res( CORBA::_stc_Object, &_res );
1606
1607 CORBA::StaticRequest __req( this, "provide_facet" );
1608 __req.add_in_arg( &_sa_name );
1609 __req.set_result( &__res );
1610
1611 __req.invoke();
1612
1613 mico_sii_throw( &__req,
1614 _marshaller_Components_InvalidName, "IDL:omg.org/Components/InvalidName:1.0",
1615 0);
1616 return _res;
1617 }
1618
1619
1620 #ifndef MICO_CONF_NO_POA
1621
1622 CORBA::Object_ptr
1623 Components::Navigation_stub_clp::provide_facet( const char* _par_name )
1624 {
1625 PortableServer::Servant _serv = _preinvoke ();
1626 if (_serv) {
1627 POA_Components::Navigation * _myserv = POA_Components::Navigation::_narrow (_serv);
1628 if (_myserv) {
1629 CORBA::Object_ptr __res;
1630
1631 #ifdef HAVE_EXCEPTIONS
1632 try {
1633 #endif
1634 __res = _myserv->provide_facet(_par_name);
1635 #ifdef HAVE_EXCEPTIONS
1636 }
1637 catch (...) {
1638 _myserv->_remove_ref();
1639 _postinvoke();
1640 throw;
1641 }
1642 #endif
1643
1644 _myserv->_remove_ref();
1645 _postinvoke ();
1646 return __res;
1647 }
1648 _postinvoke ();
1649 }
1650
1651 return Components::Navigation_stub::provide_facet(_par_name);
1652 }
1653
1654 #endif // MICO_CONF_NO_POA
1655
1656 Components::FacetDescriptions* Components::Navigation_stub::get_all_facets()
1657 {
1658 CORBA::StaticAny __res( _marshaller__seq_Components_FacetDescription );
1659
1660 CORBA::StaticRequest __req( this, "get_all_facets" );
1661 __req.set_result( &__res );
1662
1663 __req.invoke();
1664
1665 mico_sii_throw( &__req,
1666 0);
1667 return (Components::FacetDescriptions*) __res._retn();
1668 }
1669
1670
1671 #ifndef MICO_CONF_NO_POA
1672
1673 Components::FacetDescriptions*
1674 Components::Navigation_stub_clp::get_all_facets()
1675 {
1676 return Components::Navigation_stub::get_all_facets();
1677 }
1678
1679 #endif // MICO_CONF_NO_POA
1680
1681 Components::FacetDescriptions* Components::Navigation_stub::get_named_facets( const Components::NameList& _par_names )
1682 {
1683 CORBA::StaticAny _sa_names( CORBA::_stcseq_string, &_par_names );
1684 CORBA::StaticAny __res( _marshaller__seq_Components_FacetDescription );
1685
1686 CORBA::StaticRequest __req( this, "get_named_facets" );
1687 __req.add_in_arg( &_sa_names );
1688 __req.set_result( &__res );
1689
1690 __req.invoke();
1691
1692 mico_sii_throw( &__req,
1693 _marshaller_Components_InvalidName, "IDL:omg.org/Components/InvalidName:1.0",
1694 0);
1695 return (Components::FacetDescriptions*) __res._retn();
1696 }
1697
1698
1699 #ifndef MICO_CONF_NO_POA
1700
1701 Components::FacetDescriptions*
1702 Components::Navigation_stub_clp::get_named_facets( const Components::NameList& _par_names )
1703 {
1704 return Components::Navigation_stub::get_named_facets(_par_names);
1705 }
1706
1707 #endif // MICO_CONF_NO_POA
1708
1709 CORBA::Boolean Components::Navigation_stub::same_component( CORBA::Object_ptr _par_ref )
1710 {
1711 CORBA::StaticAny _sa_ref( CORBA::_stc_Object, &_par_ref );
1712 CORBA::Boolean _res;
1713 CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
1714
1715 CORBA::StaticRequest __req( this, "same_component" );
1716 __req.add_in_arg( &_sa_ref );
1717 __req.set_result( &__res );
1718
1719 __req.invoke();
1720
1721 mico_sii_throw( &__req,
1722 0);
1723 return _res;
1724 }
1725
1726
1727 #ifndef MICO_CONF_NO_POA
1728
1729 CORBA::Boolean
1730 Components::Navigation_stub_clp::same_component( CORBA::Object_ptr _par_ref )
1731 {
1732 PortableServer::Servant _serv = _preinvoke ();
1733 if (_serv) {
1734 POA_Components::Navigation * _myserv = POA_Components::Navigation::_narrow (_serv);
1735 if (_myserv) {
1736 CORBA::Boolean __res;
1737
1738 #ifdef HAVE_EXCEPTIONS
1739 try {
1740 #endif
1741 __res = _myserv->same_component(_par_ref);
1742 #ifdef HAVE_EXCEPTIONS
1743 }
1744 catch (...) {
1745 _myserv->_remove_ref();
1746 _postinvoke();
1747 throw;
1748 }
1749 #endif
1750
1751 _myserv->_remove_ref();
1752 _postinvoke ();
1753 return __res;
1754 }
1755 _postinvoke ();
1756 }
1757
1758 return Components::Navigation_stub::same_component(_par_ref);
1759 }
1760
1761 #endif // MICO_CONF_NO_POA
1762
1763
1764
1765 Components::ConnectionDescription::ConnectionDescription ()
1766 {
1767 }
1768
1769 Components::ConnectionDescription::~ConnectionDescription ()
1770 {
1771 }
1772
1773 void *
1774 Components::ConnectionDescription::_narrow_helper (const char * repoid)
1775 {
1776 if (strcmp (repoid, "IDL:omg.org/Components/ConnectionDescription:1.0") == 0) {
1777 return (void *) this;
1778 }
1779 return NULL;
1780 }
1781
1782 Components::ConnectionDescription *
1783 Components::ConnectionDescription::_downcast (CORBA::ValueBase * vb)
1784 {
1785 void * p;
1786 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/ConnectionDescription:1.0")))) {
1787 return (Components::ConnectionDescription *) p;
1788 }
1789 return 0;
1790 }
1791
1792 Components::ConnectionDescription *
1793 Components::ConnectionDescription::_downcast (CORBA::AbstractBase * vb)
1794 {
1795 return _downcast (vb->_to_value());
1796 }
1797
1798 CORBA::ValueDef_ptr
1799 Components::ConnectionDescription::get_value_def ()
1800 {
1801 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
1802 CORBA::Object_var irobj =
1803 orb->resolve_initial_references ("InterfaceRepository");
1804 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
1805 if (CORBA::is_nil (ifr)) {
1806 return CORBA::ValueDef::_nil ();
1807 }
1808
1809 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/ConnectionDescription:1.0");
1810 return CORBA::ValueDef::_narrow (cv);
1811 }
1812
1813 void
1814 Components::ConnectionDescription::_copy_members (const ConnectionDescription& other)
1815 {
1816 Components::Cookie_var _ck = Components::Cookie::_downcast (other.ck()->_copy_value());
1817 ck (_ck);
1818 objref (other.objref());
1819 }
1820
1821 CORBA::ValueBase *
1822 Components::ConnectionDescription::_copy_value ()
1823 {
1824 vector<string> _dummy;
1825 string _repo_id = "IDL:omg.org/Components/ConnectionDescription:1.0";
1826 ConnectionDescription * _res = _downcast (_create (_dummy, _repo_id));
1827 assert (_res != 0);
1828 _res->_copy_members (*this);
1829 return _res;
1830 }
1831
1832 void
1833 Components::ConnectionDescription::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
1834 {
1835 repoids.push_back ("IDL:omg.org/Components/ConnectionDescription:1.0");
1836 chunked = FALSE;
1837 }
1838
1839 void
1840 Components::ConnectionDescription::_marshal_members (CORBA::DataEncoder &ec)
1841 {
1842 Components::Cookie* _ck = ck ();
1843 _marshaller_Components_Cookie->marshal (ec, &_ck);
1844 CORBA::Object_ptr _objref = objref ();
1845 CORBA::_stc_Object->marshal (ec, &_objref);
1846 }
1847
1848 CORBA::Boolean
1849 Components::ConnectionDescription::_demarshal_members (CORBA::DataDecoder &dc)
1850 {
1851 Components::Cookie_var _ck;
1852 if (!_marshaller_Components_Cookie->demarshal (dc, &_ck._for_demarshal())) {
1853 return FALSE;
1854 }
1855 ck (_ck);
1856 CORBA::Object_var _objref;
1857 if (!CORBA::_stc_Object->demarshal (dc, &_objref._for_demarshal())) {
1858 return FALSE;
1859 }
1860 objref (_objref);
1861 return TRUE;
1862 }
1863
1864
1865 class _Marshaller_Components_ConnectionDescription : public ::CORBA::StaticTypeInfo {
1866 typedef Components::ConnectionDescription* _MICO_T;
1867 public:
1868 StaticValueType create () const;
1869 void assign (StaticValueType dst, const StaticValueType src) const;
1870 void free (StaticValueType) const;
1871 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1872 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1873 };
1874
1875
1876 ::CORBA::StaticValueType _Marshaller_Components_ConnectionDescription::create() const
1877 {
1878 return (StaticValueType) new _MICO_T( 0 );
1879 }
1880
1881 void _Marshaller_Components_ConnectionDescription::assign( StaticValueType d, const StaticValueType s ) const
1882 {
1883 ::CORBA::remove_ref (*(_MICO_T*)d);
1884 ::CORBA::add_ref (*(_MICO_T*)s);
1885 *(_MICO_T*) d = *(_MICO_T*) s;
1886 }
1887
1888 void _Marshaller_Components_ConnectionDescription::free( StaticValueType v ) const
1889 {
1890 ::CORBA::remove_ref (*(_MICO_T*)v);
1891 delete (_MICO_T*) v;
1892 }
1893
1894 ::CORBA::Boolean _Marshaller_Components_ConnectionDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1895 {
1896 ::CORBA::ValueBase* vb = NULL;
1897 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/ConnectionDescription:1.0")) {
1898 return FALSE;
1899 }
1900 *(_MICO_T *)v = ::Components::ConnectionDescription::_downcast (vb);
1901 if (vb && !*(_MICO_T *)v) {
1902 ::CORBA::remove_ref (vb);
1903 return FALSE;
1904 }
1905 return TRUE;
1906 }
1907
1908 void _Marshaller_Components_ConnectionDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1909 {
1910 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
1911 }
1912
1913 ::CORBA::StaticTypeInfo *_marshaller_Components_ConnectionDescription;
1914
1915
1916
1917 OBV_Components::ConnectionDescription::ConnectionDescription ()
1918 {
1919 }
1920
1921 OBV_Components::ConnectionDescription::ConnectionDescription (::Components::Cookie* _ck, CORBA::Object_ptr _objref)
1922 {
1923 CORBA::add_ref ( _ck );
1924 _m.ck = _ck;
1925 _m.objref = CORBA::Object::_duplicate( _objref );
1926 }
1927
1928 OBV_Components::ConnectionDescription::~ConnectionDescription ()
1929 {
1930 }
1931
1932 void OBV_Components::ConnectionDescription::ck( ::Components::Cookie* _p )
1933 {
1934 CORBA::add_ref ( _p );
1935 _m.ck = _p;
1936 }
1937
1938 ::Components::Cookie* OBV_Components::ConnectionDescription::ck() const
1939 {
1940 return _m.ck.in();
1941 }
1942
1943 void OBV_Components::ConnectionDescription::objref( CORBA::Object_ptr _p )
1944 {
1945 _m.objref = CORBA::Object::_duplicate( _p );
1946 }
1947
1948 CORBA::Object_ptr OBV_Components::ConnectionDescription::objref() const
1949 {
1950 return _m.objref.in();
1951 }
1952
1953
1954
1955
1956 Components::ReceptacleDescription::ReceptacleDescription ()
1957 {
1958 }
1959
1960 Components::ReceptacleDescription::~ReceptacleDescription ()
1961 {
1962 }
1963
1964 void *
1965 Components::ReceptacleDescription::_narrow_helper (const char * repoid)
1966 {
1967 void * p;
1968 if (strcmp (repoid, "IDL:omg.org/Components/ReceptacleDescription:1.0") == 0) {
1969 return (void *) this;
1970 }
1971 if ((p = Components::PortDescription::_narrow_helper (repoid)) != NULL) {
1972 return p;
1973 }
1974 return NULL;
1975 }
1976
1977 Components::ReceptacleDescription *
1978 Components::ReceptacleDescription::_downcast (CORBA::ValueBase * vb)
1979 {
1980 void * p;
1981 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/ReceptacleDescription:1.0")))) {
1982 return (Components::ReceptacleDescription *) p;
1983 }
1984 return 0;
1985 }
1986
1987 Components::ReceptacleDescription *
1988 Components::ReceptacleDescription::_downcast (CORBA::AbstractBase * vb)
1989 {
1990 return _downcast (vb->_to_value());
1991 }
1992
1993 CORBA::ValueDef_ptr
1994 Components::ReceptacleDescription::get_value_def ()
1995 {
1996 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
1997 CORBA::Object_var irobj =
1998 orb->resolve_initial_references ("InterfaceRepository");
1999 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
2000 if (CORBA::is_nil (ifr)) {
2001 return CORBA::ValueDef::_nil ();
2002 }
2003
2004 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/ReceptacleDescription:1.0");
2005 return CORBA::ValueDef::_narrow (cv);
2006 }
2007
2008 void
2009 Components::ReceptacleDescription::_copy_members (const ReceptacleDescription& other)
2010 {
2011 is_multiplex (other.is_multiplex());
2012 connections (other.connections());
2013 }
2014
2015 CORBA::ValueBase *
2016 Components::ReceptacleDescription::_copy_value ()
2017 {
2018 vector<string> _dummy;
2019 string _repo_id = "IDL:omg.org/Components/ReceptacleDescription:1.0";
2020 ReceptacleDescription * _res = _downcast (_create (_dummy, _repo_id));
2021 assert (_res != 0);
2022 _res->Components::PortDescription::_copy_members (*this);
2023 _res->_copy_members (*this);
2024 return _res;
2025 }
2026
2027 void
2028 Components::ReceptacleDescription::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
2029 {
2030 repoids.push_back ("IDL:omg.org/Components/ReceptacleDescription:1.0");
2031 chunked = FALSE;
2032 }
2033
2034 void
2035 Components::ReceptacleDescription::_marshal_members (CORBA::DataEncoder &ec)
2036 {
2037 Components::PortDescription::_marshal_members (ec);
2038 CORBA::Boolean _is_multiplex = is_multiplex ();
2039 CORBA::_stc_boolean->marshal (ec, &_is_multiplex);
2040 Components::ConnectionDescriptions& _connections = connections ();
2041 _marshaller__seq_Components_ConnectionDescription->marshal (ec, &_connections);
2042 }
2043
2044 CORBA::Boolean
2045 Components::ReceptacleDescription::_demarshal_members (CORBA::DataDecoder &dc)
2046 {
2047 if (!Components::PortDescription::_demarshal_members (dc)) {
2048 return FALSE;
2049 }
2050 CORBA::Boolean _is_multiplex;
2051 if (!CORBA::_stc_boolean->demarshal (dc, &_is_multiplex)) {
2052 return FALSE;
2053 }
2054 is_multiplex (_is_multiplex);
2055 Components::ConnectionDescriptions _connections;
2056 if (!_marshaller__seq_Components_ConnectionDescription->demarshal (dc, &_connections)) {
2057 return FALSE;
2058 }
2059 connections (_connections);
2060 return TRUE;
2061 }
2062
2063
2064 class _Marshaller_Components_ReceptacleDescription : public ::CORBA::StaticTypeInfo {
2065 typedef Components::ReceptacleDescription* _MICO_T;
2066 public:
2067 StaticValueType create () const;
2068 void assign (StaticValueType dst, const StaticValueType src) const;
2069 void free (StaticValueType) const;
2070 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2071 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2072 };
2073
2074
2075 ::CORBA::StaticValueType _Marshaller_Components_ReceptacleDescription::create() const
2076 {
2077 return (StaticValueType) new _MICO_T( 0 );
2078 }
2079
2080 void _Marshaller_Components_ReceptacleDescription::assign( StaticValueType d, const StaticValueType s ) const
2081 {
2082 ::CORBA::remove_ref (*(_MICO_T*)d);
2083 ::CORBA::add_ref (*(_MICO_T*)s);
2084 *(_MICO_T*) d = *(_MICO_T*) s;
2085 }
2086
2087 void _Marshaller_Components_ReceptacleDescription::free( StaticValueType v ) const
2088 {
2089 ::CORBA::remove_ref (*(_MICO_T*)v);
2090 delete (_MICO_T*) v;
2091 }
2092
2093 ::CORBA::Boolean _Marshaller_Components_ReceptacleDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2094 {
2095 ::CORBA::ValueBase* vb = NULL;
2096 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/ReceptacleDescription:1.0")) {
2097 return FALSE;
2098 }
2099 *(_MICO_T *)v = ::Components::ReceptacleDescription::_downcast (vb);
2100 if (vb && !*(_MICO_T *)v) {
2101 ::CORBA::remove_ref (vb);
2102 return FALSE;
2103 }
2104 return TRUE;
2105 }
2106
2107 void _Marshaller_Components_ReceptacleDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2108 {
2109 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
2110 }
2111
2112 ::CORBA::StaticTypeInfo *_marshaller_Components_ReceptacleDescription;
2113
2114
2115
2116 OBV_Components::ReceptacleDescription::ReceptacleDescription ()
2117 {
2118 }
2119
2120 OBV_Components::ReceptacleDescription::ReceptacleDescription (CORBA::Boolean _is_multiplex, const ::Components::ConnectionDescriptions& _connections)
2121 {
2122 _m.is_multiplex = _is_multiplex;
2123 _m.connections = _connections;
2124 }
2125
2126 OBV_Components::ReceptacleDescription::~ReceptacleDescription ()
2127 {
2128 }
2129
2130 void OBV_Components::ReceptacleDescription::is_multiplex( CORBA::Boolean _p )
2131 {
2132 _m.is_multiplex = _p;
2133 }
2134
2135 CORBA::Boolean OBV_Components::ReceptacleDescription::is_multiplex() const
2136 {
2137 return (CORBA::Boolean)_m.is_multiplex;
2138 }
2139
2140 void OBV_Components::ReceptacleDescription::connections( const ::Components::ConnectionDescriptions& _p )
2141 {
2142 _m.connections = _p;
2143 }
2144
2145 const ::Components::ConnectionDescriptions& OBV_Components::ReceptacleDescription::connections() const
2146 {
2147 return (::Components::ConnectionDescriptions&) _m.connections;
2148 }
2149
2150 ::Components::ConnectionDescriptions& OBV_Components::ReceptacleDescription::connections()
2151 {
2152 return _m.connections;
2153 }
2154
2155
2156
2157
2158
2159 Components::Receptacles::~Receptacles()
2160 {
2161 }
2162
2163 void *
2164 Components::Receptacles::_narrow_helper( const char *_repoid )
2165 {
2166 if( strcmp( _repoid, "IDL:omg.org/Components/Receptacles:1.0" ) == 0 )
2167 return (void *)this;
2168 return NULL;
2169 }
2170
2171 Components::Receptacles_ptr
2172 Components::Receptacles::_narrow( CORBA::Object_ptr _obj )
2173 {
2174 Components::Receptacles_ptr _o;
2175 if( !CORBA::is_nil( _obj ) ) {
2176 void *_p;
2177 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/Receptacles:1.0" )))
2178 return _duplicate( (Components::Receptacles_ptr) _p );
2179 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/Receptacles:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/Receptacles:1.0")) {
2180 _o = new Components::Receptacles_stub;
2181 _o->CORBA::Object::operator=( *_obj );
2182 return _o;
2183 }
2184 }
2185 return _nil();
2186 }
2187
2188 Components::Receptacles_ptr
2189 Components::Receptacles::_narrow( CORBA::AbstractBase_ptr _obj )
2190 {
2191 return _narrow (_obj->_to_object());
2192 }
2193
2194 class _Marshaller_Components_Receptacles : public ::CORBA::StaticTypeInfo {
2195 typedef Components::Receptacles_ptr _MICO_T;
2196 public:
2197 StaticValueType create () const;
2198 void assign (StaticValueType dst, const StaticValueType src) const;
2199 void free (StaticValueType) const;
2200 void release (StaticValueType) const;
2201 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2202 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2203 };
2204
2205
2206 ::CORBA::StaticValueType _Marshaller_Components_Receptacles::create() const
2207 {
2208 return (StaticValueType) new _MICO_T( 0 );
2209 }
2210
2211 void _Marshaller_Components_Receptacles::assign( StaticValueType d, const StaticValueType s ) const
2212 {
2213 *(_MICO_T*) d = ::Components::Receptacles::_duplicate( *(_MICO_T*) s );
2214 }
2215
2216 void _Marshaller_Components_Receptacles::free( StaticValueType v ) const
2217 {
2218 ::CORBA::release( *(_MICO_T *) v );
2219 delete (_MICO_T*) v;
2220 }
2221
2222 void _Marshaller_Components_Receptacles::release( StaticValueType v ) const
2223 {
2224 ::CORBA::release( *(_MICO_T *) v );
2225 }
2226
2227 ::CORBA::Boolean _Marshaller_Components_Receptacles::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2228 {
2229 ::CORBA::Object_ptr obj;
2230 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
2231 return FALSE;
2232 *(_MICO_T *) v = ::Components::Receptacles::_narrow( obj );
2233 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
2234 ::CORBA::release (obj);
2235 return ret;
2236 }
2237
2238 void _Marshaller_Components_Receptacles::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2239 {
2240 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
2241 ::CORBA::_stc_Object->marshal( ec, &obj );
2242 }
2243
2244 ::CORBA::StaticTypeInfo *_marshaller_Components_Receptacles;
2245
2246
2247
2248
2249 Components::Receptacles_stub::~Receptacles_stub()
2250 {
2251 }
2252
2253 #ifndef MICO_CONF_NO_POA
2254
2255 void *
2256 POA_Components::Receptacles::_narrow_helper (const char * repoid)
2257 {
2258 if (strcmp (repoid, "IDL:omg.org/Components/Receptacles:1.0") == 0) {
2259 return (void *) this;
2260 }
2261 return NULL;
2262 }
2263
2264 POA_Components::Receptacles *
2265 POA_Components::Receptacles::_narrow (PortableServer::Servant serv)
2266 {
2267 void * p;
2268 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/Receptacles:1.0")) != NULL) {
2269 serv->_add_ref ();
2270 return (POA_Components::Receptacles *) p;
2271 }
2272 return NULL;
2273 }
2274
2275 Components::Receptacles_stub_clp::Receptacles_stub_clp ()
2276 {
2277 }
2278
2279 Components::Receptacles_stub_clp::Receptacles_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
2280 : CORBA::Object(*obj), PortableServer::StubBase(poa)
2281 {
2282 }
2283
2284 Components::Receptacles_stub_clp::~Receptacles_stub_clp ()
2285 {
2286 }
2287
2288 #endif // MICO_CONF_NO_POA
2289
2290 Components::Cookie* Components::Receptacles_stub::connect( const char* _par_name, CORBA::Object_ptr _par_connection )
2291 {
2292 CORBA::StaticAny _sa_name( CORBA::_stc_string, &_par_name );
2293 CORBA::StaticAny _sa_connection( CORBA::_stc_Object, &_par_connection );
2294 Components::Cookie* _res;
2295 CORBA::StaticAny __res( _marshaller_Components_Cookie, &_res );
2296
2297 CORBA::StaticRequest __req( this, "connect" );
2298 __req.add_in_arg( &_sa_name );
2299 __req.add_in_arg( &_sa_connection );
2300 __req.set_result( &__res );
2301
2302 __req.invoke();
2303
2304 mico_sii_throw( &__req,
2305 _marshaller_Components_InvalidName, "IDL:omg.org/Components/InvalidName:1.0",
2306 _marshaller_Components_InvalidConnection, "IDL:omg.org/Components/InvalidConnection:1.0",
2307 _marshaller_Components_AlreadyConnected, "IDL:omg.org/Components/AlreadyConnected:1.0",
2308 _marshaller_Components_ExceededConnectionLimit, "IDL:omg.org/Components/ExceededConnectionLimit:1.0",
2309 0);
2310 return _res;
2311 }
2312
2313
2314 #ifndef MICO_CONF_NO_POA
2315
2316 Components::Cookie*
2317 Components::Receptacles_stub_clp::connect( const char* _par_name, CORBA::Object_ptr _par_connection )
2318 {
2319 PortableServer::Servant _serv = _preinvoke ();
2320 if (_serv) {
2321 POA_Components::Receptacles * _myserv = POA_Components::Receptacles::_narrow (_serv);
2322 if (_myserv) {
2323 Components::Cookie* __res;
2324
2325 #ifdef HAVE_EXCEPTIONS
2326 try {
2327 #endif
2328 __res = _myserv->connect(_par_name, _par_connection);
2329 #ifdef HAVE_EXCEPTIONS
2330 }
2331 catch (...) {
2332 _myserv->_remove_ref();
2333 _postinvoke();
2334 throw;
2335 }
2336 #endif
2337
2338 _myserv->_remove_ref();
2339 _postinvoke ();
2340 Components::Cookie* __res2 = Components::Cookie::_downcast (__res->_copy_value ());
2341 CORBA::remove_ref (__res);
2342 return __res2;
2343 }
2344 _postinvoke ();
2345 }
2346
2347 return Components::Receptacles_stub::connect(_par_name, _par_connection);
2348 }
2349
2350 #endif // MICO_CONF_NO_POA
2351
2352 void Components::Receptacles_stub::disconnect( const char* _par_name, Components::Cookie* _par_ck )
2353 {
2354 CORBA::StaticAny _sa_name( CORBA::_stc_string, &_par_name );
2355 CORBA::StaticAny _sa_ck( _marshaller_Components_Cookie, &_par_ck );
2356 CORBA::StaticRequest __req( this, "disconnect" );
2357 __req.add_in_arg( &_sa_name );
2358 __req.add_in_arg( &_sa_ck );
2359
2360 __req.invoke();
2361
2362 mico_sii_throw( &__req,
2363 _marshaller_Components_InvalidName, "IDL:omg.org/Components/InvalidName:1.0",
2364 _marshaller_Components_InvalidConnection, "IDL:omg.org/Components/InvalidConnection:1.0",
2365 _marshaller_Components_CookieRequired, "IDL:omg.org/Components/CookieRequired:1.0",
2366 _marshaller_Components_NoConnection, "IDL:omg.org/Components/NoConnection:1.0",
2367 0);
2368 }
2369
2370
2371 #ifndef MICO_CONF_NO_POA
2372
2373 void
2374 Components::Receptacles_stub_clp::disconnect( const char* _par_name, Components::Cookie* _par_ck )
2375 {
2376 PortableServer::Servant _serv = _preinvoke ();
2377 if (_serv) {
2378 POA_Components::Receptacles * _myserv = POA_Components::Receptacles::_narrow (_serv);
2379 if (_myserv) {
2380 Components::Cookie* _copy_of_par_ck;
2381 _copy_of_par_ck = Components::Cookie::_downcast (_par_ck->_copy_value());
2382 #ifdef HAVE_EXCEPTIONS
2383 try {
2384 #endif
2385 _myserv->disconnect(_par_name, _copy_of_par_ck);
2386 #ifdef HAVE_EXCEPTIONS
2387 }
2388 catch (...) {
2389 _myserv->_remove_ref();
2390 _postinvoke();
2391 throw;
2392 }
2393 #endif
2394
2395 _myserv->_remove_ref();
2396 _postinvoke ();
2397 CORBA::remove_ref (_copy_of_par_ck);
2398 return;
2399 }
2400 _postinvoke ();
2401 }
2402
2403 Components::Receptacles_stub::disconnect(_par_name, _par_ck);
2404 }
2405
2406 #endif // MICO_CONF_NO_POA
2407
2408 Components::ConnectionDescriptions* Components::Receptacles_stub::get_connections( const char* _par_name )
2409 {
2410 CORBA::StaticAny _sa_name( CORBA::_stc_string, &_par_name );
2411 CORBA::StaticAny __res( _marshaller__seq_Components_ConnectionDescription );
2412
2413 CORBA::StaticRequest __req( this, "get_connections" );
2414 __req.add_in_arg( &_sa_name );
2415 __req.set_result( &__res );
2416
2417 __req.invoke();
2418
2419 mico_sii_throw( &__req,
2420 _marshaller_Components_InvalidName, "IDL:omg.org/Components/InvalidName:1.0",
2421 0);
2422 return (Components::ConnectionDescriptions*) __res._retn();
2423 }
2424
2425
2426 #ifndef MICO_CONF_NO_POA
2427
2428 Components::ConnectionDescriptions*
2429 Components::Receptacles_stub_clp::get_connections( const char* _par_name )
2430 {
2431 return Components::Receptacles_stub::get_connections(_par_name);
2432 }
2433
2434 #endif // MICO_CONF_NO_POA
2435
2436 Components::ReceptacleDescriptions* Components::Receptacles_stub::get_all_receptacles()
2437 {
2438 CORBA::StaticAny __res( _marshaller__seq_Components_ReceptacleDescription );
2439
2440 CORBA::StaticRequest __req( this, "get_all_receptacles" );
2441 __req.set_result( &__res );
2442
2443 __req.invoke();
2444
2445 mico_sii_throw( &__req,
2446 0);
2447 return (Components::ReceptacleDescriptions*) __res._retn();
2448 }
2449
2450
2451 #ifndef MICO_CONF_NO_POA
2452
2453 Components::ReceptacleDescriptions*
2454 Components::Receptacles_stub_clp::get_all_receptacles()
2455 {
2456 return Components::Receptacles_stub::get_all_receptacles();
2457 }
2458
2459 #endif // MICO_CONF_NO_POA
2460
2461 Components::ReceptacleDescriptions* Components::Receptacles_stub::get_named_receptacles( const Components::NameList& _par_names )
2462 {
2463 CORBA::StaticAny _sa_names( CORBA::_stcseq_string, &_par_names );
2464 CORBA::StaticAny __res( _marshaller__seq_Components_ReceptacleDescription );
2465
2466 CORBA::StaticRequest __req( this, "get_named_receptacles" );
2467 __req.add_in_arg( &_sa_names );
2468 __req.set_result( &__res );
2469
2470 __req.invoke();
2471
2472 mico_sii_throw( &__req,
2473 _marshaller_Components_InvalidName, "IDL:omg.org/Components/InvalidName:1.0",
2474 0);
2475 return (Components::ReceptacleDescriptions*) __res._retn();
2476 }
2477
2478
2479 #ifndef MICO_CONF_NO_POA
2480
2481 Components::ReceptacleDescriptions*
2482 Components::Receptacles_stub_clp::get_named_receptacles( const Components::NameList& _par_names )
2483 {
2484 return Components::Receptacles_stub::get_named_receptacles(_par_names);
2485 }
2486
2487 #endif // MICO_CONF_NO_POA
2488
2489
2490 #ifdef HAVE_EXPLICIT_STRUCT_OPS
2491 Components::BadEventType::BadEventType()
2492 {
2493 }
2494
2495 Components::BadEventType::BadEventType( const BadEventType& _s )
2496 {
2497 expected_event_type = ((BadEventType&)_s).expected_event_type;
2498 }
2499
2500 Components::BadEventType::~BadEventType()
2501 {
2502 }
2503
2504 Components::BadEventType&
2505 Components::BadEventType::operator=( const BadEventType& _s )
2506 {
2507 expected_event_type = ((BadEventType&)_s).expected_event_type;
2508 return *this;
2509 }
2510 #endif
2511
2512 #ifndef HAVE_EXPLICIT_STRUCT_OPS
2513 Components::BadEventType::BadEventType()
2514 {
2515 }
2516
2517 #endif
2518
2519 Components::BadEventType::BadEventType( const char* _m0 )
2520 {
2521 expected_event_type = _m0;
2522 }
2523
2524 class _Marshaller_Components_BadEventType : public ::CORBA::StaticTypeInfo {
2525 typedef ::Components::BadEventType _MICO_T;
2526 public:
2527 StaticValueType create () const;
2528 void assign (StaticValueType dst, const StaticValueType src) const;
2529 void free (StaticValueType) const;
2530 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2531 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2532 };
2533
2534
2535 ::CORBA::StaticValueType _Marshaller_Components_BadEventType::create() const
2536 {
2537 return (StaticValueType) new _MICO_T;
2538 }
2539
2540 void _Marshaller_Components_BadEventType::assign( StaticValueType d, const StaticValueType s ) const
2541 {
2542 *(_MICO_T*) d = *(_MICO_T*) s;
2543 }
2544
2545 void _Marshaller_Components_BadEventType::free( StaticValueType v ) const
2546 {
2547 delete (_MICO_T*) v;
2548 }
2549
2550 ::CORBA::Boolean _Marshaller_Components_BadEventType::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2551 {
2552 string repoid;
2553 return
2554 dc.except_begin( repoid ) &&
2555 CORBA::_stc_string->demarshal( dc, &((_MICO_T*)v)->expected_event_type._for_demarshal() ) &&
2556 dc.except_end();
2557 }
2558
2559 void _Marshaller_Components_BadEventType::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2560 {
2561 ec.except_begin( "IDL:omg.org/Components/BadEventType:1.0" );
2562 CORBA::_stc_string->marshal( ec, &((_MICO_T*)v)->expected_event_type.inout() );
2563 ec.except_end();
2564 }
2565
2566 ::CORBA::StaticTypeInfo *_marshaller_Components_BadEventType;
2567
2568 void Components::BadEventType::_throwit() const
2569 {
2570 #ifdef HAVE_EXCEPTIONS
2571 #ifdef HAVE_STD_EH
2572 throw *this;
2573 #else
2574 throw BadEventType_var( (Components::BadEventType*)_clone() );
2575 #endif
2576 #else
2577 CORBA::Exception::_throw_failed( _clone() );
2578 #endif
2579 }
2580
2581 const char *Components::BadEventType::_repoid() const
2582 {
2583 return "IDL:omg.org/Components/BadEventType:1.0";
2584 }
2585
2586 void Components::BadEventType::_encode( CORBA::DataEncoder &_en ) const
2587 {
2588 _marshaller_Components_BadEventType->marshal( _en, (void*) this );
2589 }
2590
2591 void Components::BadEventType::_encode_any( CORBA::Any & ) const
2592 {
2593
2594 assert(0);
2595 }
2596
2597 CORBA::Exception *Components::BadEventType::_clone() const
2598 {
2599 return new BadEventType( *this );
2600 }
2601
2602 Components::BadEventType *Components::BadEventType::_downcast( CORBA::Exception *_ex )
2603 {
2604 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/BadEventType:1.0" ) )
2605 return (BadEventType *) _ex;
2606 return NULL;
2607 }
2608
2609 const Components::BadEventType *Components::BadEventType::_downcast( const CORBA::Exception *_ex )
2610 {
2611 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/BadEventType:1.0" ) )
2612 return (BadEventType *) _ex;
2613 return NULL;
2614 }
2615
2616
2617
2618
2619 Components::EventConsumerBase::~EventConsumerBase()
2620 {
2621 }
2622
2623 void *
2624 Components::EventConsumerBase::_narrow_helper( const char *_repoid )
2625 {
2626 if( strcmp( _repoid, "IDL:omg.org/Components/EventConsumerBase:1.0" ) == 0 )
2627 return (void *)this;
2628 return NULL;
2629 }
2630
2631 Components::EventConsumerBase_ptr
2632 Components::EventConsumerBase::_narrow( CORBA::Object_ptr _obj )
2633 {
2634 Components::EventConsumerBase_ptr _o;
2635 if( !CORBA::is_nil( _obj ) ) {
2636 void *_p;
2637 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/EventConsumerBase:1.0" )))
2638 return _duplicate( (Components::EventConsumerBase_ptr) _p );
2639 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/EventConsumerBase:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/EventConsumerBase:1.0")) {
2640 _o = new Components::EventConsumerBase_stub;
2641 _o->CORBA::Object::operator=( *_obj );
2642 return _o;
2643 }
2644 }
2645 return _nil();
2646 }
2647
2648 Components::EventConsumerBase_ptr
2649 Components::EventConsumerBase::_narrow( CORBA::AbstractBase_ptr _obj )
2650 {
2651 return _narrow (_obj->_to_object());
2652 }
2653
2654 class _Marshaller_Components_EventConsumerBase : public ::CORBA::StaticTypeInfo {
2655 typedef Components::EventConsumerBase_ptr _MICO_T;
2656 public:
2657 StaticValueType create () const;
2658 void assign (StaticValueType dst, const StaticValueType src) const;
2659 void free (StaticValueType) const;
2660 void release (StaticValueType) const;
2661 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2662 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2663 };
2664
2665
2666 ::CORBA::StaticValueType _Marshaller_Components_EventConsumerBase::create() const
2667 {
2668 return (StaticValueType) new _MICO_T( 0 );
2669 }
2670
2671 void _Marshaller_Components_EventConsumerBase::assign( StaticValueType d, const StaticValueType s ) const
2672 {
2673 *(_MICO_T*) d = ::Components::EventConsumerBase::_duplicate( *(_MICO_T*) s );
2674 }
2675
2676 void _Marshaller_Components_EventConsumerBase::free( StaticValueType v ) const
2677 {
2678 ::CORBA::release( *(_MICO_T *) v );
2679 delete (_MICO_T*) v;
2680 }
2681
2682 void _Marshaller_Components_EventConsumerBase::release( StaticValueType v ) const
2683 {
2684 ::CORBA::release( *(_MICO_T *) v );
2685 }
2686
2687 ::CORBA::Boolean _Marshaller_Components_EventConsumerBase::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2688 {
2689 ::CORBA::Object_ptr obj;
2690 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
2691 return FALSE;
2692 *(_MICO_T *) v = ::Components::EventConsumerBase::_narrow( obj );
2693 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
2694 ::CORBA::release (obj);
2695 return ret;
2696 }
2697
2698 void _Marshaller_Components_EventConsumerBase::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2699 {
2700 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
2701 ::CORBA::_stc_Object->marshal( ec, &obj );
2702 }
2703
2704 ::CORBA::StaticTypeInfo *_marshaller_Components_EventConsumerBase;
2705
2706
2707
2708
2709 Components::EventConsumerBase_stub::~EventConsumerBase_stub()
2710 {
2711 }
2712
2713 #ifndef MICO_CONF_NO_POA
2714
2715 void *
2716 POA_Components::EventConsumerBase::_narrow_helper (const char * repoid)
2717 {
2718 if (strcmp (repoid, "IDL:omg.org/Components/EventConsumerBase:1.0") == 0) {
2719 return (void *) this;
2720 }
2721 return NULL;
2722 }
2723
2724 POA_Components::EventConsumerBase *
2725 POA_Components::EventConsumerBase::_narrow (PortableServer::Servant serv)
2726 {
2727 void * p;
2728 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/EventConsumerBase:1.0")) != NULL) {
2729 serv->_add_ref ();
2730 return (POA_Components::EventConsumerBase *) p;
2731 }
2732 return NULL;
2733 }
2734
2735 Components::EventConsumerBase_stub_clp::EventConsumerBase_stub_clp ()
2736 {
2737 }
2738
2739 Components::EventConsumerBase_stub_clp::EventConsumerBase_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
2740 : CORBA::Object(*obj), PortableServer::StubBase(poa)
2741 {
2742 }
2743
2744 Components::EventConsumerBase_stub_clp::~EventConsumerBase_stub_clp ()
2745 {
2746 }
2747
2748 #endif // MICO_CONF_NO_POA
2749
2750 void Components::EventConsumerBase_stub::push_event( Components::EventBase* _par_evt )
2751 {
2752 CORBA::StaticAny _sa_evt( _marshaller_Components_EventBase, &_par_evt );
2753 CORBA::StaticRequest __req( this, "push_event" );
2754 __req.add_in_arg( &_sa_evt );
2755
2756 __req.invoke();
2757
2758 mico_sii_throw( &__req,
2759 _marshaller_Components_BadEventType, "IDL:omg.org/Components/BadEventType:1.0",
2760 0);
2761 }
2762
2763
2764 #ifndef MICO_CONF_NO_POA
2765
2766 void
2767 Components::EventConsumerBase_stub_clp::push_event( Components::EventBase* _par_evt )
2768 {
2769 PortableServer::Servant _serv = _preinvoke ();
2770 if (_serv) {
2771 POA_Components::EventConsumerBase * _myserv = POA_Components::EventConsumerBase::_narrow (_serv);
2772 if (_myserv) {
2773 Components::EventBase* _copy_of_par_evt;
2774 _copy_of_par_evt = Components::EventBase::_downcast (_par_evt->_copy_value());
2775 #ifdef HAVE_EXCEPTIONS
2776 try {
2777 #endif
2778 _myserv->push_event(_copy_of_par_evt);
2779 #ifdef HAVE_EXCEPTIONS
2780 }
2781 catch (...) {
2782 _myserv->_remove_ref();
2783 _postinvoke();
2784 throw;
2785 }
2786 #endif
2787
2788 _myserv->_remove_ref();
2789 _postinvoke ();
2790 CORBA::remove_ref (_copy_of_par_evt);
2791 return;
2792 }
2793 _postinvoke ();
2794 }
2795
2796 Components::EventConsumerBase_stub::push_event(_par_evt);
2797 }
2798
2799 #endif // MICO_CONF_NO_POA
2800
2801
2802
2803 Components::ConsumerDescription::ConsumerDescription ()
2804 {
2805 }
2806
2807 Components::ConsumerDescription::~ConsumerDescription ()
2808 {
2809 }
2810
2811 void *
2812 Components::ConsumerDescription::_narrow_helper (const char * repoid)
2813 {
2814 void * p;
2815 if (strcmp (repoid, "IDL:omg.org/Components/ConsumerDescription:1.0") == 0) {
2816 return (void *) this;
2817 }
2818 if ((p = Components::PortDescription::_narrow_helper (repoid)) != NULL) {
2819 return p;
2820 }
2821 return NULL;
2822 }
2823
2824 Components::ConsumerDescription *
2825 Components::ConsumerDescription::_downcast (CORBA::ValueBase * vb)
2826 {
2827 void * p;
2828 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/ConsumerDescription:1.0")))) {
2829 return (Components::ConsumerDescription *) p;
2830 }
2831 return 0;
2832 }
2833
2834 Components::ConsumerDescription *
2835 Components::ConsumerDescription::_downcast (CORBA::AbstractBase * vb)
2836 {
2837 return _downcast (vb->_to_value());
2838 }
2839
2840 CORBA::ValueDef_ptr
2841 Components::ConsumerDescription::get_value_def ()
2842 {
2843 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
2844 CORBA::Object_var irobj =
2845 orb->resolve_initial_references ("InterfaceRepository");
2846 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
2847 if (CORBA::is_nil (ifr)) {
2848 return CORBA::ValueDef::_nil ();
2849 }
2850
2851 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/ConsumerDescription:1.0");
2852 return CORBA::ValueDef::_narrow (cv);
2853 }
2854
2855 void
2856 Components::ConsumerDescription::_copy_members (const ConsumerDescription& other)
2857 {
2858 consumer (other.consumer());
2859 }
2860
2861 CORBA::ValueBase *
2862 Components::ConsumerDescription::_copy_value ()
2863 {
2864 vector<string> _dummy;
2865 string _repo_id = "IDL:omg.org/Components/ConsumerDescription:1.0";
2866 ConsumerDescription * _res = _downcast (_create (_dummy, _repo_id));
2867 assert (_res != 0);
2868 _res->Components::PortDescription::_copy_members (*this);
2869 _res->_copy_members (*this);
2870 return _res;
2871 }
2872
2873 void
2874 Components::ConsumerDescription::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
2875 {
2876 repoids.push_back ("IDL:omg.org/Components/ConsumerDescription:1.0");
2877 chunked = FALSE;
2878 }
2879
2880 void
2881 Components::ConsumerDescription::_marshal_members (CORBA::DataEncoder &ec)
2882 {
2883 Components::PortDescription::_marshal_members (ec);
2884 Components::EventConsumerBase_ptr _consumer = consumer ();
2885 _marshaller_Components_EventConsumerBase->marshal (ec, &_consumer);
2886 }
2887
2888 CORBA::Boolean
2889 Components::ConsumerDescription::_demarshal_members (CORBA::DataDecoder &dc)
2890 {
2891 if (!Components::PortDescription::_demarshal_members (dc)) {
2892 return FALSE;
2893 }
2894 Components::EventConsumerBase_var _consumer;
2895 if (!_marshaller_Components_EventConsumerBase->demarshal (dc, &_consumer._for_demarshal())) {
2896 return FALSE;
2897 }
2898 consumer (_consumer);
2899 return TRUE;
2900 }
2901
2902
2903 class _Marshaller_Components_ConsumerDescription : public ::CORBA::StaticTypeInfo {
2904 typedef Components::ConsumerDescription* _MICO_T;
2905 public:
2906 StaticValueType create () const;
2907 void assign (StaticValueType dst, const StaticValueType src) const;
2908 void free (StaticValueType) const;
2909 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2910 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2911 };
2912
2913
2914 ::CORBA::StaticValueType _Marshaller_Components_ConsumerDescription::create() const
2915 {
2916 return (StaticValueType) new _MICO_T( 0 );
2917 }
2918
2919 void _Marshaller_Components_ConsumerDescription::assign( StaticValueType d, const StaticValueType s ) const
2920 {
2921 ::CORBA::remove_ref (*(_MICO_T*)d);
2922 ::CORBA::add_ref (*(_MICO_T*)s);
2923 *(_MICO_T*) d = *(_MICO_T*) s;
2924 }
2925
2926 void _Marshaller_Components_ConsumerDescription::free( StaticValueType v ) const
2927 {
2928 ::CORBA::remove_ref (*(_MICO_T*)v);
2929 delete (_MICO_T*) v;
2930 }
2931
2932 ::CORBA::Boolean _Marshaller_Components_ConsumerDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2933 {
2934 ::CORBA::ValueBase* vb = NULL;
2935 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/ConsumerDescription:1.0")) {
2936 return FALSE;
2937 }
2938 *(_MICO_T *)v = ::Components::ConsumerDescription::_downcast (vb);
2939 if (vb && !*(_MICO_T *)v) {
2940 ::CORBA::remove_ref (vb);
2941 return FALSE;
2942 }
2943 return TRUE;
2944 }
2945
2946 void _Marshaller_Components_ConsumerDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2947 {
2948 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
2949 }
2950
2951 ::CORBA::StaticTypeInfo *_marshaller_Components_ConsumerDescription;
2952
2953
2954
2955 OBV_Components::ConsumerDescription::ConsumerDescription ()
2956 {
2957 }
2958
2959 OBV_Components::ConsumerDescription::ConsumerDescription (::Components::EventConsumerBase_ptr _consumer)
2960 {
2961 _m.consumer = ::Components::EventConsumerBase::_duplicate( _consumer );
2962 }
2963
2964 OBV_Components::ConsumerDescription::~ConsumerDescription ()
2965 {
2966 }
2967
2968 void OBV_Components::ConsumerDescription::consumer( ::Components::EventConsumerBase_ptr _p )
2969 {
2970 _m.consumer = ::Components::EventConsumerBase::_duplicate( _p );
2971 }
2972
2973 ::Components::EventConsumerBase_ptr OBV_Components::ConsumerDescription::consumer() const
2974 {
2975 return _m.consumer.in();
2976 }
2977
2978
2979
2980
2981 Components::EmitterDescription::EmitterDescription ()
2982 {
2983 }
2984
2985 Components::EmitterDescription::~EmitterDescription ()
2986 {
2987 }
2988
2989 void *
2990 Components::EmitterDescription::_narrow_helper (const char * repoid)
2991 {
2992 void * p;
2993 if (strcmp (repoid, "IDL:omg.org/Components/EmitterDescription:1.0") == 0) {
2994 return (void *) this;
2995 }
2996 if ((p = Components::PortDescription::_narrow_helper (repoid)) != NULL) {
2997 return p;
2998 }
2999 return NULL;
3000 }
3001
3002 Components::EmitterDescription *
3003 Components::EmitterDescription::_downcast (CORBA::ValueBase * vb)
3004 {
3005 void * p;
3006 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/EmitterDescription:1.0")))) {
3007 return (Components::EmitterDescription *) p;
3008 }
3009 return 0;
3010 }
3011
3012 Components::EmitterDescription *
3013 Components::EmitterDescription::_downcast (CORBA::AbstractBase * vb)
3014 {
3015 return _downcast (vb->_to_value());
3016 }
3017
3018 CORBA::ValueDef_ptr
3019 Components::EmitterDescription::get_value_def ()
3020 {
3021 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
3022 CORBA::Object_var irobj =
3023 orb->resolve_initial_references ("InterfaceRepository");
3024 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
3025 if (CORBA::is_nil (ifr)) {
3026 return CORBA::ValueDef::_nil ();
3027 }
3028
3029 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/EmitterDescription:1.0");
3030 return CORBA::ValueDef::_narrow (cv);
3031 }
3032
3033 void
3034 Components::EmitterDescription::_copy_members (const EmitterDescription& other)
3035 {
3036 consumer (other.consumer());
3037 }
3038
3039 CORBA::ValueBase *
3040 Components::EmitterDescription::_copy_value ()
3041 {
3042 vector<string> _dummy;
3043 string _repo_id = "IDL:omg.org/Components/EmitterDescription:1.0";
3044 EmitterDescription * _res = _downcast (_create (_dummy, _repo_id));
3045 assert (_res != 0);
3046 _res->Components::PortDescription::_copy_members (*this);
3047 _res->_copy_members (*this);
3048 return _res;
3049 }
3050
3051 void
3052 Components::EmitterDescription::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
3053 {
3054 repoids.push_back ("IDL:omg.org/Components/EmitterDescription:1.0");
3055 chunked = FALSE;
3056 }
3057
3058 void
3059 Components::EmitterDescription::_marshal_members (CORBA::DataEncoder &ec)
3060 {
3061 Components::PortDescription::_marshal_members (ec);
3062 Components::EventConsumerBase_ptr _consumer = consumer ();
3063 _marshaller_Components_EventConsumerBase->marshal (ec, &_consumer);
3064 }
3065
3066 CORBA::Boolean
3067 Components::EmitterDescription::_demarshal_members (CORBA::DataDecoder &dc)
3068 {
3069 if (!Components::PortDescription::_demarshal_members (dc)) {
3070 return FALSE;
3071 }
3072 Components::EventConsumerBase_var _consumer;
3073 if (!_marshaller_Components_EventConsumerBase->demarshal (dc, &_consumer._for_demarshal())) {
3074 return FALSE;
3075 }
3076 consumer (_consumer);
3077 return TRUE;
3078 }
3079
3080
3081 class _Marshaller_Components_EmitterDescription : public ::CORBA::StaticTypeInfo {
3082 typedef Components::EmitterDescription* _MICO_T;
3083 public:
3084 StaticValueType create () const;
3085 void assign (StaticValueType dst, const StaticValueType src) const;
3086 void free (StaticValueType) const;
3087 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
3088 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
3089 };
3090
3091
3092 ::CORBA::StaticValueType _Marshaller_Components_EmitterDescription::create() const
3093 {
3094 return (StaticValueType) new _MICO_T( 0 );
3095 }
3096
3097 void _Marshaller_Components_EmitterDescription::assign( StaticValueType d, const StaticValueType s ) const
3098 {
3099 ::CORBA::remove_ref (*(_MICO_T*)d);
3100 ::CORBA::add_ref (*(_MICO_T*)s);
3101 *(_MICO_T*) d = *(_MICO_T*) s;
3102 }
3103
3104 void _Marshaller_Components_EmitterDescription::free( StaticValueType v ) const
3105 {
3106 ::CORBA::remove_ref (*(_MICO_T*)v);
3107 delete (_MICO_T*) v;
3108 }
3109
3110 ::CORBA::Boolean _Marshaller_Components_EmitterDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
3111 {
3112 ::CORBA::ValueBase* vb = NULL;
3113 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/EmitterDescription:1.0")) {
3114 return FALSE;
3115 }
3116 *(_MICO_T *)v = ::Components::EmitterDescription::_downcast (vb);
3117 if (vb && !*(_MICO_T *)v) {
3118 ::CORBA::remove_ref (vb);
3119 return FALSE;
3120 }
3121 return TRUE;
3122 }
3123
3124 void _Marshaller_Components_EmitterDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
3125 {
3126 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
3127 }
3128
3129 ::CORBA::StaticTypeInfo *_marshaller_Components_EmitterDescription;
3130
3131
3132
3133 OBV_Components::EmitterDescription::EmitterDescription ()
3134 {
3135 }
3136
3137 OBV_Components::EmitterDescription::EmitterDescription (::Components::EventConsumerBase_ptr _consumer)
3138 {
3139 _m.consumer = ::Components::EventConsumerBase::_duplicate( _consumer );
3140 }
3141
3142 OBV_Components::EmitterDescription::~EmitterDescription ()
3143 {
3144 }
3145
3146 void OBV_Components::EmitterDescription::consumer( ::Components::EventConsumerBase_ptr _p )
3147 {
3148 _m.consumer = ::Components::EventConsumerBase::_duplicate( _p );
3149 }
3150
3151 ::Components::EventConsumerBase_ptr OBV_Components::EmitterDescription::consumer() const
3152 {
3153 return _m.consumer.in();
3154 }
3155
3156
3157
3158
3159 Components::SubscriberDescription::SubscriberDescription ()
3160 {
3161 }
3162
3163 Components::SubscriberDescription::~SubscriberDescription ()
3164 {
3165 }
3166
3167 void *
3168 Components::SubscriberDescription::_narrow_helper (const char * repoid)
3169 {
3170 if (strcmp (repoid, "IDL:omg.org/Components/SubscriberDescription:1.0") == 0) {
3171 return (void *) this;
3172 }
3173 return NULL;
3174 }
3175
3176 Components::SubscriberDescription *
3177 Components::SubscriberDescription::_downcast (CORBA::ValueBase * vb)
3178 {
3179 void * p;
3180 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/SubscriberDescription:1.0")))) {
3181 return (Components::SubscriberDescription *) p;
3182 }
3183 return 0;
3184 }
3185
3186 Components::SubscriberDescription *
3187 Components::SubscriberDescription::_downcast (CORBA::AbstractBase * vb)
3188 {
3189 return _downcast (vb->_to_value());
3190 }
3191
3192 CORBA::ValueDef_ptr
3193 Components::SubscriberDescription::get_value_def ()
3194 {
3195 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
3196 CORBA::Object_var irobj =
3197 orb->resolve_initial_references ("InterfaceRepository");
3198 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
3199 if (CORBA::is_nil (ifr)) {
3200 return CORBA::ValueDef::_nil ();
3201 }
3202
3203 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/SubscriberDescription:1.0");
3204 return CORBA::ValueDef::_narrow (cv);
3205 }
3206
3207 void
3208 Components::SubscriberDescription::_copy_members (const SubscriberDescription& other)
3209 {
3210 Components::Cookie_var _ck = Components::Cookie::_downcast (other.ck()->_copy_value());
3211 ck (_ck);
3212 consumer (other.consumer());
3213 }
3214
3215 CORBA::ValueBase *
3216 Components::SubscriberDescription::_copy_value ()
3217 {
3218 vector<string> _dummy;
3219 string _repo_id = "IDL:omg.org/Components/SubscriberDescription:1.0";
3220 SubscriberDescription * _res = _downcast (_create (_dummy, _repo_id));
3221 assert (_res != 0);
3222 _res->_copy_members (*this);
3223 return _res;
3224 }
3225
3226 void
3227 Components::SubscriberDescription::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
3228 {
3229 repoids.push_back ("IDL:omg.org/Components/SubscriberDescription:1.0");
3230 chunked = FALSE;
3231 }
3232
3233 void
3234 Components::SubscriberDescription::_marshal_members (CORBA::DataEncoder &ec)
3235 {
3236 Components::Cookie* _ck = ck ();
3237 _marshaller_Components_Cookie->marshal (ec, &_ck);
3238 Components::EventConsumerBase_ptr _consumer = consumer ();
3239 _marshaller_Components_EventConsumerBase->marshal (ec, &_consumer);
3240 }
3241
3242 CORBA::Boolean
3243 Components::SubscriberDescription::_demarshal_members (CORBA::DataDecoder &dc)
3244 {
3245 Components::Cookie_var _ck;
3246 if (!_marshaller_Components_Cookie->demarshal (dc, &_ck._for_demarshal())) {
3247 return FALSE;
3248 }
3249 ck (_ck);
3250 Components::EventConsumerBase_var _consumer;
3251 if (!_marshaller_Components_EventConsumerBase->demarshal (dc, &_consumer._for_demarshal())) {
3252 return FALSE;
3253 }
3254 consumer (_consumer);
3255 return TRUE;
3256 }
3257
3258
3259 class _Marshaller_Components_SubscriberDescription : public ::CORBA::StaticTypeInfo {
3260 typedef Components::SubscriberDescription* _MICO_T;
3261 public:
3262 StaticValueType create () const;
3263 void assign (StaticValueType dst, const StaticValueType src) const;
3264 void free (StaticValueType) const;
3265 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
3266 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
3267 };
3268
3269
3270 ::CORBA::StaticValueType _Marshaller_Components_SubscriberDescription::create() const
3271 {
3272 return (StaticValueType) new _MICO_T( 0 );
3273 }
3274
3275 void _Marshaller_Components_SubscriberDescription::assign( StaticValueType d, const StaticValueType s ) const
3276 {
3277 ::CORBA::remove_ref (*(_MICO_T*)d);
3278 ::CORBA::add_ref (*(_MICO_T*)s);
3279 *(_MICO_T*) d = *(_MICO_T*) s;
3280 }
3281
3282 void _Marshaller_Components_SubscriberDescription::free( StaticValueType v ) const
3283 {
3284 ::CORBA::remove_ref (*(_MICO_T*)v);
3285 delete (_MICO_T*) v;
3286 }
3287
3288 ::CORBA::Boolean _Marshaller_Components_SubscriberDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
3289 {
3290 ::CORBA::ValueBase* vb = NULL;
3291 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/SubscriberDescription:1.0")) {
3292 return FALSE;
3293 }
3294 *(_MICO_T *)v = ::Components::SubscriberDescription::_downcast (vb);
3295 if (vb && !*(_MICO_T *)v) {
3296 ::CORBA::remove_ref (vb);
3297 return FALSE;
3298 }
3299 return TRUE;
3300 }
3301
3302 void _Marshaller_Components_SubscriberDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
3303 {
3304 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
3305 }
3306
3307 ::CORBA::StaticTypeInfo *_marshaller_Components_SubscriberDescription;
3308
3309
3310
3311 OBV_Components::SubscriberDescription::SubscriberDescription ()
3312 {
3313 }
3314
3315 OBV_Components::SubscriberDescription::SubscriberDescription (::Components::Cookie* _ck, ::Components::EventConsumerBase_ptr _consumer)
3316 {
3317 CORBA::add_ref ( _ck );
3318 _m.ck = _ck;
3319 _m.consumer = ::Components::EventConsumerBase::_duplicate( _consumer );
3320 }
3321
3322 OBV_Components::SubscriberDescription::~SubscriberDescription ()
3323 {
3324 }
3325
3326 void OBV_Components::SubscriberDescription::ck( ::Components::Cookie* _p )
3327 {
3328 CORBA::add_ref ( _p );
3329 _m.ck = _p;
3330 }
3331
3332 ::Components::Cookie* OBV_Components::SubscriberDescription::ck() const
3333 {
3334 return _m.ck.in();
3335 }
3336
3337 void OBV_Components::SubscriberDescription::consumer( ::Components::EventConsumerBase_ptr _p )
3338 {
3339 _m.consumer = ::Components::EventConsumerBase::_duplicate( _p );
3340 }
3341
3342 ::Components::EventConsumerBase_ptr OBV_Components::SubscriberDescription::consumer() const
3343 {
3344 return _m.consumer.in();
3345 }
3346
3347
3348
3349
3350 Components::PublisherDescription::PublisherDescription ()
3351 {
3352 }
3353
3354 Components::PublisherDescription::~PublisherDescription ()
3355 {
3356 }
3357
3358 void *
3359 Components::PublisherDescription::_narrow_helper (const char * repoid)
3360 {
3361 void * p;
3362 if (strcmp (repoid, "IDL:omg.org/Components/PublisherDescription:1.0") == 0) {
3363 return (void *) this;
3364 }
3365 if ((p = Components::PortDescription::_narrow_helper (repoid)) != NULL) {
3366 return p;
3367 }
3368 return NULL;
3369 }
3370
3371 Components::PublisherDescription *
3372 Components::PublisherDescription::_downcast (CORBA::ValueBase * vb)
3373 {
3374 void * p;
3375 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/PublisherDescription:1.0")))) {
3376 return (Components::PublisherDescription *) p;
3377 }
3378 return 0;
3379 }
3380
3381 Components::PublisherDescription *
3382 Components::PublisherDescription::_downcast (CORBA::AbstractBase * vb)
3383 {
3384 return _downcast (vb->_to_value());
3385 }
3386
3387 CORBA::ValueDef_ptr
3388 Components::PublisherDescription::get_value_def ()
3389 {
3390 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
3391 CORBA::Object_var irobj =
3392 orb->resolve_initial_references ("InterfaceRepository");
3393 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
3394 if (CORBA::is_nil (ifr)) {
3395 return CORBA::ValueDef::_nil ();
3396 }
3397
3398 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/PublisherDescription:1.0");
3399 return CORBA::ValueDef::_narrow (cv);
3400 }
3401
3402 void
3403 Components::PublisherDescription::_copy_members (const PublisherDescription& other)
3404 {
3405 consumers (other.consumers());
3406 }
3407
3408 CORBA::ValueBase *
3409 Components::PublisherDescription::_copy_value ()
3410 {
3411 vector<string> _dummy;
3412 string _repo_id = "IDL:omg.org/Components/PublisherDescription:1.0";
3413 PublisherDescription * _res = _downcast (_create (_dummy, _repo_id));
3414 assert (_res != 0);
3415 _res->Components::PortDescription::_copy_members (*this);
3416 _res->_copy_members (*this);
3417 return _res;
3418 }
3419
3420 void
3421 Components::PublisherDescription::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
3422 {
3423 repoids.push_back ("IDL:omg.org/Components/PublisherDescription:1.0");
3424 chunked = FALSE;
3425 }
3426
3427 void
3428 Components::PublisherDescription::_marshal_members (CORBA::DataEncoder &ec)
3429 {
3430 Components::PortDescription::_marshal_members (ec);
3431 Components::SubscriberDescriptions& _consumers = consumers ();
3432 _marshaller__seq_Components_SubscriberDescription->marshal (ec, &_consumers);
3433 }
3434
3435 CORBA::Boolean
3436 Components::PublisherDescription::_demarshal_members (CORBA::DataDecoder &dc)
3437 {
3438 if (!Components::PortDescription::_demarshal_members (dc)) {
3439 return FALSE;
3440 }
3441 Components::SubscriberDescriptions _consumers;
3442 if (!_marshaller__seq_Components_SubscriberDescription->demarshal (dc, &_consumers)) {
3443 return FALSE;
3444 }
3445 consumers (_consumers);
3446 return TRUE;
3447 }
3448
3449
3450 class _Marshaller_Components_PublisherDescription : public ::CORBA::StaticTypeInfo {
3451 typedef Components::PublisherDescription* _MICO_T;
3452 public:
3453 StaticValueType create () const;
3454 void assign (StaticValueType dst, const StaticValueType src) const;
3455 void free (StaticValueType) const;
3456 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
3457 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
3458 };
3459
3460
3461 ::CORBA::StaticValueType _Marshaller_Components_PublisherDescription::create() const
3462 {
3463 return (StaticValueType) new _MICO_T( 0 );
3464 }
3465
3466 void _Marshaller_Components_PublisherDescription::assign( StaticValueType d, const StaticValueType s ) const
3467 {
3468 ::CORBA::remove_ref (*(_MICO_T*)d);
3469 ::CORBA::add_ref (*(_MICO_T*)s);
3470 *(_MICO_T*) d = *(_MICO_T*) s;
3471 }
3472
3473 void _Marshaller_Components_PublisherDescription::free( StaticValueType v ) const
3474 {
3475 ::CORBA::remove_ref (*(_MICO_T*)v);
3476 delete (_MICO_T*) v;
3477 }
3478
3479 ::CORBA::Boolean _Marshaller_Components_PublisherDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
3480 {
3481 ::CORBA::ValueBase* vb = NULL;
3482 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/PublisherDescription:1.0")) {
3483 return FALSE;
3484 }
3485 *(_MICO_T *)v = ::Components::PublisherDescription::_downcast (vb);
3486 if (vb && !*(_MICO_T *)v) {
3487 ::CORBA::remove_ref (vb);
3488 return FALSE;
3489 }
3490 return TRUE;
3491 }
3492
3493 void _Marshaller_Components_PublisherDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
3494 {
3495 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
3496 }
3497
3498 ::CORBA::StaticTypeInfo *_marshaller_Components_PublisherDescription;
3499
3500
3501
3502 OBV_Components::PublisherDescription::PublisherDescription ()
3503 {
3504 }
3505
3506 OBV_Components::PublisherDescription::PublisherDescription (const ::Components::SubscriberDescriptions& _consumers)
3507 {
3508 _m.consumers = _consumers;
3509 }
3510
3511 OBV_Components::PublisherDescription::~PublisherDescription ()
3512 {
3513 }
3514
3515 void OBV_Components::PublisherDescription::consumers( const ::Components::SubscriberDescriptions& _p )
3516 {
3517 _m.consumers = _p;
3518 }
3519
3520 const ::Components::SubscriberDescriptions& OBV_Components::PublisherDescription::consumers() const
3521 {
3522 return (::Components::SubscriberDescriptions&) _m.consumers;
3523 }
3524
3525 ::Components::SubscriberDescriptions& OBV_Components::PublisherDescription::consumers()
3526 {
3527 return _m.consumers;
3528 }
3529
3530
3531
3532
3533
3534 Components::Events::~Events()
3535 {
3536 }
3537
3538 void *
3539 Components::Events::_narrow_helper( const char *_repoid )
3540 {
3541 if( strcmp( _repoid, "IDL:omg.org/Components/Events:1.0" ) == 0 )
3542 return (void *)this;
3543 return NULL;
3544 }
3545
3546 Components::Events_ptr
3547 Components::Events::_narrow( CORBA::Object_ptr _obj )
3548 {
3549 Components::Events_ptr _o;
3550 if( !CORBA::is_nil( _obj ) ) {
3551 void *_p;
3552 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/Events:1.0" )))
3553 return _duplicate( (Components::Events_ptr) _p );
3554 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/Events:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/Events:1.0")) {
3555 _o = new Components::Events_stub;
3556 _o->CORBA::Object::operator=( *_obj );
3557 return _o;
3558 }
3559 }
3560 return _nil();
3561 }
3562
3563 Components::Events_ptr
3564 Components::Events::_narrow( CORBA::AbstractBase_ptr _obj )
3565 {
3566 return _narrow (_obj->_to_object());
3567 }
3568
3569 class _Marshaller_Components_Events : public ::CORBA::StaticTypeInfo {
3570 typedef Components::Events_ptr _MICO_T;
3571 public:
3572 StaticValueType create () const;
3573 void assign (StaticValueType dst, const StaticValueType src) const;
3574 void free (StaticValueType) const;
3575 void release (StaticValueType) const;
3576 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
3577 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
3578 };
3579
3580
3581 ::CORBA::StaticValueType _Marshaller_Components_Events::create() const
3582 {
3583 return (StaticValueType) new _MICO_T( 0 );
3584 }
3585
3586 void _Marshaller_Components_Events::assign( StaticValueType d, const StaticValueType s ) const
3587 {
3588 *(_MICO_T*) d = ::Components::Events::_duplicate( *(_MICO_T*) s );
3589 }
3590
3591 void _Marshaller_Components_Events::free( StaticValueType v ) const
3592 {
3593 ::CORBA::release( *(_MICO_T *) v );
3594 delete (_MICO_T*) v;
3595 }
3596
3597 void _Marshaller_Components_Events::release( StaticValueType v ) const
3598 {
3599 ::CORBA::release( *(_MICO_T *) v );
3600 }
3601
3602 ::CORBA::Boolean _Marshaller_Components_Events::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
3603 {
3604 ::CORBA::Object_ptr obj;
3605 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
3606 return FALSE;
3607 *(_MICO_T *) v = ::Components::Events::_narrow( obj );
3608 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
3609 ::CORBA::release (obj);
3610 return ret;
3611 }
3612
3613 void _Marshaller_Components_Events::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
3614 {
3615 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
3616 ::CORBA::_stc_Object->marshal( ec, &obj );
3617 }
3618
3619 ::CORBA::StaticTypeInfo *_marshaller_Components_Events;
3620
3621
3622
3623
3624 Components::Events_stub::~Events_stub()
3625 {
3626 }
3627
3628 #ifndef MICO_CONF_NO_POA
3629
3630 void *
3631 POA_Components::Events::_narrow_helper (const char * repoid)
3632 {
3633 if (strcmp (repoid, "IDL:omg.org/Components/Events:1.0") == 0) {
3634 return (void *) this;
3635 }
3636 return NULL;
3637 }
3638
3639 POA_Components::Events *
3640 POA_Components::Events::_narrow (PortableServer::Servant serv)
3641 {
3642 void * p;
3643 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/Events:1.0")) != NULL) {
3644 serv->_add_ref ();
3645 return (POA_Components::Events *) p;
3646 }
3647 return NULL;
3648 }
3649
3650 Components::Events_stub_clp::Events_stub_clp ()
3651 {
3652 }
3653
3654 Components::Events_stub_clp::Events_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
3655 : CORBA::Object(*obj), PortableServer::StubBase(poa)
3656 {
3657 }
3658
3659 Components::Events_stub_clp::~Events_stub_clp ()
3660 {
3661 }
3662
3663 #endif // MICO_CONF_NO_POA
3664
3665 Components::EventConsumerBase_ptr Components::Events_stub::get_consumer( const char* _par_sink_name )
3666 {
3667 CORBA::StaticAny _sa_sink_name( CORBA::_stc_string, &_par_sink_name );
3668 Components::EventConsumerBase_ptr _res;
3669 CORBA::StaticAny __res( _marshaller_Components_EventConsumerBase, &_res );
3670
3671 CORBA::StaticRequest __req( this, "get_consumer" );
3672 __req.add_in_arg( &_sa_sink_name );
3673 __req.set_result( &__res );
3674
3675 __req.invoke();
3676
3677 mico_sii_throw( &__req,
3678 _marshaller_Components_InvalidName, "IDL:omg.org/Components/InvalidName:1.0",
3679 0);
3680 return _res;
3681 }
3682
3683
3684 #ifndef MICO_CONF_NO_POA
3685
3686 Components::EventConsumerBase_ptr
3687 Components::Events_stub_clp::get_consumer( const char* _par_sink_name )
3688 {
3689 PortableServer::Servant _serv = _preinvoke ();
3690 if (_serv) {
3691 POA_Components::Events * _myserv = POA_Components::Events::_narrow (_serv);
3692 if (_myserv) {
3693 Components::EventConsumerBase_ptr __res;
3694
3695 #ifdef HAVE_EXCEPTIONS
3696 try {
3697 #endif
3698 __res = _myserv->get_consumer(_par_sink_name);
3699 #ifdef HAVE_EXCEPTIONS
3700 }
3701 catch (...) {
3702 _myserv->_remove_ref();
3703 _postinvoke();
3704 throw;
3705 }
3706 #endif
3707
3708 _myserv->_remove_ref();
3709 _postinvoke ();
3710 return __res;
3711 }
3712 _postinvoke ();
3713 }
3714
3715 return Components::Events_stub::get_consumer(_par_sink_name);
3716 }
3717
3718 #endif // MICO_CONF_NO_POA
3719
3720 Components::ConsumerDescriptions* Components::Events_stub::get_all_consumers()
3721 {
3722 CORBA::StaticAny __res( _marshaller__seq_Components_ConsumerDescription );
3723
3724 CORBA::StaticRequest __req( this, "get_all_consumers" );
3725 __req.set_result( &__res );
3726
3727 __req.invoke();
3728
3729 mico_sii_throw( &__req,
3730 0);
3731 return (Components::ConsumerDescriptions*) __res._retn();
3732 }
3733
3734
3735 #ifndef MICO_CONF_NO_POA
3736
3737 Components::ConsumerDescriptions*
3738 Components::Events_stub_clp::get_all_consumers()
3739 {
3740 return Components::Events_stub::get_all_consumers();
3741 }
3742
3743 #endif // MICO_CONF_NO_POA
3744
3745 Components::ConsumerDescriptions* Components::Events_stub::get_named_consumers( const Components::NameList& _par_names )
3746 {
3747 CORBA::StaticAny _sa_names( CORBA::_stcseq_string, &_par_names );
3748 CORBA::StaticAny __res( _marshaller__seq_Components_ConsumerDescription );
3749
3750 CORBA::StaticRequest __req( this, "get_named_consumers" );
3751 __req.add_in_arg( &_sa_names );
3752 __req.set_result( &__res );
3753
3754 __req.invoke();
3755
3756 mico_sii_throw( &__req,
3757 0);
3758 return (Components::ConsumerDescriptions*) __res._retn();
3759 }
3760
3761
3762 #ifndef MICO_CONF_NO_POA
3763
3764 Components::ConsumerDescriptions*
3765 Components::Events_stub_clp::get_named_consumers( const Components::NameList& _par_names )
3766 {
3767 return Components::Events_stub::get_named_consumers(_par_names);
3768 }
3769
3770 #endif // MICO_CONF_NO_POA
3771
3772 Components::Cookie* Components::Events_stub::subscribe( const char* _par_publisher_name, Components::EventConsumerBase_ptr _par_subscriber )
3773 {
3774 CORBA::StaticAny _sa_publisher_name( CORBA::_stc_string, &_par_publisher_name );
3775 CORBA::StaticAny _sa_subscriber( _marshaller_Components_EventConsumerBase, &_par_subscriber );
3776 Components::Cookie* _res;
3777 CORBA::StaticAny __res( _marshaller_Components_Cookie, &_res );
3778
3779 CORBA::StaticRequest __req( this, "subscribe" );
3780 __req.add_in_arg( &_sa_publisher_name );
3781 __req.add_in_arg( &_sa_subscriber );
3782 __req.set_result( &__res );
3783
3784 __req.invoke();
3785
3786 mico_sii_throw( &__req,
3787 _marshaller_Components_InvalidName, "IDL:omg.org/Components/InvalidName:1.0",
3788 0);
3789 return _res;
3790 }
3791
3792
3793 #ifndef MICO_CONF_NO_POA
3794
3795 Components::Cookie*
3796 Components::Events_stub_clp::subscribe( const char* _par_publisher_name, Components::EventConsumerBase_ptr _par_subscriber )
3797 {
3798 PortableServer::Servant _serv = _preinvoke ();
3799 if (_serv) {
3800 POA_Components::Events * _myserv = POA_Components::Events::_narrow (_serv);
3801 if (_myserv) {
3802 Components::Cookie* __res;
3803
3804 #ifdef HAVE_EXCEPTIONS
3805 try {
3806 #endif
3807 __res = _myserv->subscribe(_par_publisher_name, _par_subscriber);
3808 #ifdef HAVE_EXCEPTIONS
3809 }
3810 catch (...) {
3811 _myserv->_remove_ref();
3812 _postinvoke();
3813 throw;
3814 }
3815 #endif
3816
3817 _myserv->_remove_ref();
3818 _postinvoke ();
3819 Components::Cookie* __res2 = Components::Cookie::_downcast (__res->_copy_value ());
3820 CORBA::remove_ref (__res);
3821 return __res2;
3822 }
3823 _postinvoke ();
3824 }
3825
3826 return Components::Events_stub::subscribe(_par_publisher_name, _par_subscriber);
3827 }
3828
3829 #endif // MICO_CONF_NO_POA
3830
3831 void Components::Events_stub::unsubscribe( const char* _par_publisher_name, Components::Cookie* _par_ck )
3832 {
3833 CORBA::StaticAny _sa_publisher_name( CORBA::_stc_string, &_par_publisher_name );
3834 CORBA::StaticAny _sa_ck( _marshaller_Components_Cookie, &_par_ck );
3835 CORBA::StaticRequest __req( this, "unsubscribe" );
3836 __req.add_in_arg( &_sa_publisher_name );
3837 __req.add_in_arg( &_sa_ck );
3838
3839 __req.invoke();
3840
3841 mico_sii_throw( &__req,
3842 _marshaller_Components_InvalidName, "IDL:omg.org/Components/InvalidName:1.0",
3843 _marshaller_Components_InvalidConnection, "IDL:omg.org/Components/InvalidConnection:1.0",
3844 0);
3845 }
3846
3847
3848 #ifndef MICO_CONF_NO_POA
3849
3850 void
3851 Components::Events_stub_clp::unsubscribe( const char* _par_publisher_name, Components::Cookie* _par_ck )
3852 {
3853 PortableServer::Servant _serv = _preinvoke ();
3854 if (_serv) {
3855 POA_Components::Events * _myserv = POA_Components::Events::_narrow (_serv);
3856 if (_myserv) {
3857 Components::Cookie* _copy_of_par_ck;
3858 _copy_of_par_ck = Components::Cookie::_downcast (_par_ck->_copy_value());
3859 #ifdef HAVE_EXCEPTIONS
3860 try {
3861 #endif
3862 _myserv->unsubscribe(_par_publisher_name, _copy_of_par_ck);
3863 #ifdef HAVE_EXCEPTIONS
3864 }
3865 catch (...) {
3866 _myserv->_remove_ref();
3867 _postinvoke();
3868 throw;
3869 }
3870 #endif
3871
3872 _myserv->_remove_ref();
3873 _postinvoke ();
3874 CORBA::remove_ref (_copy_of_par_ck);
3875 return;
3876 }
3877 _postinvoke ();
3878 }
3879
3880 Components::Events_stub::unsubscribe(_par_publisher_name, _par_ck);
3881 }
3882
3883 #endif // MICO_CONF_NO_POA
3884
3885 Components::PublisherDescriptions* Components::Events_stub::get_all_publishers()
3886 {
3887 CORBA::StaticAny __res( _marshaller__seq_Components_PublisherDescription );
3888
3889 CORBA::StaticRequest __req( this, "get_all_publishers" );
3890 __req.set_result( &__res );
3891
3892 __req.invoke();
3893
3894 mico_sii_throw( &__req,
3895 0);
3896 return (Components::PublisherDescriptions*) __res._retn();
3897 }
3898
3899
3900 #ifndef MICO_CONF_NO_POA
3901
3902 Components::PublisherDescriptions*
3903 Components::Events_stub_clp::get_all_publishers()
3904 {
3905 return Components::Events_stub::get_all_publishers();
3906 }
3907
3908 #endif // MICO_CONF_NO_POA
3909
3910 Components::PublisherDescriptions* Components::Events_stub::get_named_publishers( const Components::NameList& _par_names )
3911 {
3912 CORBA::StaticAny _sa_names( CORBA::_stcseq_string, &_par_names );
3913 CORBA::StaticAny __res( _marshaller__seq_Components_PublisherDescription );
3914
3915 CORBA::StaticRequest __req( this, "get_named_publishers" );
3916 __req.add_in_arg( &_sa_names );
3917 __req.set_result( &__res );
3918
3919 __req.invoke();
3920
3921 mico_sii_throw( &__req,
3922 0);
3923 return (Components::PublisherDescriptions*) __res._retn();
3924 }
3925
3926
3927 #ifndef MICO_CONF_NO_POA
3928
3929 Components::PublisherDescriptions*
3930 Components::Events_stub_clp::get_named_publishers( const Components::NameList& _par_names )
3931 {
3932 return Components::Events_stub::get_named_publishers(_par_names);
3933 }
3934
3935 #endif // MICO_CONF_NO_POA
3936
3937 void Components::Events_stub::connect_consumer( const char* _par_emitter_name, Components::EventConsumerBase_ptr _par_consumer )
3938 {
3939 CORBA::StaticAny _sa_emitter_name( CORBA::_stc_string, &_par_emitter_name );
3940 CORBA::StaticAny _sa_consumer( _marshaller_Components_EventConsumerBase, &_par_consumer );
3941 CORBA::StaticRequest __req( this, "connect_consumer" );
3942 __req.add_in_arg( &_sa_emitter_name );
3943 __req.add_in_arg( &_sa_consumer );
3944
3945 __req.invoke();
3946
3947 mico_sii_throw( &__req,
3948 _marshaller_Components_InvalidName, "IDL:omg.org/Components/InvalidName:1.0",
3949 _marshaller_Components_AlreadyConnected, "IDL:omg.org/Components/AlreadyConnected:1.0",
3950 0);
3951 }
3952
3953
3954 #ifndef MICO_CONF_NO_POA
3955
3956 void
3957 Components::Events_stub_clp::connect_consumer( const char* _par_emitter_name, Components::EventConsumerBase_ptr _par_consumer )
3958 {
3959 PortableServer::Servant _serv = _preinvoke ();
3960 if (_serv) {
3961 POA_Components::Events * _myserv = POA_Components::Events::_narrow (_serv);
3962 if (_myserv) {
3963 #ifdef HAVE_EXCEPTIONS
3964 try {
3965 #endif
3966 _myserv->connect_consumer(_par_emitter_name, _par_consumer);
3967 #ifdef HAVE_EXCEPTIONS
3968 }
3969 catch (...) {
3970 _myserv->_remove_ref();
3971 _postinvoke();
3972 throw;
3973 }
3974 #endif
3975
3976 _myserv->_remove_ref();
3977 _postinvoke ();
3978 return;
3979 }
3980 _postinvoke ();
3981 }
3982
3983 Components::Events_stub::connect_consumer(_par_emitter_name, _par_consumer);
3984 }
3985
3986 #endif // MICO_CONF_NO_POA
3987
3988 Components::EventConsumerBase_ptr Components::Events_stub::disconnect_consumer( const char* _par_source_name )
3989 {
3990 CORBA::StaticAny _sa_source_name( CORBA::_stc_string, &_par_source_name );
3991 Components::EventConsumerBase_ptr _res;
3992 CORBA::StaticAny __res( _marshaller_Components_EventConsumerBase, &_res );
3993
3994 CORBA::StaticRequest __req( this, "disconnect_consumer" );
3995 __req.add_in_arg( &_sa_source_name );
3996 __req.set_result( &__res );
3997
3998 __req.invoke();
3999
4000 mico_sii_throw( &__req,
4001 _marshaller_Components_InvalidName, "IDL:omg.org/Components/InvalidName:1.0",
4002 _marshaller_Components_NoConnection, "IDL:omg.org/Components/NoConnection:1.0",
4003 0);
4004 return _res;
4005 }
4006
4007
4008 #ifndef MICO_CONF_NO_POA
4009
4010 Components::EventConsumerBase_ptr
4011 Components::Events_stub_clp::disconnect_consumer( const char* _par_source_name )
4012 {
4013 PortableServer::Servant _serv = _preinvoke ();
4014 if (_serv) {
4015 POA_Components::Events * _myserv = POA_Components::Events::_narrow (_serv);
4016 if (_myserv) {
4017 Components::EventConsumerBase_ptr __res;
4018
4019 #ifdef HAVE_EXCEPTIONS
4020 try {
4021 #endif
4022 __res = _myserv->disconnect_consumer(_par_source_name);
4023 #ifdef HAVE_EXCEPTIONS
4024 }
4025 catch (...) {
4026 _myserv->_remove_ref();
4027 _postinvoke();
4028 throw;
4029 }
4030 #endif
4031
4032 _myserv->_remove_ref();
4033 _postinvoke ();
4034 return __res;
4035 }
4036 _postinvoke ();
4037 }
4038
4039 return Components::Events_stub::disconnect_consumer(_par_source_name);
4040 }
4041
4042 #endif // MICO_CONF_NO_POA
4043
4044 Components::EmitterDescriptions* Components::Events_stub::get_all_emitters()
4045 {
4046 CORBA::StaticAny __res( _marshaller__seq_Components_EmitterDescription );
4047
4048 CORBA::StaticRequest __req( this, "get_all_emitters" );
4049 __req.set_result( &__res );
4050
4051 __req.invoke();
4052
4053 mico_sii_throw( &__req,
4054 0);
4055 return (Components::EmitterDescriptions*) __res._retn();
4056 }
4057
4058
4059 #ifndef MICO_CONF_NO_POA
4060
4061 Components::EmitterDescriptions*
4062 Components::Events_stub_clp::get_all_emitters()
4063 {
4064 return Components::Events_stub::get_all_emitters();
4065 }
4066
4067 #endif // MICO_CONF_NO_POA
4068
4069 Components::EmitterDescriptions* Components::Events_stub::get_named_emitters( const Components::NameList& _par_names )
4070 {
4071 CORBA::StaticAny _sa_names( CORBA::_stcseq_string, &_par_names );
4072 CORBA::StaticAny __res( _marshaller__seq_Components_EmitterDescription );
4073
4074 CORBA::StaticRequest __req( this, "get_named_emitters" );
4075 __req.add_in_arg( &_sa_names );
4076 __req.set_result( &__res );
4077
4078 __req.invoke();
4079
4080 mico_sii_throw( &__req,
4081 0);
4082 return (Components::EmitterDescriptions*) __res._retn();
4083 }
4084
4085
4086 #ifndef MICO_CONF_NO_POA
4087
4088 Components::EmitterDescriptions*
4089 Components::Events_stub_clp::get_named_emitters( const Components::NameList& _par_names )
4090 {
4091 return Components::Events_stub::get_named_emitters(_par_names);
4092 }
4093
4094 #endif // MICO_CONF_NO_POA
4095
4096
4097
4098
4099 Components::CCMHome::~CCMHome()
4100 {
4101 }
4102
4103 void *
4104 Components::CCMHome::_narrow_helper( const char *_repoid )
4105 {
4106 if( strcmp( _repoid, "IDL:omg.org/Components/CCMHome:1.0" ) == 0 )
4107 return (void *)this;
4108 return NULL;
4109 }
4110
4111 Components::CCMHome_ptr
4112 Components::CCMHome::_narrow( CORBA::Object_ptr _obj )
4113 {
4114 Components::CCMHome_ptr _o;
4115 if( !CORBA::is_nil( _obj ) ) {
4116 void *_p;
4117 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/CCMHome:1.0" )))
4118 return _duplicate( (Components::CCMHome_ptr) _p );
4119 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/CCMHome:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/CCMHome:1.0")) {
4120 _o = new Components::CCMHome_stub;
4121 _o->CORBA::Object::operator=( *_obj );
4122 return _o;
4123 }
4124 }
4125 return _nil();
4126 }
4127
4128 Components::CCMHome_ptr
4129 Components::CCMHome::_narrow( CORBA::AbstractBase_ptr _obj )
4130 {
4131 return _narrow (_obj->_to_object());
4132 }
4133
4134 class _Marshaller_Components_CCMHome : public ::CORBA::StaticTypeInfo {
4135 typedef Components::CCMHome_ptr _MICO_T;
4136 public:
4137 StaticValueType create () const;
4138 void assign (StaticValueType dst, const StaticValueType src) const;
4139 void free (StaticValueType) const;
4140 void release (StaticValueType) const;
4141 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
4142 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
4143 };
4144
4145
4146 ::CORBA::StaticValueType _Marshaller_Components_CCMHome::create() const
4147 {
4148 return (StaticValueType) new _MICO_T( 0 );
4149 }
4150
4151 void _Marshaller_Components_CCMHome::assign( StaticValueType d, const StaticValueType s ) const
4152 {
4153 *(_MICO_T*) d = ::Components::CCMHome::_duplicate( *(_MICO_T*) s );
4154 }
4155
4156 void _Marshaller_Components_CCMHome::free( StaticValueType v ) const
4157 {
4158 ::CORBA::release( *(_MICO_T *) v );
4159 delete (_MICO_T*) v;
4160 }
4161
4162 void _Marshaller_Components_CCMHome::release( StaticValueType v ) const
4163 {
4164 ::CORBA::release( *(_MICO_T *) v );
4165 }
4166
4167 ::CORBA::Boolean _Marshaller_Components_CCMHome::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
4168 {
4169 ::CORBA::Object_ptr obj;
4170 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
4171 return FALSE;
4172 *(_MICO_T *) v = ::Components::CCMHome::_narrow( obj );
4173 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
4174 ::CORBA::release (obj);
4175 return ret;
4176 }
4177
4178 void _Marshaller_Components_CCMHome::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
4179 {
4180 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
4181 ::CORBA::_stc_Object->marshal( ec, &obj );
4182 }
4183
4184 ::CORBA::StaticTypeInfo *_marshaller_Components_CCMHome;
4185
4186
4187
4188
4189 Components::CCMHome_stub::~CCMHome_stub()
4190 {
4191 }
4192
4193 #ifndef MICO_CONF_NO_POA
4194
4195 void *
4196 POA_Components::CCMHome::_narrow_helper (const char * repoid)
4197 {
4198 if (strcmp (repoid, "IDL:omg.org/Components/CCMHome:1.0") == 0) {
4199 return (void *) this;
4200 }
4201 return NULL;
4202 }
4203
4204 POA_Components::CCMHome *
4205 POA_Components::CCMHome::_narrow (PortableServer::Servant serv)
4206 {
4207 void * p;
4208 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/CCMHome:1.0")) != NULL) {
4209 serv->_add_ref ();
4210 return (POA_Components::CCMHome *) p;
4211 }
4212 return NULL;
4213 }
4214
4215 Components::CCMHome_stub_clp::CCMHome_stub_clp ()
4216 {
4217 }
4218
4219 Components::CCMHome_stub_clp::CCMHome_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
4220 : CORBA::Object(*obj), PortableServer::StubBase(poa)
4221 {
4222 }
4223
4224 Components::CCMHome_stub_clp::~CCMHome_stub_clp ()
4225 {
4226 }
4227
4228 #endif // MICO_CONF_NO_POA
4229
4230 CORBA::Object_ptr Components::CCMHome_stub::get_component_def()
4231 {
4232 CORBA::Object_ptr _res;
4233 CORBA::StaticAny __res( CORBA::_stc_Object, &_res );
4234
4235 CORBA::StaticRequest __req( this, "get_component_def" );
4236 __req.set_result( &__res );
4237
4238 __req.invoke();
4239
4240 mico_sii_throw( &__req,
4241 0);
4242 return _res;
4243 }
4244
4245
4246 #ifndef MICO_CONF_NO_POA
4247
4248 CORBA::Object_ptr
4249 Components::CCMHome_stub_clp::get_component_def()
4250 {
4251 PortableServer::Servant _serv = _preinvoke ();
4252 if (_serv) {
4253 POA_Components::CCMHome * _myserv = POA_Components::CCMHome::_narrow (_serv);
4254 if (_myserv) {
4255 CORBA::Object_ptr __res;
4256
4257 #ifdef HAVE_EXCEPTIONS
4258 try {
4259 #endif
4260 __res = _myserv->get_component_def();
4261 #ifdef HAVE_EXCEPTIONS
4262 }
4263 catch (...) {
4264 _myserv->_remove_ref();
4265 _postinvoke();
4266 throw;
4267 }
4268 #endif
4269
4270 _myserv->_remove_ref();
4271 _postinvoke ();
4272 return __res;
4273 }
4274 _postinvoke ();
4275 }
4276
4277 return Components::CCMHome_stub::get_component_def();
4278 }
4279
4280 #endif // MICO_CONF_NO_POA
4281
4282 CORBA::Object_ptr Components::CCMHome_stub::get_home_def()
4283 {
4284 CORBA::Object_ptr _res;
4285 CORBA::StaticAny __res( CORBA::_stc_Object, &_res );
4286
4287 CORBA::StaticRequest __req( this, "get_home_def" );
4288 __req.set_result( &__res );
4289
4290 __req.invoke();
4291
4292 mico_sii_throw( &__req,
4293 0);
4294 return _res;
4295 }
4296
4297
4298 #ifndef MICO_CONF_NO_POA
4299
4300 CORBA::Object_ptr
4301 Components::CCMHome_stub_clp::get_home_def()
4302 {
4303 PortableServer::Servant _serv = _preinvoke ();
4304 if (_serv) {
4305 POA_Components::CCMHome * _myserv = POA_Components::CCMHome::_narrow (_serv);
4306 if (_myserv) {
4307 CORBA::Object_ptr __res;
4308
4309 #ifdef HAVE_EXCEPTIONS
4310 try {
4311 #endif
4312 __res = _myserv->get_home_def();
4313 #ifdef HAVE_EXCEPTIONS
4314 }
4315 catch (...) {
4316 _myserv->_remove_ref();
4317 _postinvoke();
4318 throw;
4319 }
4320 #endif
4321
4322 _myserv->_remove_ref();
4323 _postinvoke ();
4324 return __res;
4325 }
4326 _postinvoke ();
4327 }
4328
4329 return Components::CCMHome_stub::get_home_def();
4330 }
4331
4332 #endif // MICO_CONF_NO_POA
4333
4334 void Components::CCMHome_stub::remove_component( Components::CCMObject_ptr _par_comp )
4335 {
4336 CORBA::StaticAny _sa_comp( _marshaller_Components_CCMObject, &_par_comp );
4337 CORBA::StaticRequest __req( this, "remove_component" );
4338 __req.add_in_arg( &_sa_comp );
4339
4340 __req.invoke();
4341
4342 mico_sii_throw( &__req,
4343 0);
4344 }
4345
4346
4347 #ifndef MICO_CONF_NO_POA
4348
4349 void
4350 Components::CCMHome_stub_clp::remove_component( Components::CCMObject_ptr _par_comp )
4351 {
4352 PortableServer::Servant _serv = _preinvoke ();
4353 if (_serv) {
4354 POA_Components::CCMHome * _myserv = POA_Components::CCMHome::_narrow (_serv);
4355 if (_myserv) {
4356 #ifdef HAVE_EXCEPTIONS
4357 try {
4358 #endif
4359 _myserv->remove_component(_par_comp);
4360 #ifdef HAVE_EXCEPTIONS
4361 }
4362 catch (...) {
4363 _myserv->_remove_ref();
4364 _postinvoke();
4365 throw;
4366 }
4367 #endif
4368
4369 _myserv->_remove_ref();
4370 _postinvoke ();
4371 return;
4372 }
4373 _postinvoke ();
4374 }
4375
4376 Components::CCMHome_stub::remove_component(_par_comp);
4377 }
4378
4379 #endif // MICO_CONF_NO_POA
4380
4381
4382
4383 Components::ComponentPortDescription::ComponentPortDescription ()
4384 {
4385 }
4386
4387 Components::ComponentPortDescription::~ComponentPortDescription ()
4388 {
4389 }
4390
4391 void *
4392 Components::ComponentPortDescription::_narrow_helper (const char * repoid)
4393 {
4394 if (strcmp (repoid, "IDL:omg.org/Components/ComponentPortDescription:1.0") == 0) {
4395 return (void *) this;
4396 }
4397 return NULL;
4398 }
4399
4400 Components::ComponentPortDescription *
4401 Components::ComponentPortDescription::_downcast (CORBA::ValueBase * vb)
4402 {
4403 void * p;
4404 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/ComponentPortDescription:1.0")))) {
4405 return (Components::ComponentPortDescription *) p;
4406 }
4407 return 0;
4408 }
4409
4410 Components::ComponentPortDescription *
4411 Components::ComponentPortDescription::_downcast (CORBA::AbstractBase * vb)
4412 {
4413 return _downcast (vb->_to_value());
4414 }
4415
4416 CORBA::ValueDef_ptr
4417 Components::ComponentPortDescription::get_value_def ()
4418 {
4419 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
4420 CORBA::Object_var irobj =
4421 orb->resolve_initial_references ("InterfaceRepository");
4422 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
4423 if (CORBA::is_nil (ifr)) {
4424 return CORBA::ValueDef::_nil ();
4425 }
4426
4427 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/ComponentPortDescription:1.0");
4428 return CORBA::ValueDef::_narrow (cv);
4429 }
4430
4431 void
4432 Components::ComponentPortDescription::_copy_members (const ComponentPortDescription& other)
4433 {
4434 facets (other.facets());
4435 receptacles (other.receptacles());
4436 consumers (other.consumers());
4437 emitters (other.emitters());
4438 publishers (other.publishers());
4439 }
4440
4441 CORBA::ValueBase *
4442 Components::ComponentPortDescription::_copy_value ()
4443 {
4444 vector<string> _dummy;
4445 string _repo_id = "IDL:omg.org/Components/ComponentPortDescription:1.0";
4446 ComponentPortDescription * _res = _downcast (_create (_dummy, _repo_id));
4447 assert (_res != 0);
4448 _res->_copy_members (*this);
4449 return _res;
4450 }
4451
4452 void
4453 Components::ComponentPortDescription::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
4454 {
4455 repoids.push_back ("IDL:omg.org/Components/ComponentPortDescription:1.0");
4456 chunked = FALSE;
4457 }
4458
4459 void
4460 Components::ComponentPortDescription::_marshal_members (CORBA::DataEncoder &ec)
4461 {
4462 Components::FacetDescriptions& _facets = facets ();
4463 _marshaller__seq_Components_FacetDescription->marshal (ec, &_facets);
4464 Components::ReceptacleDescriptions& _receptacles = receptacles ();
4465 _marshaller__seq_Components_ReceptacleDescription->marshal (ec, &_receptacles);
4466 Components::ConsumerDescriptions& _consumers = consumers ();
4467 _marshaller__seq_Components_ConsumerDescription->marshal (ec, &_consumers);
4468 Components::EmitterDescriptions& _emitters = emitters ();
4469 _marshaller__seq_Components_EmitterDescription->marshal (ec, &_emitters);
4470 Components::PublisherDescriptions& _publishers = publishers ();
4471 _marshaller__seq_Components_PublisherDescription->marshal (ec, &_publishers);
4472 }
4473
4474 CORBA::Boolean
4475 Components::ComponentPortDescription::_demarshal_members (CORBA::DataDecoder &dc)
4476 {
4477 Components::FacetDescriptions _facets;
4478 if (!_marshaller__seq_Components_FacetDescription->demarshal (dc, &_facets)) {
4479 return FALSE;
4480 }
4481 facets (_facets);
4482 Components::ReceptacleDescriptions _receptacles;
4483 if (!_marshaller__seq_Components_ReceptacleDescription->demarshal (dc, &_receptacles)) {
4484 return FALSE;
4485 }
4486 receptacles (_receptacles);
4487 Components::ConsumerDescriptions _consumers;
4488 if (!_marshaller__seq_Components_ConsumerDescription->demarshal (dc, &_consumers)) {
4489 return FALSE;
4490 }
4491 consumers (_consumers);
4492 Components::EmitterDescriptions _emitters;
4493 if (!_marshaller__seq_Components_EmitterDescription->demarshal (dc, &_emitters)) {
4494 return FALSE;
4495 }
4496 emitters (_emitters);
4497 Components::PublisherDescriptions _publishers;
4498 if (!_marshaller__seq_Components_PublisherDescription->demarshal (dc, &_publishers)) {
4499 return FALSE;
4500 }
4501 publishers (_publishers);
4502 return TRUE;
4503 }
4504
4505
4506 class _Marshaller_Components_ComponentPortDescription : public ::CORBA::StaticTypeInfo {
4507 typedef Components::ComponentPortDescription* _MICO_T;
4508 public:
4509 StaticValueType create () const;
4510 void assign (StaticValueType dst, const StaticValueType src) const;
4511 void free (StaticValueType) const;
4512 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
4513 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
4514 };
4515
4516
4517 ::CORBA::StaticValueType _Marshaller_Components_ComponentPortDescription::create() const
4518 {
4519 return (StaticValueType) new _MICO_T( 0 );
4520 }
4521
4522 void _Marshaller_Components_ComponentPortDescription::assign( StaticValueType d, const StaticValueType s ) const
4523 {
4524 ::CORBA::remove_ref (*(_MICO_T*)d);
4525 ::CORBA::add_ref (*(_MICO_T*)s);
4526 *(_MICO_T*) d = *(_MICO_T*) s;
4527 }
4528
4529 void _Marshaller_Components_ComponentPortDescription::free( StaticValueType v ) const
4530 {
4531 ::CORBA::remove_ref (*(_MICO_T*)v);
4532 delete (_MICO_T*) v;
4533 }
4534
4535 ::CORBA::Boolean _Marshaller_Components_ComponentPortDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
4536 {
4537 ::CORBA::ValueBase* vb = NULL;
4538 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/ComponentPortDescription:1.0")) {
4539 return FALSE;
4540 }
4541 *(_MICO_T *)v = ::Components::ComponentPortDescription::_downcast (vb);
4542 if (vb && !*(_MICO_T *)v) {
4543 ::CORBA::remove_ref (vb);
4544 return FALSE;
4545 }
4546 return TRUE;
4547 }
4548
4549 void _Marshaller_Components_ComponentPortDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
4550 {
4551 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
4552 }
4553
4554 ::CORBA::StaticTypeInfo *_marshaller_Components_ComponentPortDescription;
4555
4556
4557
4558 OBV_Components::ComponentPortDescription::ComponentPortDescription ()
4559 {
4560 }
4561
4562 OBV_Components::ComponentPortDescription::ComponentPortDescription (const ::Components::FacetDescriptions& _facets, const ::Components::ReceptacleDescriptions& _receptacles, const ::Components::ConsumerDescriptions& _consumers, const ::Components::EmitterDescriptions& _emitters, const ::Components::PublisherDescriptions& _publishers)
4563 {
4564 _m.facets = _facets;
4565 _m.receptacles = _receptacles;
4566 _m.consumers = _consumers;
4567 _m.emitters = _emitters;
4568 _m.publishers = _publishers;
4569 }
4570
4571 OBV_Components::ComponentPortDescription::~ComponentPortDescription ()
4572 {
4573 }
4574
4575 void OBV_Components::ComponentPortDescription::facets( const ::Components::FacetDescriptions& _p )
4576 {
4577 _m.facets = _p;
4578 }
4579
4580 const ::Components::FacetDescriptions& OBV_Components::ComponentPortDescription::facets() const
4581 {
4582 return (::Components::FacetDescriptions&) _m.facets;
4583 }
4584
4585 ::Components::FacetDescriptions& OBV_Components::ComponentPortDescription::facets()
4586 {
4587 return _m.facets;
4588 }
4589
4590 void OBV_Components::ComponentPortDescription::receptacles( const ::Components::ReceptacleDescriptions& _p )
4591 {
4592 _m.receptacles = _p;
4593 }
4594
4595 const ::Components::ReceptacleDescriptions& OBV_Components::ComponentPortDescription::receptacles() const
4596 {
4597 return (::Components::ReceptacleDescriptions&) _m.receptacles;
4598 }
4599
4600 ::Components::ReceptacleDescriptions& OBV_Components::ComponentPortDescription::receptacles()
4601 {
4602 return _m.receptacles;
4603 }
4604
4605 void OBV_Components::ComponentPortDescription::consumers( const ::Components::ConsumerDescriptions& _p )
4606 {
4607 _m.consumers = _p;
4608 }
4609
4610 const ::Components::ConsumerDescriptions& OBV_Components::ComponentPortDescription::consumers() const
4611 {
4612 return (::Components::ConsumerDescriptions&) _m.consumers;
4613 }
4614
4615 ::Components::ConsumerDescriptions& OBV_Components::ComponentPortDescription::consumers()
4616 {
4617 return _m.consumers;
4618 }
4619
4620 void OBV_Components::ComponentPortDescription::emitters( const ::Components::EmitterDescriptions& _p )
4621 {
4622 _m.emitters = _p;
4623 }
4624
4625 const ::Components::EmitterDescriptions& OBV_Components::ComponentPortDescription::emitters() const
4626 {
4627 return (::Components::EmitterDescriptions&) _m.emitters;
4628 }
4629
4630 ::Components::EmitterDescriptions& OBV_Components::ComponentPortDescription::emitters()
4631 {
4632 return _m.emitters;
4633 }
4634
4635 void OBV_Components::ComponentPortDescription::publishers( const ::Components::PublisherDescriptions& _p )
4636 {
4637 _m.publishers = _p;
4638 }
4639
4640 const ::Components::PublisherDescriptions& OBV_Components::ComponentPortDescription::publishers() const
4641 {
4642 return (::Components::PublisherDescriptions&) _m.publishers;
4643 }
4644
4645 ::Components::PublisherDescriptions& OBV_Components::ComponentPortDescription::publishers()
4646 {
4647 return _m.publishers;
4648 }
4649
4650
4651
4652
4653 Components::CCMObject::~CCMObject()
4654 {
4655 }
4656
4657 void *
4658 Components::CCMObject::_narrow_helper( const char *_repoid )
4659 {
4660 if( strcmp( _repoid, "IDL:omg.org/Components/CCMObject:1.0" ) == 0 )
4661 return (void *)this;
4662 {
4663 void *_p;
4664 if ((_p = Components::Navigation::_narrow_helper( _repoid )))
4665 return _p;
4666 }
4667 {
4668 void *_p;
4669 if ((_p = Components::Receptacles::_narrow_helper( _repoid )))
4670 return _p;
4671 }
4672 {
4673 void *_p;
4674 if ((_p = Components::Events::_narrow_helper( _repoid )))
4675 return _p;
4676 }
4677 return NULL;
4678 }
4679
4680 Components::CCMObject_ptr
4681 Components::CCMObject::_narrow( CORBA::Object_ptr _obj )
4682 {
4683 Components::CCMObject_ptr _o;
4684 if( !CORBA::is_nil( _obj ) ) {
4685 void *_p;
4686 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/CCMObject:1.0" )))
4687 return _duplicate( (Components::CCMObject_ptr) _p );
4688 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/CCMObject:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/CCMObject:1.0")) {
4689 _o = new Components::CCMObject_stub;
4690 _o->CORBA::Object::operator=( *_obj );
4691 return _o;
4692 }
4693 }
4694 return _nil();
4695 }
4696
4697 Components::CCMObject_ptr
4698 Components::CCMObject::_narrow( CORBA::AbstractBase_ptr _obj )
4699 {
4700 return _narrow (_obj->_to_object());
4701 }
4702
4703 class _Marshaller_Components_CCMObject : public ::CORBA::StaticTypeInfo {
4704 typedef Components::CCMObject_ptr _MICO_T;
4705 public:
4706 StaticValueType create () const;
4707 void assign (StaticValueType dst, const StaticValueType src) const;
4708 void free (StaticValueType) const;
4709 void release (StaticValueType) const;
4710 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
4711 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
4712 };
4713
4714
4715 ::CORBA::StaticValueType _Marshaller_Components_CCMObject::create() const
4716 {
4717 return (StaticValueType) new _MICO_T( 0 );
4718 }
4719
4720 void _Marshaller_Components_CCMObject::assign( StaticValueType d, const StaticValueType s ) const
4721 {
4722 *(_MICO_T*) d = ::Components::CCMObject::_duplicate( *(_MICO_T*) s );
4723 }
4724
4725 void _Marshaller_Components_CCMObject::free( StaticValueType v ) const
4726 {
4727 ::CORBA::release( *(_MICO_T *) v );
4728 delete (_MICO_T*) v;
4729 }
4730
4731 void _Marshaller_Components_CCMObject::release( StaticValueType v ) const
4732 {
4733 ::CORBA::release( *(_MICO_T *) v );
4734 }
4735
4736 ::CORBA::Boolean _Marshaller_Components_CCMObject::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
4737 {
4738 ::CORBA::Object_ptr obj;
4739 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
4740 return FALSE;
4741 *(_MICO_T *) v = ::Components::CCMObject::_narrow( obj );
4742 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
4743 ::CORBA::release (obj);
4744 return ret;
4745 }
4746
4747 void _Marshaller_Components_CCMObject::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
4748 {
4749 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
4750 ::CORBA::_stc_Object->marshal( ec, &obj );
4751 }
4752
4753 ::CORBA::StaticTypeInfo *_marshaller_Components_CCMObject;
4754
4755
4756
4757
4758 Components::CCMObject_stub::~CCMObject_stub()
4759 {
4760 }
4761
4762 #ifndef MICO_CONF_NO_POA
4763
4764 void *
4765 POA_Components::CCMObject::_narrow_helper (const char * repoid)
4766 {
4767 void * p;
4768 if (strcmp (repoid, "IDL:omg.org/Components/CCMObject:1.0") == 0) {
4769 return (void *) this;
4770 }
4771 if ((p = POA_Components::Navigation::_narrow_helper (repoid)) != NULL)
4772 {
4773 return p;
4774 }
4775 if ((p = POA_Components::Receptacles::_narrow_helper (repoid)) != NULL)
4776 {
4777 return p;
4778 }
4779 if ((p = POA_Components::Events::_narrow_helper (repoid)) != NULL)
4780 {
4781 return p;
4782 }
4783 return NULL;
4784 }
4785
4786 POA_Components::CCMObject *
4787 POA_Components::CCMObject::_narrow (PortableServer::Servant serv)
4788 {
4789 void * p;
4790 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/CCMObject:1.0")) != NULL) {
4791 serv->_add_ref ();
4792 return (POA_Components::CCMObject *) p;
4793 }
4794 return NULL;
4795 }
4796
4797 Components::CCMObject_stub_clp::CCMObject_stub_clp ()
4798 {
4799 }
4800
4801 Components::CCMObject_stub_clp::CCMObject_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
4802 : CORBA::Object(*obj), PortableServer::StubBase(poa)
4803 {
4804 }
4805
4806 Components::CCMObject_stub_clp::~CCMObject_stub_clp ()
4807 {
4808 }
4809
4810 #endif // MICO_CONF_NO_POA
4811
4812 CORBA::Object_ptr Components::CCMObject_stub::get_component_def()
4813 {
4814 CORBA::Object_ptr _res;
4815 CORBA::StaticAny __res( CORBA::_stc_Object, &_res );
4816
4817 CORBA::StaticRequest __req( this, "get_component_def" );
4818 __req.set_result( &__res );
4819
4820 __req.invoke();
4821
4822 mico_sii_throw( &__req,
4823 0);
4824 return _res;
4825 }
4826
4827
4828 #ifndef MICO_CONF_NO_POA
4829
4830 CORBA::Object_ptr
4831 Components::CCMObject_stub_clp::get_component_def()
4832 {
4833 PortableServer::Servant _serv = _preinvoke ();
4834 if (_serv) {
4835 POA_Components::CCMObject * _myserv = POA_Components::CCMObject::_narrow (_serv);
4836 if (_myserv) {
4837 CORBA::Object_ptr __res;
4838
4839 #ifdef HAVE_EXCEPTIONS
4840 try {
4841 #endif
4842 __res = _myserv->get_component_def();
4843 #ifdef HAVE_EXCEPTIONS
4844 }
4845 catch (...) {
4846 _myserv->_remove_ref();
4847 _postinvoke();
4848 throw;
4849 }
4850 #endif
4851
4852 _myserv->_remove_ref();
4853 _postinvoke ();
4854 return __res;
4855 }
4856 _postinvoke ();
4857 }
4858
4859 return Components::CCMObject_stub::get_component_def();
4860 }
4861
4862 #endif // MICO_CONF_NO_POA
4863
4864 Components::CCMHome_ptr Components::CCMObject_stub::get_ccm_home()
4865 {
4866 Components::CCMHome_ptr _res;
4867 CORBA::StaticAny __res( _marshaller_Components_CCMHome, &_res );
4868
4869 CORBA::StaticRequest __req( this, "get_ccm_home" );
4870 __req.set_result( &__res );
4871
4872 __req.invoke();
4873
4874 mico_sii_throw( &__req,
4875 0);
4876 return _res;
4877 }
4878
4879
4880 #ifndef MICO_CONF_NO_POA
4881
4882 Components::CCMHome_ptr
4883 Components::CCMObject_stub_clp::get_ccm_home()
4884 {
4885 PortableServer::Servant _serv = _preinvoke ();
4886 if (_serv) {
4887 POA_Components::CCMObject * _myserv = POA_Components::CCMObject::_narrow (_serv);
4888 if (_myserv) {
4889 Components::CCMHome_ptr __res;
4890
4891 #ifdef HAVE_EXCEPTIONS
4892 try {
4893 #endif
4894 __res = _myserv->get_ccm_home();
4895 #ifdef HAVE_EXCEPTIONS
4896 }
4897 catch (...) {
4898 _myserv->_remove_ref();
4899 _postinvoke();
4900 throw;
4901 }
4902 #endif
4903
4904 _myserv->_remove_ref();
4905 _postinvoke ();
4906 return __res;
4907 }
4908 _postinvoke ();
4909 }
4910
4911 return Components::CCMObject_stub::get_ccm_home();
4912 }
4913
4914 #endif // MICO_CONF_NO_POA
4915
4916 void Components::CCMObject_stub::configuration_complete()
4917 {
4918 CORBA::StaticRequest __req( this, "configuration_complete" );
4919
4920 __req.invoke();
4921
4922 mico_sii_throw( &__req,
4923 0);
4924 }
4925
4926
4927 #ifndef MICO_CONF_NO_POA
4928
4929 void
4930 Components::CCMObject_stub_clp::configuration_complete()
4931 {
4932 PortableServer::Servant _serv = _preinvoke ();
4933 if (_serv) {
4934 POA_Components::CCMObject * _myserv = POA_Components::CCMObject::_narrow (_serv);
4935 if (_myserv) {
4936 #ifdef HAVE_EXCEPTIONS
4937 try {
4938 #endif
4939 _myserv->configuration_complete();
4940 #ifdef HAVE_EXCEPTIONS
4941 }
4942 catch (...) {
4943 _myserv->_remove_ref();
4944 _postinvoke();
4945 throw;
4946 }
4947 #endif
4948
4949 _myserv->_remove_ref();
4950 _postinvoke ();
4951 return;
4952 }
4953 _postinvoke ();
4954 }
4955
4956 Components::CCMObject_stub::configuration_complete();
4957 }
4958
4959 #endif // MICO_CONF_NO_POA
4960
4961 void Components::CCMObject_stub::remove()
4962 {
4963 CORBA::StaticRequest __req( this, "remove" );
4964
4965 __req.invoke();
4966
4967 mico_sii_throw( &__req,
4968 0);
4969 }
4970
4971
4972 #ifndef MICO_CONF_NO_POA
4973
4974 void
4975 Components::CCMObject_stub_clp::remove()
4976 {
4977 PortableServer::Servant _serv = _preinvoke ();
4978 if (_serv) {
4979 POA_Components::CCMObject * _myserv = POA_Components::CCMObject::_narrow (_serv);
4980 if (_myserv) {
4981 #ifdef HAVE_EXCEPTIONS
4982 try {
4983 #endif
4984 _myserv->remove();
4985 #ifdef HAVE_EXCEPTIONS
4986 }
4987 catch (...) {
4988 _myserv->_remove_ref();
4989 _postinvoke();
4990 throw;
4991 }
4992 #endif
4993
4994 _myserv->_remove_ref();
4995 _postinvoke ();
4996 return;
4997 }
4998 _postinvoke ();
4999 }
5000
5001 Components::CCMObject_stub::remove();
5002 }
5003
5004 #endif // MICO_CONF_NO_POA
5005
5006 Components::ComponentPortDescription* Components::CCMObject_stub::get_all_ports()
5007 {
5008 Components::ComponentPortDescription* _res;
5009 CORBA::StaticAny __res( _marshaller_Components_ComponentPortDescription, &_res );
5010
5011 CORBA::StaticRequest __req( this, "get_all_ports" );
5012 __req.set_result( &__res );
5013
5014 __req.invoke();
5015
5016 mico_sii_throw( &__req,
5017 0);
5018 return _res;
5019 }
5020
5021
5022 #ifndef MICO_CONF_NO_POA
5023
5024 Components::ComponentPortDescription*
5025 Components::CCMObject_stub_clp::get_all_ports()
5026 {
5027 PortableServer::Servant _serv = _preinvoke ();
5028 if (_serv) {
5029 POA_Components::CCMObject * _myserv = POA_Components::CCMObject::_narrow (_serv);
5030 if (_myserv) {
5031 Components::ComponentPortDescription* __res;
5032
5033 #ifdef HAVE_EXCEPTIONS
5034 try {
5035 #endif
5036 __res = _myserv->get_all_ports();
5037 #ifdef HAVE_EXCEPTIONS
5038 }
5039 catch (...) {
5040 _myserv->_remove_ref();
5041 _postinvoke();
5042 throw;
5043 }
5044 #endif
5045
5046 _myserv->_remove_ref();
5047 _postinvoke ();
5048 Components::ComponentPortDescription* __res2 = Components::ComponentPortDescription::_downcast (__res->_copy_value ());
5049 CORBA::remove_ref (__res);
5050 return __res2;
5051 }
5052 _postinvoke ();
5053 }
5054
5055 return Components::CCMObject_stub::get_all_ports();
5056 }
5057
5058 #endif // MICO_CONF_NO_POA
5059
5060
5061 #ifdef HAVE_EXPLICIT_STRUCT_OPS
5062 Components::DuplicateKeyValue::DuplicateKeyValue()
5063 {
5064 }
5065
5066 Components::DuplicateKeyValue::DuplicateKeyValue( const DuplicateKeyValue& _s )
5067 {
5068 }
5069
5070 Components::DuplicateKeyValue::~DuplicateKeyValue()
5071 {
5072 }
5073
5074 Components::DuplicateKeyValue&
5075 Components::DuplicateKeyValue::operator=( const DuplicateKeyValue& _s )
5076 {
5077 return *this;
5078 }
5079 #endif
5080
5081 class _Marshaller_Components_DuplicateKeyValue : public ::CORBA::StaticTypeInfo {
5082 typedef ::Components::DuplicateKeyValue _MICO_T;
5083 public:
5084 StaticValueType create () const;
5085 void assign (StaticValueType dst, const StaticValueType src) const;
5086 void free (StaticValueType) const;
5087 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
5088 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
5089 };
5090
5091
5092 ::CORBA::StaticValueType _Marshaller_Components_DuplicateKeyValue::create() const
5093 {
5094 return (StaticValueType) new _MICO_T;
5095 }
5096
5097 void _Marshaller_Components_DuplicateKeyValue::assign( StaticValueType d, const StaticValueType s ) const
5098 {
5099 *(_MICO_T*) d = *(_MICO_T*) s;
5100 }
5101
5102 void _Marshaller_Components_DuplicateKeyValue::free( StaticValueType v ) const
5103 {
5104 delete (_MICO_T*) v;
5105 }
5106
5107 ::CORBA::Boolean _Marshaller_Components_DuplicateKeyValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
5108 {
5109 string repoid;
5110 return
5111 dc.except_begin( repoid ) &&
5112 dc.except_end();
5113 }
5114
5115 void _Marshaller_Components_DuplicateKeyValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
5116 {
5117 ec.except_begin( "IDL:omg.org/Components/DuplicateKeyValue:1.0" );
5118 ec.except_end();
5119 }
5120
5121 ::CORBA::StaticTypeInfo *_marshaller_Components_DuplicateKeyValue;
5122
5123 void Components::DuplicateKeyValue::_throwit() const
5124 {
5125 #ifdef HAVE_EXCEPTIONS
5126 #ifdef HAVE_STD_EH
5127 throw *this;
5128 #else
5129 throw DuplicateKeyValue_var( (Components::DuplicateKeyValue*)_clone() );
5130 #endif
5131 #else
5132 CORBA::Exception::_throw_failed( _clone() );
5133 #endif
5134 }
5135
5136 const char *Components::DuplicateKeyValue::_repoid() const
5137 {
5138 return "IDL:omg.org/Components/DuplicateKeyValue:1.0";
5139 }
5140
5141 void Components::DuplicateKeyValue::_encode( CORBA::DataEncoder &_en ) const
5142 {
5143 _marshaller_Components_DuplicateKeyValue->marshal( _en, (void*) this );
5144 }
5145
5146 void Components::DuplicateKeyValue::_encode_any( CORBA::Any & ) const
5147 {
5148
5149 assert(0);
5150 }
5151
5152 CORBA::Exception *Components::DuplicateKeyValue::_clone() const
5153 {
5154 return new DuplicateKeyValue( *this );
5155 }
5156
5157 Components::DuplicateKeyValue *Components::DuplicateKeyValue::_downcast( CORBA::Exception *_ex )
5158 {
5159 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/DuplicateKeyValue:1.0" ) )
5160 return (DuplicateKeyValue *) _ex;
5161 return NULL;
5162 }
5163
5164 const Components::DuplicateKeyValue *Components::DuplicateKeyValue::_downcast( const CORBA::Exception *_ex )
5165 {
5166 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/DuplicateKeyValue:1.0" ) )
5167 return (DuplicateKeyValue *) _ex;
5168 return NULL;
5169 }
5170
5171
5172 #ifdef HAVE_EXPLICIT_STRUCT_OPS
5173 Components::UnknownKeyValue::UnknownKeyValue()
5174 {
5175 }
5176
5177 Components::UnknownKeyValue::UnknownKeyValue( const UnknownKeyValue& _s )
5178 {
5179 }
5180
5181 Components::UnknownKeyValue::~UnknownKeyValue()
5182 {
5183 }
5184
5185 Components::UnknownKeyValue&
5186 Components::UnknownKeyValue::operator=( const UnknownKeyValue& _s )
5187 {
5188 return *this;
5189 }
5190 #endif
5191
5192 class _Marshaller_Components_UnknownKeyValue : public ::CORBA::StaticTypeInfo {
5193 typedef ::Components::UnknownKeyValue _MICO_T;
5194 public:
5195 StaticValueType create () const;
5196 void assign (StaticValueType dst, const StaticValueType src) const;
5197 void free (StaticValueType) const;
5198 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
5199 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
5200 };
5201
5202
5203 ::CORBA::StaticValueType _Marshaller_Components_UnknownKeyValue::create() const
5204 {
5205 return (StaticValueType) new _MICO_T;
5206 }
5207
5208 void _Marshaller_Components_UnknownKeyValue::assign( StaticValueType d, const StaticValueType s ) const
5209 {
5210 *(_MICO_T*) d = *(_MICO_T*) s;
5211 }
5212
5213 void _Marshaller_Components_UnknownKeyValue::free( StaticValueType v ) const
5214 {
5215 delete (_MICO_T*) v;
5216 }
5217
5218 ::CORBA::Boolean _Marshaller_Components_UnknownKeyValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
5219 {
5220 string repoid;
5221 return
5222 dc.except_begin( repoid ) &&
5223 dc.except_end();
5224 }
5225
5226 void _Marshaller_Components_UnknownKeyValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
5227 {
5228 ec.except_begin( "IDL:omg.org/Components/UnknownKeyValue:1.0" );
5229 ec.except_end();
5230 }
5231
5232 ::CORBA::StaticTypeInfo *_marshaller_Components_UnknownKeyValue;
5233
5234 void Components::UnknownKeyValue::_throwit() const
5235 {
5236 #ifdef HAVE_EXCEPTIONS
5237 #ifdef HAVE_STD_EH
5238 throw *this;
5239 #else
5240 throw UnknownKeyValue_var( (Components::UnknownKeyValue*)_clone() );
5241 #endif
5242 #else
5243 CORBA::Exception::_throw_failed( _clone() );
5244 #endif
5245 }
5246
5247 const char *Components::UnknownKeyValue::_repoid() const
5248 {
5249 return "IDL:omg.org/Components/UnknownKeyValue:1.0";
5250 }
5251
5252 void Components::UnknownKeyValue::_encode( CORBA::DataEncoder &_en ) const
5253 {
5254 _marshaller_Components_UnknownKeyValue->marshal( _en, (void*) this );
5255 }
5256
5257 void Components::UnknownKeyValue::_encode_any( CORBA::Any & ) const
5258 {
5259
5260 assert(0);
5261 }
5262
5263 CORBA::Exception *Components::UnknownKeyValue::_clone() const
5264 {
5265 return new UnknownKeyValue( *this );
5266 }
5267
5268 Components::UnknownKeyValue *Components::UnknownKeyValue::_downcast( CORBA::Exception *_ex )
5269 {
5270 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/UnknownKeyValue:1.0" ) )
5271 return (UnknownKeyValue *) _ex;
5272 return NULL;
5273 }
5274
5275 const Components::UnknownKeyValue *Components::UnknownKeyValue::_downcast( const CORBA::Exception *_ex )
5276 {
5277 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/UnknownKeyValue:1.0" ) )
5278 return (UnknownKeyValue *) _ex;
5279 return NULL;
5280 }
5281
5282
5283 #ifdef HAVE_EXPLICIT_STRUCT_OPS
5284 Components::InvalidKey::InvalidKey()
5285 {
5286 }
5287
5288 Components::InvalidKey::InvalidKey( const InvalidKey& _s )
5289 {
5290 }
5291
5292 Components::InvalidKey::~InvalidKey()
5293 {
5294 }
5295
5296 Components::InvalidKey&
5297 Components::InvalidKey::operator=( const InvalidKey& _s )
5298 {
5299 return *this;
5300 }
5301 #endif
5302
5303 class _Marshaller_Components_InvalidKey : public ::CORBA::StaticTypeInfo {
5304 typedef ::Components::InvalidKey _MICO_T;
5305 public:
5306 StaticValueType create () const;
5307 void assign (StaticValueType dst, const StaticValueType src) const;
5308 void free (StaticValueType) const;
5309 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
5310 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
5311 };
5312
5313
5314 ::CORBA::StaticValueType _Marshaller_Components_InvalidKey::create() const
5315 {
5316 return (StaticValueType) new _MICO_T;
5317 }
5318
5319 void _Marshaller_Components_InvalidKey::assign( StaticValueType d, const StaticValueType s ) const
5320 {
5321 *(_MICO_T*) d = *(_MICO_T*) s;
5322 }
5323
5324 void _Marshaller_Components_InvalidKey::free( StaticValueType v ) const
5325 {
5326 delete (_MICO_T*) v;
5327 }
5328
5329 ::CORBA::Boolean _Marshaller_Components_InvalidKey::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
5330 {
5331 string repoid;
5332 return
5333 dc.except_begin( repoid ) &&
5334 dc.except_end();
5335 }
5336
5337 void _Marshaller_Components_InvalidKey::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
5338 {
5339 ec.except_begin( "IDL:omg.org/Components/InvalidKey:1.0" );
5340 ec.except_end();
5341 }
5342
5343 ::CORBA::StaticTypeInfo *_marshaller_Components_InvalidKey;
5344
5345 void Components::InvalidKey::_throwit() const
5346 {
5347 #ifdef HAVE_EXCEPTIONS
5348 #ifdef HAVE_STD_EH
5349 throw *this;
5350 #else
5351 throw InvalidKey_var( (Components::InvalidKey*)_clone() );
5352 #endif
5353 #else
5354 CORBA::Exception::_throw_failed( _clone() );
5355 #endif
5356 }
5357
5358 const char *Components::InvalidKey::_repoid() const
5359 {
5360 return "IDL:omg.org/Components/InvalidKey:1.0";
5361 }
5362
5363 void Components::InvalidKey::_encode( CORBA::DataEncoder &_en ) const
5364 {
5365 _marshaller_Components_InvalidKey->marshal( _en, (void*) this );
5366 }
5367
5368 void Components::InvalidKey::_encode_any( CORBA::Any & ) const
5369 {
5370
5371 assert(0);
5372 }
5373
5374 CORBA::Exception *Components::InvalidKey::_clone() const
5375 {
5376 return new InvalidKey( *this );
5377 }
5378
5379 Components::InvalidKey *Components::InvalidKey::_downcast( CORBA::Exception *_ex )
5380 {
5381 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidKey:1.0" ) )
5382 return (InvalidKey *) _ex;
5383 return NULL;
5384 }
5385
5386 const Components::InvalidKey *Components::InvalidKey::_downcast( const CORBA::Exception *_ex )
5387 {
5388 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidKey:1.0" ) )
5389 return (InvalidKey *) _ex;
5390 return NULL;
5391 }
5392
5393
5394
5395
5396
5397 Components::KeylessCCMHome::~KeylessCCMHome()
5398 {
5399 }
5400
5401 void *
5402 Components::KeylessCCMHome::_narrow_helper( const char *_repoid )
5403 {
5404 if( strcmp( _repoid, "IDL:omg.org/Components/KeylessCCMHome:1.0" ) == 0 )
5405 return (void *)this;
5406 return NULL;
5407 }
5408
5409 Components::KeylessCCMHome_ptr
5410 Components::KeylessCCMHome::_narrow( CORBA::Object_ptr _obj )
5411 {
5412 Components::KeylessCCMHome_ptr _o;
5413 if( !CORBA::is_nil( _obj ) ) {
5414 void *_p;
5415 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/KeylessCCMHome:1.0" )))
5416 return _duplicate( (Components::KeylessCCMHome_ptr) _p );
5417 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/KeylessCCMHome:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/KeylessCCMHome:1.0")) {
5418 _o = new Components::KeylessCCMHome_stub;
5419 _o->CORBA::Object::operator=( *_obj );
5420 return _o;
5421 }
5422 }
5423 return _nil();
5424 }
5425
5426 Components::KeylessCCMHome_ptr
5427 Components::KeylessCCMHome::_narrow( CORBA::AbstractBase_ptr _obj )
5428 {
5429 return _narrow (_obj->_to_object());
5430 }
5431
5432 class _Marshaller_Components_KeylessCCMHome : public ::CORBA::StaticTypeInfo {
5433 typedef Components::KeylessCCMHome_ptr _MICO_T;
5434 public:
5435 StaticValueType create () const;
5436 void assign (StaticValueType dst, const StaticValueType src) const;
5437 void free (StaticValueType) const;
5438 void release (StaticValueType) const;
5439 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
5440 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
5441 };
5442
5443
5444 ::CORBA::StaticValueType _Marshaller_Components_KeylessCCMHome::create() const
5445 {
5446 return (StaticValueType) new _MICO_T( 0 );
5447 }
5448
5449 void _Marshaller_Components_KeylessCCMHome::assign( StaticValueType d, const StaticValueType s ) const
5450 {
5451 *(_MICO_T*) d = ::Components::KeylessCCMHome::_duplicate( *(_MICO_T*) s );
5452 }
5453
5454 void _Marshaller_Components_KeylessCCMHome::free( StaticValueType v ) const
5455 {
5456 ::CORBA::release( *(_MICO_T *) v );
5457 delete (_MICO_T*) v;
5458 }
5459
5460 void _Marshaller_Components_KeylessCCMHome::release( StaticValueType v ) const
5461 {
5462 ::CORBA::release( *(_MICO_T *) v );
5463 }
5464
5465 ::CORBA::Boolean _Marshaller_Components_KeylessCCMHome::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
5466 {
5467 ::CORBA::Object_ptr obj;
5468 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
5469 return FALSE;
5470 *(_MICO_T *) v = ::Components::KeylessCCMHome::_narrow( obj );
5471 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
5472 ::CORBA::release (obj);
5473 return ret;
5474 }
5475
5476 void _Marshaller_Components_KeylessCCMHome::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
5477 {
5478 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
5479 ::CORBA::_stc_Object->marshal( ec, &obj );
5480 }
5481
5482 ::CORBA::StaticTypeInfo *_marshaller_Components_KeylessCCMHome;
5483
5484
5485
5486
5487 Components::KeylessCCMHome_stub::~KeylessCCMHome_stub()
5488 {
5489 }
5490
5491 #ifndef MICO_CONF_NO_POA
5492
5493 void *
5494 POA_Components::KeylessCCMHome::_narrow_helper (const char * repoid)
5495 {
5496 if (strcmp (repoid, "IDL:omg.org/Components/KeylessCCMHome:1.0") == 0) {
5497 return (void *) this;
5498 }
5499 return NULL;
5500 }
5501
5502 POA_Components::KeylessCCMHome *
5503 POA_Components::KeylessCCMHome::_narrow (PortableServer::Servant serv)
5504 {
5505 void * p;
5506 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/KeylessCCMHome:1.0")) != NULL) {
5507 serv->_add_ref ();
5508 return (POA_Components::KeylessCCMHome *) p;
5509 }
5510 return NULL;
5511 }
5512
5513 Components::KeylessCCMHome_stub_clp::KeylessCCMHome_stub_clp ()
5514 {
5515 }
5516
5517 Components::KeylessCCMHome_stub_clp::KeylessCCMHome_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
5518 : CORBA::Object(*obj), PortableServer::StubBase(poa)
5519 {
5520 }
5521
5522 Components::KeylessCCMHome_stub_clp::~KeylessCCMHome_stub_clp ()
5523 {
5524 }
5525
5526 #endif // MICO_CONF_NO_POA
5527
5528 Components::CCMObject_ptr Components::KeylessCCMHome_stub::create_component()
5529 {
5530 Components::CCMObject_ptr _res;
5531 CORBA::StaticAny __res( _marshaller_Components_CCMObject, &_res );
5532
5533 CORBA::StaticRequest __req( this, "create_component" );
5534 __req.set_result( &__res );
5535
5536 __req.invoke();
5537
5538 mico_sii_throw( &__req,
5539 0);
5540 return _res;
5541 }
5542
5543
5544 #ifndef MICO_CONF_NO_POA
5545
5546 Components::CCMObject_ptr
5547 Components::KeylessCCMHome_stub_clp::create_component()
5548 {
5549 PortableServer::Servant _serv = _preinvoke ();
5550 if (_serv) {
5551 POA_Components::KeylessCCMHome * _myserv = POA_Components::KeylessCCMHome::_narrow (_serv);
5552 if (_myserv) {
5553 Components::CCMObject_ptr __res;
5554
5555 #ifdef HAVE_EXCEPTIONS
5556 try {
5557 #endif
5558 __res = _myserv->create_component();
5559 #ifdef HAVE_EXCEPTIONS
5560 }
5561 catch (...) {
5562 _myserv->_remove_ref();
5563 _postinvoke();
5564 throw;
5565 }
5566 #endif
5567
5568 _myserv->_remove_ref();
5569 _postinvoke ();
5570 return __res;
5571 }
5572 _postinvoke ();
5573 }
5574
5575 return Components::KeylessCCMHome_stub::create_component();
5576 }
5577
5578 #endif // MICO_CONF_NO_POA
5579
5580
5581 #ifdef HAVE_EXPLICIT_STRUCT_OPS
5582 Components::HomeNotFound::HomeNotFound()
5583 {
5584 }
5585
5586 Components::HomeNotFound::HomeNotFound( const HomeNotFound& _s )
5587 {
5588 }
5589
5590 Components::HomeNotFound::~HomeNotFound()
5591 {
5592 }
5593
5594 Components::HomeNotFound&
5595 Components::HomeNotFound::operator=( const HomeNotFound& _s )
5596 {
5597 return *this;
5598 }
5599 #endif
5600
5601 class _Marshaller_Components_HomeNotFound : public ::CORBA::StaticTypeInfo {
5602 typedef ::Components::HomeNotFound _MICO_T;
5603 public:
5604 StaticValueType create () const;
5605 void assign (StaticValueType dst, const StaticValueType src) const;
5606 void free (StaticValueType) const;
5607 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
5608 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
5609 };
5610
5611
5612 ::CORBA::StaticValueType _Marshaller_Components_HomeNotFound::create() const
5613 {
5614 return (StaticValueType) new _MICO_T;
5615 }
5616
5617 void _Marshaller_Components_HomeNotFound::assign( StaticValueType d, const StaticValueType s ) const
5618 {
5619 *(_MICO_T*) d = *(_MICO_T*) s;
5620 }
5621
5622 void _Marshaller_Components_HomeNotFound::free( StaticValueType v ) const
5623 {
5624 delete (_MICO_T*) v;
5625 }
5626
5627 ::CORBA::Boolean _Marshaller_Components_HomeNotFound::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
5628 {
5629 string repoid;
5630 return
5631 dc.except_begin( repoid ) &&
5632 dc.except_end();
5633 }
5634
5635 void _Marshaller_Components_HomeNotFound::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
5636 {
5637 ec.except_begin( "IDL:omg.org/Components/HomeNotFound:1.0" );
5638 ec.except_end();
5639 }
5640
5641 ::CORBA::StaticTypeInfo *_marshaller_Components_HomeNotFound;
5642
5643 void Components::HomeNotFound::_throwit() const
5644 {
5645 #ifdef HAVE_EXCEPTIONS
5646 #ifdef HAVE_STD_EH
5647 throw *this;
5648 #else
5649 throw HomeNotFound_var( (Components::HomeNotFound*)_clone() );
5650 #endif
5651 #else
5652 CORBA::Exception::_throw_failed( _clone() );
5653 #endif
5654 }
5655
5656 const char *Components::HomeNotFound::_repoid() const
5657 {
5658 return "IDL:omg.org/Components/HomeNotFound:1.0";
5659 }
5660
5661 void Components::HomeNotFound::_encode( CORBA::DataEncoder &_en ) const
5662 {
5663 _marshaller_Components_HomeNotFound->marshal( _en, (void*) this );
5664 }
5665
5666 void Components::HomeNotFound::_encode_any( CORBA::Any & ) const
5667 {
5668
5669 assert(0);
5670 }
5671
5672 CORBA::Exception *Components::HomeNotFound::_clone() const
5673 {
5674 return new HomeNotFound( *this );
5675 }
5676
5677 Components::HomeNotFound *Components::HomeNotFound::_downcast( CORBA::Exception *_ex )
5678 {
5679 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/HomeNotFound:1.0" ) )
5680 return (HomeNotFound *) _ex;
5681 return NULL;
5682 }
5683
5684 const Components::HomeNotFound *Components::HomeNotFound::_downcast( const CORBA::Exception *_ex )
5685 {
5686 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/HomeNotFound:1.0" ) )
5687 return (HomeNotFound *) _ex;
5688 return NULL;
5689 }
5690
5691
5692
5693
5694 Components::HomeFinder::~HomeFinder()
5695 {
5696 }
5697
5698 void *
5699 Components::HomeFinder::_narrow_helper( const char *_repoid )
5700 {
5701 if( strcmp( _repoid, "IDL:omg.org/Components/HomeFinder:1.0" ) == 0 )
5702 return (void *)this;
5703 return NULL;
5704 }
5705
5706 Components::HomeFinder_ptr
5707 Components::HomeFinder::_narrow( CORBA::Object_ptr _obj )
5708 {
5709 Components::HomeFinder_ptr _o;
5710 if( !CORBA::is_nil( _obj ) ) {
5711 void *_p;
5712 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/HomeFinder:1.0" )))
5713 return _duplicate( (Components::HomeFinder_ptr) _p );
5714 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/HomeFinder:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/HomeFinder:1.0")) {
5715 _o = new Components::HomeFinder_stub;
5716 _o->CORBA::Object::operator=( *_obj );
5717 return _o;
5718 }
5719 }
5720 return _nil();
5721 }
5722
5723 Components::HomeFinder_ptr
5724 Components::HomeFinder::_narrow( CORBA::AbstractBase_ptr _obj )
5725 {
5726 return _narrow (_obj->_to_object());
5727 }
5728
5729 class _Marshaller_Components_HomeFinder : public ::CORBA::StaticTypeInfo {
5730 typedef Components::HomeFinder_ptr _MICO_T;
5731 public:
5732 StaticValueType create () const;
5733 void assign (StaticValueType dst, const StaticValueType src) const;
5734 void free (StaticValueType) const;
5735 void release (StaticValueType) const;
5736 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
5737 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
5738 };
5739
5740
5741 ::CORBA::StaticValueType _Marshaller_Components_HomeFinder::create() const
5742 {
5743 return (StaticValueType) new _MICO_T( 0 );
5744 }
5745
5746 void _Marshaller_Components_HomeFinder::assign( StaticValueType d, const StaticValueType s ) const
5747 {
5748 *(_MICO_T*) d = ::Components::HomeFinder::_duplicate( *(_MICO_T*) s );
5749 }
5750
5751 void _Marshaller_Components_HomeFinder::free( StaticValueType v ) const
5752 {
5753 ::CORBA::release( *(_MICO_T *) v );
5754 delete (_MICO_T*) v;
5755 }
5756
5757 void _Marshaller_Components_HomeFinder::release( StaticValueType v ) const
5758 {
5759 ::CORBA::release( *(_MICO_T *) v );
5760 }
5761
5762 ::CORBA::Boolean _Marshaller_Components_HomeFinder::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
5763 {
5764 ::CORBA::Object_ptr obj;
5765 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
5766 return FALSE;
5767 *(_MICO_T *) v = ::Components::HomeFinder::_narrow( obj );
5768 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
5769 ::CORBA::release (obj);
5770 return ret;
5771 }
5772
5773 void _Marshaller_Components_HomeFinder::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
5774 {
5775 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
5776 ::CORBA::_stc_Object->marshal( ec, &obj );
5777 }
5778
5779 ::CORBA::StaticTypeInfo *_marshaller_Components_HomeFinder;
5780
5781
5782
5783
5784 Components::HomeFinder_stub::~HomeFinder_stub()
5785 {
5786 }
5787
5788 #ifndef MICO_CONF_NO_POA
5789
5790 void *
5791 POA_Components::HomeFinder::_narrow_helper (const char * repoid)
5792 {
5793 if (strcmp (repoid, "IDL:omg.org/Components/HomeFinder:1.0") == 0) {
5794 return (void *) this;
5795 }
5796 return NULL;
5797 }
5798
5799 POA_Components::HomeFinder *
5800 POA_Components::HomeFinder::_narrow (PortableServer::Servant serv)
5801 {
5802 void * p;
5803 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/HomeFinder:1.0")) != NULL) {
5804 serv->_add_ref ();
5805 return (POA_Components::HomeFinder *) p;
5806 }
5807 return NULL;
5808 }
5809
5810 Components::HomeFinder_stub_clp::HomeFinder_stub_clp ()
5811 {
5812 }
5813
5814 Components::HomeFinder_stub_clp::HomeFinder_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
5815 : CORBA::Object(*obj), PortableServer::StubBase(poa)
5816 {
5817 }
5818
5819 Components::HomeFinder_stub_clp::~HomeFinder_stub_clp ()
5820 {
5821 }
5822
5823 #endif // MICO_CONF_NO_POA
5824
5825 Components::CCMHome_ptr Components::HomeFinder_stub::find_home_by_component_type( const char* _par_comp_repid )
5826 {
5827 CORBA::StaticAny _sa_comp_repid( CORBA::_stc_string, &_par_comp_repid );
5828 Components::CCMHome_ptr _res;
5829 CORBA::StaticAny __res( _marshaller_Components_CCMHome, &_res );
5830
5831 CORBA::StaticRequest __req( this, "find_home_by_component_type" );
5832 __req.add_in_arg( &_sa_comp_repid );
5833 __req.set_result( &__res );
5834
5835 __req.invoke();
5836
5837 mico_sii_throw( &__req,
5838 _marshaller_Components_HomeNotFound, "IDL:omg.org/Components/HomeNotFound:1.0",
5839 0);
5840 return _res;
5841 }
5842
5843
5844 #ifndef MICO_CONF_NO_POA
5845
5846 Components::CCMHome_ptr
5847 Components::HomeFinder_stub_clp::find_home_by_component_type( const char* _par_comp_repid )
5848 {
5849 PortableServer::Servant _serv = _preinvoke ();
5850 if (_serv) {
5851 POA_Components::HomeFinder * _myserv = POA_Components::HomeFinder::_narrow (_serv);
5852 if (_myserv) {
5853 Components::CCMHome_ptr __res;
5854
5855 #ifdef HAVE_EXCEPTIONS
5856 try {
5857 #endif
5858 __res = _myserv->find_home_by_component_type(_par_comp_repid);
5859 #ifdef HAVE_EXCEPTIONS
5860 }
5861 catch (...) {
5862 _myserv->_remove_ref();
5863 _postinvoke();
5864 throw;
5865 }
5866 #endif
5867
5868 _myserv->_remove_ref();
5869 _postinvoke ();
5870 return __res;
5871 }
5872 _postinvoke ();
5873 }
5874
5875 return Components::HomeFinder_stub::find_home_by_component_type(_par_comp_repid);
5876 }
5877
5878 #endif // MICO_CONF_NO_POA
5879
5880 Components::CCMHome_ptr Components::HomeFinder_stub::find_home_by_home_type( const char* _par_home_repid )
5881 {
5882 CORBA::StaticAny _sa_home_repid( CORBA::_stc_string, &_par_home_repid );
5883 Components::CCMHome_ptr _res;
5884 CORBA::StaticAny __res( _marshaller_Components_CCMHome, &_res );
5885
5886 CORBA::StaticRequest __req( this, "find_home_by_home_type" );
5887 __req.add_in_arg( &_sa_home_repid );
5888 __req.set_result( &__res );
5889
5890 __req.invoke();
5891
5892 mico_sii_throw( &__req,
5893 _marshaller_Components_HomeNotFound, "IDL:omg.org/Components/HomeNotFound:1.0",
5894 0);
5895 return _res;
5896 }
5897
5898
5899 #ifndef MICO_CONF_NO_POA
5900
5901 Components::CCMHome_ptr
5902 Components::HomeFinder_stub_clp::find_home_by_home_type( const char* _par_home_repid )
5903 {
5904 PortableServer::Servant _serv = _preinvoke ();
5905 if (_serv) {
5906 POA_Components::HomeFinder * _myserv = POA_Components::HomeFinder::_narrow (_serv);
5907 if (_myserv) {
5908 Components::CCMHome_ptr __res;
5909
5910 #ifdef HAVE_EXCEPTIONS
5911 try {
5912 #endif
5913 __res = _myserv->find_home_by_home_type(_par_home_repid);
5914 #ifdef HAVE_EXCEPTIONS
5915 }
5916 catch (...) {
5917 _myserv->_remove_ref();
5918 _postinvoke();
5919 throw;
5920 }
5921 #endif
5922
5923 _myserv->_remove_ref();
5924 _postinvoke ();
5925 return __res;
5926 }
5927 _postinvoke ();
5928 }
5929
5930 return Components::HomeFinder_stub::find_home_by_home_type(_par_home_repid);
5931 }
5932
5933 #endif // MICO_CONF_NO_POA
5934
5935 Components::CCMHome_ptr Components::HomeFinder_stub::find_home_by_name( const char* _par_home_name )
5936 {
5937 CORBA::StaticAny _sa_home_name( CORBA::_stc_string, &_par_home_name );
5938 Components::CCMHome_ptr _res;
5939 CORBA::StaticAny __res( _marshaller_Components_CCMHome, &_res );
5940
5941 CORBA::StaticRequest __req( this, "find_home_by_name" );
5942 __req.add_in_arg( &_sa_home_name );
5943 __req.set_result( &__res );
5944
5945 __req.invoke();
5946
5947 mico_sii_throw( &__req,
5948 0);
5949 return _res;
5950 }
5951
5952
5953 #ifndef MICO_CONF_NO_POA
5954
5955 Components::CCMHome_ptr
5956 Components::HomeFinder_stub_clp::find_home_by_name( const char* _par_home_name )
5957 {
5958 PortableServer::Servant _serv = _preinvoke ();
5959 if (_serv) {
5960 POA_Components::HomeFinder * _myserv = POA_Components::HomeFinder::_narrow (_serv);
5961 if (_myserv) {
5962 Components::CCMHome_ptr __res;
5963
5964 #ifdef HAVE_EXCEPTIONS
5965 try {
5966 #endif
5967 __res = _myserv->find_home_by_name(_par_home_name);
5968 #ifdef HAVE_EXCEPTIONS
5969 }
5970 catch (...) {
5971 _myserv->_remove_ref();
5972 _postinvoke();
5973 throw;
5974 }
5975 #endif
5976
5977 _myserv->_remove_ref();
5978 _postinvoke ();
5979 return __res;
5980 }
5981 _postinvoke ();
5982 }
5983
5984 return Components::HomeFinder_stub::find_home_by_name(_par_home_name);
5985 }
5986
5987 #endif // MICO_CONF_NO_POA
5988
5989
5990 #ifdef HAVE_EXPLICIT_STRUCT_OPS
5991 Components::WrongComponentType::WrongComponentType()
5992 {
5993 }
5994
5995 Components::WrongComponentType::WrongComponentType( const WrongComponentType& _s )
5996 {
5997 }
5998
5999 Components::WrongComponentType::~WrongComponentType()
6000 {
6001 }
6002
6003 Components::WrongComponentType&
6004 Components::WrongComponentType::operator=( const WrongComponentType& _s )
6005 {
6006 return *this;
6007 }
6008 #endif
6009
6010 class _Marshaller_Components_WrongComponentType : public ::CORBA::StaticTypeInfo {
6011 typedef ::Components::WrongComponentType _MICO_T;
6012 public:
6013 StaticValueType create () const;
6014 void assign (StaticValueType dst, const StaticValueType src) const;
6015 void free (StaticValueType) const;
6016 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
6017 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
6018 };
6019
6020
6021 ::CORBA::StaticValueType _Marshaller_Components_WrongComponentType::create() const
6022 {
6023 return (StaticValueType) new _MICO_T;
6024 }
6025
6026 void _Marshaller_Components_WrongComponentType::assign( StaticValueType d, const StaticValueType s ) const
6027 {
6028 *(_MICO_T*) d = *(_MICO_T*) s;
6029 }
6030
6031 void _Marshaller_Components_WrongComponentType::free( StaticValueType v ) const
6032 {
6033 delete (_MICO_T*) v;
6034 }
6035
6036 ::CORBA::Boolean _Marshaller_Components_WrongComponentType::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
6037 {
6038 string repoid;
6039 return
6040 dc.except_begin( repoid ) &&
6041 dc.except_end();
6042 }
6043
6044 void _Marshaller_Components_WrongComponentType::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
6045 {
6046 ec.except_begin( "IDL:omg.org/Components/WrongComponentType:1.0" );
6047 ec.except_end();
6048 }
6049
6050 ::CORBA::StaticTypeInfo *_marshaller_Components_WrongComponentType;
6051
6052 void Components::WrongComponentType::_throwit() const
6053 {
6054 #ifdef HAVE_EXCEPTIONS
6055 #ifdef HAVE_STD_EH
6056 throw *this;
6057 #else
6058 throw WrongComponentType_var( (Components::WrongComponentType*)_clone() );
6059 #endif
6060 #else
6061 CORBA::Exception::_throw_failed( _clone() );
6062 #endif
6063 }
6064
6065 const char *Components::WrongComponentType::_repoid() const
6066 {
6067 return "IDL:omg.org/Components/WrongComponentType:1.0";
6068 }
6069
6070 void Components::WrongComponentType::_encode( CORBA::DataEncoder &_en ) const
6071 {
6072 _marshaller_Components_WrongComponentType->marshal( _en, (void*) this );
6073 }
6074
6075 void Components::WrongComponentType::_encode_any( CORBA::Any & ) const
6076 {
6077
6078 assert(0);
6079 }
6080
6081 CORBA::Exception *Components::WrongComponentType::_clone() const
6082 {
6083 return new WrongComponentType( *this );
6084 }
6085
6086 Components::WrongComponentType *Components::WrongComponentType::_downcast( CORBA::Exception *_ex )
6087 {
6088 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/WrongComponentType:1.0" ) )
6089 return (WrongComponentType *) _ex;
6090 return NULL;
6091 }
6092
6093 const Components::WrongComponentType *Components::WrongComponentType::_downcast( const CORBA::Exception *_ex )
6094 {
6095 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/WrongComponentType:1.0" ) )
6096 return (WrongComponentType *) _ex;
6097 return NULL;
6098 }
6099
6100
6101
6102
6103 Components::Configurator::~Configurator()
6104 {
6105 }
6106
6107 void *
6108 Components::Configurator::_narrow_helper( const char *_repoid )
6109 {
6110 if( strcmp( _repoid, "IDL:omg.org/Components/Configurator:1.0" ) == 0 )
6111 return (void *)this;
6112 return NULL;
6113 }
6114
6115 Components::Configurator_ptr
6116 Components::Configurator::_narrow( CORBA::Object_ptr _obj )
6117 {
6118 Components::Configurator_ptr _o;
6119 if( !CORBA::is_nil( _obj ) ) {
6120 void *_p;
6121 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/Configurator:1.0" )))
6122 return _duplicate( (Components::Configurator_ptr) _p );
6123 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/Configurator:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/Configurator:1.0")) {
6124 _o = new Components::Configurator_stub;
6125 _o->CORBA::Object::operator=( *_obj );
6126 return _o;
6127 }
6128 }
6129 return _nil();
6130 }
6131
6132 Components::Configurator_ptr
6133 Components::Configurator::_narrow( CORBA::AbstractBase_ptr _obj )
6134 {
6135 return _narrow (_obj->_to_object());
6136 }
6137
6138 class _Marshaller_Components_Configurator : public ::CORBA::StaticTypeInfo {
6139 typedef Components::Configurator_ptr _MICO_T;
6140 public:
6141 StaticValueType create () const;
6142 void assign (StaticValueType dst, const StaticValueType src) const;
6143 void free (StaticValueType) const;
6144 void release (StaticValueType) const;
6145 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
6146 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
6147 };
6148
6149
6150 ::CORBA::StaticValueType _Marshaller_Components_Configurator::create() const
6151 {
6152 return (StaticValueType) new _MICO_T( 0 );
6153 }
6154
6155 void _Marshaller_Components_Configurator::assign( StaticValueType d, const StaticValueType s ) const
6156 {
6157 *(_MICO_T*) d = ::Components::Configurator::_duplicate( *(_MICO_T*) s );
6158 }
6159
6160 void _Marshaller_Components_Configurator::free( StaticValueType v ) const
6161 {
6162 ::CORBA::release( *(_MICO_T *) v );
6163 delete (_MICO_T*) v;
6164 }
6165
6166 void _Marshaller_Components_Configurator::release( StaticValueType v ) const
6167 {
6168 ::CORBA::release( *(_MICO_T *) v );
6169 }
6170
6171 ::CORBA::Boolean _Marshaller_Components_Configurator::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
6172 {
6173 ::CORBA::Object_ptr obj;
6174 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
6175 return FALSE;
6176 *(_MICO_T *) v = ::Components::Configurator::_narrow( obj );
6177 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
6178 ::CORBA::release (obj);
6179 return ret;
6180 }
6181
6182 void _Marshaller_Components_Configurator::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
6183 {
6184 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
6185 ::CORBA::_stc_Object->marshal( ec, &obj );
6186 }
6187
6188 ::CORBA::StaticTypeInfo *_marshaller_Components_Configurator;
6189
6190
6191
6192
6193 Components::Configurator_stub::~Configurator_stub()
6194 {
6195 }
6196
6197 #ifndef MICO_CONF_NO_POA
6198
6199 void *
6200 POA_Components::Configurator::_narrow_helper (const char * repoid)
6201 {
6202 if (strcmp (repoid, "IDL:omg.org/Components/Configurator:1.0") == 0) {
6203 return (void *) this;
6204 }
6205 return NULL;
6206 }
6207
6208 POA_Components::Configurator *
6209 POA_Components::Configurator::_narrow (PortableServer::Servant serv)
6210 {
6211 void * p;
6212 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/Configurator:1.0")) != NULL) {
6213 serv->_add_ref ();
6214 return (POA_Components::Configurator *) p;
6215 }
6216 return NULL;
6217 }
6218
6219 Components::Configurator_stub_clp::Configurator_stub_clp ()
6220 {
6221 }
6222
6223 Components::Configurator_stub_clp::Configurator_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
6224 : CORBA::Object(*obj), PortableServer::StubBase(poa)
6225 {
6226 }
6227
6228 Components::Configurator_stub_clp::~Configurator_stub_clp ()
6229 {
6230 }
6231
6232 #endif // MICO_CONF_NO_POA
6233
6234 void Components::Configurator_stub::configure( Components::CCMObject_ptr _par_comp )
6235 {
6236 CORBA::StaticAny _sa_comp( _marshaller_Components_CCMObject, &_par_comp );
6237 CORBA::StaticRequest __req( this, "configure" );
6238 __req.add_in_arg( &_sa_comp );
6239
6240 __req.invoke();
6241
6242 mico_sii_throw( &__req,
6243 _marshaller_Components_WrongComponentType, "IDL:omg.org/Components/WrongComponentType:1.0",
6244 0);
6245 }
6246
6247
6248 #ifndef MICO_CONF_NO_POA
6249
6250 void
6251 Components::Configurator_stub_clp::configure( Components::CCMObject_ptr _par_comp )
6252 {
6253 PortableServer::Servant _serv = _preinvoke ();
6254 if (_serv) {
6255 POA_Components::Configurator * _myserv = POA_Components::Configurator::_narrow (_serv);
6256 if (_myserv) {
6257 #ifdef HAVE_EXCEPTIONS
6258 try {
6259 #endif
6260 _myserv->configure(_par_comp);
6261 #ifdef HAVE_EXCEPTIONS
6262 }
6263 catch (...) {
6264 _myserv->_remove_ref();
6265 _postinvoke();
6266 throw;
6267 }
6268 #endif
6269
6270 _myserv->_remove_ref();
6271 _postinvoke ();
6272 return;
6273 }
6274 _postinvoke ();
6275 }
6276
6277 Components::Configurator_stub::configure(_par_comp);
6278 }
6279
6280 #endif // MICO_CONF_NO_POA
6281
6282
6283
6284 Components::ConfigValue::ConfigValue ()
6285 {
6286 }
6287
6288 Components::ConfigValue::~ConfigValue ()
6289 {
6290 }
6291
6292 void *
6293 Components::ConfigValue::_narrow_helper (const char * repoid)
6294 {
6295 if (strcmp (repoid, "IDL:omg.org/Components/ConfigValue:1.0") == 0) {
6296 return (void *) this;
6297 }
6298 return NULL;
6299 }
6300
6301 Components::ConfigValue *
6302 Components::ConfigValue::_downcast (CORBA::ValueBase * vb)
6303 {
6304 void * p;
6305 if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/Components/ConfigValue:1.0")))) {
6306 return (Components::ConfigValue *) p;
6307 }
6308 return 0;
6309 }
6310
6311 Components::ConfigValue *
6312 Components::ConfigValue::_downcast (CORBA::AbstractBase * vb)
6313 {
6314 return _downcast (vb->_to_value());
6315 }
6316
6317 CORBA::ValueDef_ptr
6318 Components::ConfigValue::get_value_def ()
6319 {
6320 CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
6321 CORBA::Object_var irobj =
6322 orb->resolve_initial_references ("InterfaceRepository");
6323 CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
6324 if (CORBA::is_nil (ifr)) {
6325 return CORBA::ValueDef::_nil ();
6326 }
6327
6328 CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/Components/ConfigValue:1.0");
6329 return CORBA::ValueDef::_narrow (cv);
6330 }
6331
6332 void
6333 Components::ConfigValue::_copy_members (const ConfigValue& other)
6334 {
6335 name (other.name());
6336 value (other.value());
6337 }
6338
6339 CORBA::ValueBase *
6340 Components::ConfigValue::_copy_value ()
6341 {
6342 vector<string> _dummy;
6343 string _repo_id = "IDL:omg.org/Components/ConfigValue:1.0";
6344 ConfigValue * _res = _downcast (_create (_dummy, _repo_id));
6345 assert (_res != 0);
6346 _res->_copy_members (*this);
6347 return _res;
6348 }
6349
6350 void
6351 Components::ConfigValue::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
6352 {
6353 repoids.push_back ("IDL:omg.org/Components/ConfigValue:1.0");
6354 chunked = FALSE;
6355 }
6356
6357 void
6358 Components::ConfigValue::_marshal_members (CORBA::DataEncoder &ec)
6359 {
6360 const char * _name = name ();
6361 CORBA::_stc_string->marshal (ec, &_name);
6362 CORBA::Any& _value = value ();
6363 CORBA::_stc_any->marshal (ec, &_value);
6364 }
6365
6366 CORBA::Boolean
6367 Components::ConfigValue::_demarshal_members (CORBA::DataDecoder &dc)
6368 {
6369 Components::FeatureName_var _name;
6370 if (!CORBA::_stc_string->demarshal (dc, &_name._for_demarshal())) {
6371 return FALSE;
6372 }
6373 name (_name);
6374 CORBA::Any _value;
6375 if (!CORBA::_stc_any->demarshal (dc, &_value)) {
6376 return FALSE;
6377 }
6378 value (_value);
6379 return TRUE;
6380 }
6381
6382
6383 class _Marshaller_Components_ConfigValue : public ::CORBA::StaticTypeInfo {
6384 typedef Components::ConfigValue* _MICO_T;
6385 public:
6386 StaticValueType create () const;
6387 void assign (StaticValueType dst, const StaticValueType src) const;
6388 void free (StaticValueType) const;
6389 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
6390 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
6391 };
6392
6393
6394 ::CORBA::StaticValueType _Marshaller_Components_ConfigValue::create() const
6395 {
6396 return (StaticValueType) new _MICO_T( 0 );
6397 }
6398
6399 void _Marshaller_Components_ConfigValue::assign( StaticValueType d, const StaticValueType s ) const
6400 {
6401 ::CORBA::remove_ref (*(_MICO_T*)d);
6402 ::CORBA::add_ref (*(_MICO_T*)s);
6403 *(_MICO_T*) d = *(_MICO_T*) s;
6404 }
6405
6406 void _Marshaller_Components_ConfigValue::free( StaticValueType v ) const
6407 {
6408 ::CORBA::remove_ref (*(_MICO_T*)v);
6409 delete (_MICO_T*) v;
6410 }
6411
6412 ::CORBA::Boolean _Marshaller_Components_ConfigValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
6413 {
6414 ::CORBA::ValueBase* vb = NULL;
6415 if (!::CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/Components/ConfigValue:1.0")) {
6416 return FALSE;
6417 }
6418 *(_MICO_T *)v = ::Components::ConfigValue::_downcast (vb);
6419 if (vb && !*(_MICO_T *)v) {
6420 ::CORBA::remove_ref (vb);
6421 return FALSE;
6422 }
6423 return TRUE;
6424 }
6425
6426 void _Marshaller_Components_ConfigValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
6427 {
6428 ::CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
6429 }
6430
6431 ::CORBA::StaticTypeInfo *_marshaller_Components_ConfigValue;
6432
6433
6434
6435 OBV_Components::ConfigValue::ConfigValue ()
6436 {
6437 }
6438
6439 OBV_Components::ConfigValue::ConfigValue (const char* _name, const CORBA::Any& _value)
6440 {
6441 _m.name = _name;
6442 _m.value = _value;
6443 }
6444
6445 OBV_Components::ConfigValue::~ConfigValue ()
6446 {
6447 }
6448
6449 void OBV_Components::ConfigValue::name( char *_p )
6450 {
6451 _m.name = _p;
6452 }
6453
6454 void OBV_Components::ConfigValue::name( const char *_p )
6455 {
6456 _m.name = _p;
6457 }
6458
6459 void OBV_Components::ConfigValue::name( const CORBA::String_var &_p )
6460 {
6461 _m.name = _p;
6462 }
6463
6464 const char *OBV_Components::ConfigValue::name() const
6465 {
6466 return _m.name;
6467 }
6468
6469 void OBV_Components::ConfigValue::value( const CORBA::Any& _p )
6470 {
6471 _m.value = _p;
6472 }
6473
6474 const CORBA::Any& OBV_Components::ConfigValue::value() const
6475 {
6476 return (CORBA::Any&) _m.value;
6477 }
6478
6479 CORBA::Any& OBV_Components::ConfigValue::value()
6480 {
6481 return _m.value;
6482 }
6483
6484
6485
6486
6487
6488 Components::StandardConfigurator::~StandardConfigurator()
6489 {
6490 }
6491
6492 void *
6493 Components::StandardConfigurator::_narrow_helper( const char *_repoid )
6494 {
6495 if( strcmp( _repoid, "IDL:omg.org/Components/StandardConfigurator:1.0" ) == 0 )
6496 return (void *)this;
6497 {
6498 void *_p;
6499 if ((_p = Components::Configurator::_narrow_helper( _repoid )))
6500 return _p;
6501 }
6502 return NULL;
6503 }
6504
6505 Components::StandardConfigurator_ptr
6506 Components::StandardConfigurator::_narrow( CORBA::Object_ptr _obj )
6507 {
6508 Components::StandardConfigurator_ptr _o;
6509 if( !CORBA::is_nil( _obj ) ) {
6510 void *_p;
6511 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/StandardConfigurator:1.0" )))
6512 return _duplicate( (Components::StandardConfigurator_ptr) _p );
6513 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/StandardConfigurator:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/StandardConfigurator:1.0")) {
6514 _o = new Components::StandardConfigurator_stub;
6515 _o->CORBA::Object::operator=( *_obj );
6516 return _o;
6517 }
6518 }
6519 return _nil();
6520 }
6521
6522 Components::StandardConfigurator_ptr
6523 Components::StandardConfigurator::_narrow( CORBA::AbstractBase_ptr _obj )
6524 {
6525 return _narrow (_obj->_to_object());
6526 }
6527
6528 class _Marshaller_Components_StandardConfigurator : public ::CORBA::StaticTypeInfo {
6529 typedef Components::StandardConfigurator_ptr _MICO_T;
6530 public:
6531 StaticValueType create () const;
6532 void assign (StaticValueType dst, const StaticValueType src) const;
6533 void free (StaticValueType) const;
6534 void release (StaticValueType) const;
6535 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
6536 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
6537 };
6538
6539
6540 ::CORBA::StaticValueType _Marshaller_Components_StandardConfigurator::create() const
6541 {
6542 return (StaticValueType) new _MICO_T( 0 );
6543 }
6544
6545 void _Marshaller_Components_StandardConfigurator::assign( StaticValueType d, const StaticValueType s ) const
6546 {
6547 *(_MICO_T*) d = ::Components::StandardConfigurator::_duplicate( *(_MICO_T*) s );
6548 }
6549
6550 void _Marshaller_Components_StandardConfigurator::free( StaticValueType v ) const
6551 {
6552 ::CORBA::release( *(_MICO_T *) v );
6553 delete (_MICO_T*) v;
6554 }
6555
6556 void _Marshaller_Components_StandardConfigurator::release( StaticValueType v ) const
6557 {
6558 ::CORBA::release( *(_MICO_T *) v );
6559 }
6560
6561 ::CORBA::Boolean _Marshaller_Components_StandardConfigurator::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
6562 {
6563 ::CORBA::Object_ptr obj;
6564 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
6565 return FALSE;
6566 *(_MICO_T *) v = ::Components::StandardConfigurator::_narrow( obj );
6567 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
6568 ::CORBA::release (obj);
6569 return ret;
6570 }
6571
6572 void _Marshaller_Components_StandardConfigurator::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
6573 {
6574 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
6575 ::CORBA::_stc_Object->marshal( ec, &obj );
6576 }
6577
6578 ::CORBA::StaticTypeInfo *_marshaller_Components_StandardConfigurator;
6579
6580
6581
6582
6583 Components::StandardConfigurator_stub::~StandardConfigurator_stub()
6584 {
6585 }
6586
6587 #ifndef MICO_CONF_NO_POA
6588
6589 void *
6590 POA_Components::StandardConfigurator::_narrow_helper (const char * repoid)
6591 {
6592 void * p;
6593 if (strcmp (repoid, "IDL:omg.org/Components/StandardConfigurator:1.0") == 0) {
6594 return (void *) this;
6595 }
6596 if ((p = POA_Components::Configurator::_narrow_helper (repoid)) != NULL)
6597 {
6598 return p;
6599 }
6600 return NULL;
6601 }
6602
6603 POA_Components::StandardConfigurator *
6604 POA_Components::StandardConfigurator::_narrow (PortableServer::Servant serv)
6605 {
6606 void * p;
6607 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/StandardConfigurator:1.0")) != NULL) {
6608 serv->_add_ref ();
6609 return (POA_Components::StandardConfigurator *) p;
6610 }
6611 return NULL;
6612 }
6613
6614 Components::StandardConfigurator_stub_clp::StandardConfigurator_stub_clp ()
6615 {
6616 }
6617
6618 Components::StandardConfigurator_stub_clp::StandardConfigurator_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
6619 : CORBA::Object(*obj), PortableServer::StubBase(poa)
6620 {
6621 }
6622
6623 Components::StandardConfigurator_stub_clp::~StandardConfigurator_stub_clp ()
6624 {
6625 }
6626
6627 #endif // MICO_CONF_NO_POA
6628
6629 void Components::StandardConfigurator_stub::set_configuration( const Components::ConfigValues& _par_descr )
6630 {
6631 CORBA::StaticAny _sa_descr( _marshaller__seq_Components_ConfigValue, &_par_descr );
6632 CORBA::StaticRequest __req( this, "set_configuration" );
6633 __req.add_in_arg( &_sa_descr );
6634
6635 __req.invoke();
6636
6637 mico_sii_throw( &__req,
6638 0);
6639 }
6640
6641
6642 #ifndef MICO_CONF_NO_POA
6643
6644 void
6645 Components::StandardConfigurator_stub_clp::set_configuration( const Components::ConfigValues& _par_descr )
6646 {
6647 Components::StandardConfigurator_stub::set_configuration(_par_descr);
6648 }
6649
6650 #endif // MICO_CONF_NO_POA
6651
6652
6653 #ifdef HAVE_EXPLICIT_STRUCT_OPS
6654 Components::IllegalState::IllegalState()
6655 {
6656 }
6657
6658 Components::IllegalState::IllegalState( const IllegalState& _s )
6659 {
6660 }
6661
6662 Components::IllegalState::~IllegalState()
6663 {
6664 }
6665
6666 Components::IllegalState&
6667 Components::IllegalState::operator=( const IllegalState& _s )
6668 {
6669 return *this;
6670 }
6671 #endif
6672
6673 class _Marshaller_Components_IllegalState : public ::CORBA::StaticTypeInfo {
6674 typedef ::Components::IllegalState _MICO_T;
6675 public:
6676 StaticValueType create () const;
6677 void assign (StaticValueType dst, const StaticValueType src) const;
6678 void free (StaticValueType) const;
6679 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
6680 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
6681 };
6682
6683
6684 ::CORBA::StaticValueType _Marshaller_Components_IllegalState::create() const
6685 {
6686 return (StaticValueType) new _MICO_T;
6687 }
6688
6689 void _Marshaller_Components_IllegalState::assign( StaticValueType d, const StaticValueType s ) const
6690 {
6691 *(_MICO_T*) d = *(_MICO_T*) s;
6692 }
6693
6694 void _Marshaller_Components_IllegalState::free( StaticValueType v ) const
6695 {
6696 delete (_MICO_T*) v;
6697 }
6698
6699 ::CORBA::Boolean _Marshaller_Components_IllegalState::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
6700 {
6701 string repoid;
6702 return
6703 dc.except_begin( repoid ) &&
6704 dc.except_end();
6705 }
6706
6707 void _Marshaller_Components_IllegalState::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
6708 {
6709 ec.except_begin( "IDL:omg.org/Components/IllegalState:1.0" );
6710 ec.except_end();
6711 }
6712
6713 ::CORBA::StaticTypeInfo *_marshaller_Components_IllegalState;
6714
6715 void Components::IllegalState::_throwit() const
6716 {
6717 #ifdef HAVE_EXCEPTIONS
6718 #ifdef HAVE_STD_EH
6719 throw *this;
6720 #else
6721 throw IllegalState_var( (Components::IllegalState*)_clone() );
6722 #endif
6723 #else
6724 CORBA::Exception::_throw_failed( _clone() );
6725 #endif
6726 }
6727
6728 const char *Components::IllegalState::_repoid() const
6729 {
6730 return "IDL:omg.org/Components/IllegalState:1.0";
6731 }
6732
6733 void Components::IllegalState::_encode( CORBA::DataEncoder &_en ) const
6734 {
6735 _marshaller_Components_IllegalState->marshal( _en, (void*) this );
6736 }
6737
6738 void Components::IllegalState::_encode_any( CORBA::Any & ) const
6739 {
6740
6741 assert(0);
6742 }
6743
6744 CORBA::Exception *Components::IllegalState::_clone() const
6745 {
6746 return new IllegalState( *this );
6747 }
6748
6749 Components::IllegalState *Components::IllegalState::_downcast( CORBA::Exception *_ex )
6750 {
6751 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/IllegalState:1.0" ) )
6752 return (IllegalState *) _ex;
6753 return NULL;
6754 }
6755
6756 const Components::IllegalState *Components::IllegalState::_downcast( const CORBA::Exception *_ex )
6757 {
6758 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/IllegalState:1.0" ) )
6759 return (IllegalState *) _ex;
6760 return NULL;
6761 }
6762
6763
6764
6765
6766 Components::CCMContext::~CCMContext()
6767 {
6768 }
6769
6770 void *
6771 Components::CCMContext::_narrow_helper( const char *_repoid )
6772 {
6773 if( strcmp( _repoid, "IDL:omg.org/Components/CCMContext:1.0" ) == 0 )
6774 return (void *)this;
6775 {
6776 void *_p;
6777 if ((_p = ::CORBA::LocalObject::_narrow_helper (_repoid)))
6778 return _p;
6779 }
6780 return NULL;
6781 }
6782
6783 Components::CCMContext_ptr
6784 Components::CCMContext::_narrow( CORBA::Object_ptr _obj )
6785 {
6786 if( !CORBA::is_nil( _obj ) ) {
6787 void *_p;
6788 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/CCMContext:1.0" )))
6789 return _duplicate( (Components::CCMContext_ptr) _p );
6790 }
6791 return _nil();
6792 }
6793
6794 Components::CCMContext_ptr
6795 Components::CCMContext::_narrow( CORBA::AbstractBase_ptr _obj )
6796 {
6797 return _narrow (_obj->_to_object());
6798 }
6799
6800
6801
6802
6803
6804 Components::SessionContext::~SessionContext()
6805 {
6806 }
6807
6808 void *
6809 Components::SessionContext::_narrow_helper( const char *_repoid )
6810 {
6811 if( strcmp( _repoid, "IDL:omg.org/Components/SessionContext:1.0" ) == 0 )
6812 return (void *)this;
6813 {
6814 void *_p;
6815 if ((_p = Components::CCMContext::_narrow_helper( _repoid )))
6816 return _p;
6817 }
6818 return NULL;
6819 }
6820
6821 Components::SessionContext_ptr
6822 Components::SessionContext::_narrow( CORBA::Object_ptr _obj )
6823 {
6824 if( !CORBA::is_nil( _obj ) ) {
6825 void *_p;
6826 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/SessionContext:1.0" )))
6827 return _duplicate( (Components::SessionContext_ptr) _p );
6828 }
6829 return _nil();
6830 }
6831
6832 Components::SessionContext_ptr
6833 Components::SessionContext::_narrow( CORBA::AbstractBase_ptr _obj )
6834 {
6835 return _narrow (_obj->_to_object());
6836 }
6837
6838
6839
6840 class _Marshaller_Components_CCMExceptionReason : public ::CORBA::StaticTypeInfo {
6841 typedef Components::CCMExceptionReason _MICO_T;
6842 public:
6843 StaticValueType create () const;
6844 void assign (StaticValueType dst, const StaticValueType src) const;
6845 void free (StaticValueType) const;
6846 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
6847 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
6848 };
6849
6850
6851 ::CORBA::StaticValueType _Marshaller_Components_CCMExceptionReason::create() const
6852 {
6853 return (StaticValueType) new _MICO_T;
6854 }
6855
6856 void _Marshaller_Components_CCMExceptionReason::assign( StaticValueType d, const StaticValueType s ) const
6857 {
6858 *(_MICO_T*) d = *(_MICO_T*) s;
6859 }
6860
6861 void _Marshaller_Components_CCMExceptionReason::free( StaticValueType v ) const
6862 {
6863 delete (_MICO_T*) v;
6864 }
6865
6866 ::CORBA::Boolean _Marshaller_Components_CCMExceptionReason::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
6867 {
6868 ::CORBA::ULong ul;
6869 if( !dc.enumeration( ul ) )
6870 return FALSE;
6871 *(_MICO_T*) v = (_MICO_T) ul;
6872 return TRUE;
6873 }
6874
6875 void _Marshaller_Components_CCMExceptionReason::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
6876 {
6877 ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v );
6878 }
6879
6880 ::CORBA::StaticTypeInfo *_marshaller_Components_CCMExceptionReason;
6881
6882
6883 #ifdef HAVE_EXPLICIT_STRUCT_OPS
6884 Components::CCMException::CCMException()
6885 {
6886 }
6887
6888 Components::CCMException::CCMException( const CCMException& _s )
6889 {
6890 reason = ((CCMException&)_s).reason;
6891 }
6892
6893 Components::CCMException::~CCMException()
6894 {
6895 }
6896
6897 Components::CCMException&
6898 Components::CCMException::operator=( const CCMException& _s )
6899 {
6900 reason = ((CCMException&)_s).reason;
6901 return *this;
6902 }
6903 #endif
6904
6905 #ifndef HAVE_EXPLICIT_STRUCT_OPS
6906 Components::CCMException::CCMException()
6907 {
6908 }
6909
6910 #endif
6911
6912 Components::CCMException::CCMException( Components::CCMExceptionReason _m0 )
6913 {
6914 reason = _m0;
6915 }
6916
6917 class _Marshaller_Components_CCMException : public ::CORBA::StaticTypeInfo {
6918 typedef ::Components::CCMException _MICO_T;
6919 public:
6920 StaticValueType create () const;
6921 void assign (StaticValueType dst, const StaticValueType src) const;
6922 void free (StaticValueType) const;
6923 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
6924 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
6925 };
6926
6927
6928 ::CORBA::StaticValueType _Marshaller_Components_CCMException::create() const
6929 {
6930 return (StaticValueType) new _MICO_T;
6931 }
6932
6933 void _Marshaller_Components_CCMException::assign( StaticValueType d, const StaticValueType s ) const
6934 {
6935 *(_MICO_T*) d = *(_MICO_T*) s;
6936 }
6937
6938 void _Marshaller_Components_CCMException::free( StaticValueType v ) const
6939 {
6940 delete (_MICO_T*) v;
6941 }
6942
6943 ::CORBA::Boolean _Marshaller_Components_CCMException::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
6944 {
6945 string repoid;
6946 return
6947 dc.except_begin( repoid ) &&
6948 _marshaller_Components_CCMExceptionReason->demarshal( dc, &((_MICO_T*)v)->reason ) &&
6949 dc.except_end();
6950 }
6951
6952 void _Marshaller_Components_CCMException::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
6953 {
6954 ec.except_begin( "IDL:omg.org/Components/CCMException:1.0" );
6955 _marshaller_Components_CCMExceptionReason->marshal( ec, &((_MICO_T*)v)->reason );
6956 ec.except_end();
6957 }
6958
6959 ::CORBA::StaticTypeInfo *_marshaller_Components_CCMException;
6960
6961 void Components::CCMException::_throwit() const
6962 {
6963 #ifdef HAVE_EXCEPTIONS
6964 #ifdef HAVE_STD_EH
6965 throw *this;
6966 #else
6967 throw CCMException_var( (Components::CCMException*)_clone() );
6968 #endif
6969 #else
6970 CORBA::Exception::_throw_failed( _clone() );
6971 #endif
6972 }
6973
6974 const char *Components::CCMException::_repoid() const
6975 {
6976 return "IDL:omg.org/Components/CCMException:1.0";
6977 }
6978
6979 void Components::CCMException::_encode( CORBA::DataEncoder &_en ) const
6980 {
6981 _marshaller_Components_CCMException->marshal( _en, (void*) this );
6982 }
6983
6984 void Components::CCMException::_encode_any( CORBA::Any & ) const
6985 {
6986
6987 assert(0);
6988 }
6989
6990 CORBA::Exception *Components::CCMException::_clone() const
6991 {
6992 return new CCMException( *this );
6993 }
6994
6995 Components::CCMException *Components::CCMException::_downcast( CORBA::Exception *_ex )
6996 {
6997 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/CCMException:1.0" ) )
6998 return (CCMException *) _ex;
6999 return NULL;
7000 }
7001
7002 const Components::CCMException *Components::CCMException::_downcast( const CORBA::Exception *_ex )
7003 {
7004 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/CCMException:1.0" ) )
7005 return (CCMException *) _ex;
7006 return NULL;
7007 }
7008
7009
7010
7011
7012 Components::EnterpriseComponent::~EnterpriseComponent()
7013 {
7014 }
7015
7016 void *
7017 Components::EnterpriseComponent::_narrow_helper( const char *_repoid )
7018 {
7019 if( strcmp( _repoid, "IDL:omg.org/Components/EnterpriseComponent:1.0" ) == 0 )
7020 return (void *)this;
7021 {
7022 void *_p;
7023 if ((_p = ::CORBA::LocalObject::_narrow_helper (_repoid)))
7024 return _p;
7025 }
7026 return NULL;
7027 }
7028
7029 Components::EnterpriseComponent_ptr
7030 Components::EnterpriseComponent::_narrow( CORBA::Object_ptr _obj )
7031 {
7032 if( !CORBA::is_nil( _obj ) ) {
7033 void *_p;
7034 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/EnterpriseComponent:1.0" )))
7035 return _duplicate( (Components::EnterpriseComponent_ptr) _p );
7036 }
7037 return _nil();
7038 }
7039
7040 Components::EnterpriseComponent_ptr
7041 Components::EnterpriseComponent::_narrow( CORBA::AbstractBase_ptr _obj )
7042 {
7043 return _narrow (_obj->_to_object());
7044 }
7045
7046
7047
7048
7049
7050 Components::SessionComponent::~SessionComponent()
7051 {
7052 }
7053
7054 void *
7055 Components::SessionComponent::_narrow_helper( const char *_repoid )
7056 {
7057 if( strcmp( _repoid, "IDL:omg.org/Components/SessionComponent:1.0" ) == 0 )
7058 return (void *)this;
7059 {
7060 void *_p;
7061 if ((_p = Components::EnterpriseComponent::_narrow_helper( _repoid )))
7062 return _p;
7063 }
7064 return NULL;
7065 }
7066
7067 Components::SessionComponent_ptr
7068 Components::SessionComponent::_narrow( CORBA::Object_ptr _obj )
7069 {
7070 if( !CORBA::is_nil( _obj ) ) {
7071 void *_p;
7072 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/SessionComponent:1.0" )))
7073 return _duplicate( (Components::SessionComponent_ptr) _p );
7074 }
7075 return _nil();
7076 }
7077
7078 Components::SessionComponent_ptr
7079 Components::SessionComponent::_narrow( CORBA::AbstractBase_ptr _obj )
7080 {
7081 return _narrow (_obj->_to_object());
7082 }
7083
7084
7085
7086
7087
7088 Components::HomeExecutorBase::~HomeExecutorBase()
7089 {
7090 }
7091
7092 void *
7093 Components::HomeExecutorBase::_narrow_helper( const char *_repoid )
7094 {
7095 if( strcmp( _repoid, "IDL:omg.org/Components/HomeExecutorBase:1.0" ) == 0 )
7096 return (void *)this;
7097 {
7098 void *_p;
7099 if ((_p = ::CORBA::LocalObject::_narrow_helper (_repoid)))
7100 return _p;
7101 }
7102 return NULL;
7103 }
7104
7105 Components::HomeExecutorBase_ptr
7106 Components::HomeExecutorBase::_narrow( CORBA::Object_ptr _obj )
7107 {
7108 if( !CORBA::is_nil( _obj ) ) {
7109 void *_p;
7110 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/HomeExecutorBase:1.0" )))
7111 return _duplicate( (Components::HomeExecutorBase_ptr) _p );
7112 }
7113 return _nil();
7114 }
7115
7116 Components::HomeExecutorBase_ptr
7117 Components::HomeExecutorBase::_narrow( CORBA::AbstractBase_ptr _obj )
7118 {
7119 return _narrow (_obj->_to_object());
7120 }
7121
7122
7123
7124
7125
7126 Components::ExecutorLocator::~ExecutorLocator()
7127 {
7128 }
7129
7130 void *
7131 Components::ExecutorLocator::_narrow_helper( const char *_repoid )
7132 {
7133 if( strcmp( _repoid, "IDL:omg.org/Components/ExecutorLocator:1.0" ) == 0 )
7134 return (void *)this;
7135 {
7136 void *_p;
7137 if ((_p = Components::EnterpriseComponent::_narrow_helper( _repoid )))
7138 return _p;
7139 }
7140 return NULL;
7141 }
7142
7143 Components::ExecutorLocator_ptr
7144 Components::ExecutorLocator::_narrow( CORBA::Object_ptr _obj )
7145 {
7146 if( !CORBA::is_nil( _obj ) ) {
7147 void *_p;
7148 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/ExecutorLocator:1.0" )))
7149 return _duplicate( (Components::ExecutorLocator_ptr) _p );
7150 }
7151 return _nil();
7152 }
7153
7154 Components::ExecutorLocator_ptr
7155 Components::ExecutorLocator::_narrow( CORBA::AbstractBase_ptr _obj )
7156 {
7157 return _narrow (_obj->_to_object());
7158 }
7159
7160
7161
7162 #ifdef HAVE_EXPLICIT_STRUCT_OPS
7163 Components::UnknownImplId::UnknownImplId()
7164 {
7165 }
7166
7167 Components::UnknownImplId::UnknownImplId( const UnknownImplId& _s )
7168 {
7169 }
7170
7171 Components::UnknownImplId::~UnknownImplId()
7172 {
7173 }
7174
7175 Components::UnknownImplId&
7176 Components::UnknownImplId::operator=( const UnknownImplId& _s )
7177 {
7178 return *this;
7179 }
7180 #endif
7181
7182 class _Marshaller_Components_UnknownImplId : public ::CORBA::StaticTypeInfo {
7183 typedef ::Components::UnknownImplId _MICO_T;
7184 public:
7185 StaticValueType create () const;
7186 void assign (StaticValueType dst, const StaticValueType src) const;
7187 void free (StaticValueType) const;
7188 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
7189 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
7190 };
7191
7192
7193 ::CORBA::StaticValueType _Marshaller_Components_UnknownImplId::create() const
7194 {
7195 return (StaticValueType) new _MICO_T;
7196 }
7197
7198 void _Marshaller_Components_UnknownImplId::assign( StaticValueType d, const StaticValueType s ) const
7199 {
7200 *(_MICO_T*) d = *(_MICO_T*) s;
7201 }
7202
7203 void _Marshaller_Components_UnknownImplId::free( StaticValueType v ) const
7204 {
7205 delete (_MICO_T*) v;
7206 }
7207
7208 ::CORBA::Boolean _Marshaller_Components_UnknownImplId::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
7209 {
7210 string repoid;
7211 return
7212 dc.except_begin( repoid ) &&
7213 dc.except_end();
7214 }
7215
7216 void _Marshaller_Components_UnknownImplId::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
7217 {
7218 ec.except_begin( "IDL:omg.org/Components/UnknownImplId:1.0" );
7219 ec.except_end();
7220 }
7221
7222 ::CORBA::StaticTypeInfo *_marshaller_Components_UnknownImplId;
7223
7224 void Components::UnknownImplId::_throwit() const
7225 {
7226 #ifdef HAVE_EXCEPTIONS
7227 #ifdef HAVE_STD_EH
7228 throw *this;
7229 #else
7230 throw UnknownImplId_var( (Components::UnknownImplId*)_clone() );
7231 #endif
7232 #else
7233 CORBA::Exception::_throw_failed( _clone() );
7234 #endif
7235 }
7236
7237 const char *Components::UnknownImplId::_repoid() const
7238 {
7239 return "IDL:omg.org/Components/UnknownImplId:1.0";
7240 }
7241
7242 void Components::UnknownImplId::_encode( CORBA::DataEncoder &_en ) const
7243 {
7244 _marshaller_Components_UnknownImplId->marshal( _en, (void*) this );
7245 }
7246
7247 void Components::UnknownImplId::_encode_any( CORBA::Any & ) const
7248 {
7249
7250 assert(0);
7251 }
7252
7253 CORBA::Exception *Components::UnknownImplId::_clone() const
7254 {
7255 return new UnknownImplId( *this );
7256 }
7257
7258 Components::UnknownImplId *Components::UnknownImplId::_downcast( CORBA::Exception *_ex )
7259 {
7260 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/UnknownImplId:1.0" ) )
7261 return (UnknownImplId *) _ex;
7262 return NULL;
7263 }
7264
7265 const Components::UnknownImplId *Components::UnknownImplId::_downcast( const CORBA::Exception *_ex )
7266 {
7267 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/UnknownImplId:1.0" ) )
7268 return (UnknownImplId *) _ex;
7269 return NULL;
7270 }
7271
7272
7273 #ifdef HAVE_EXPLICIT_STRUCT_OPS
7274 Components::InvalidLocation::InvalidLocation()
7275 {
7276 }
7277
7278 Components::InvalidLocation::InvalidLocation( const InvalidLocation& _s )
7279 {
7280 }
7281
7282 Components::InvalidLocation::~InvalidLocation()
7283 {
7284 }
7285
7286 Components::InvalidLocation&
7287 Components::InvalidLocation::operator=( const InvalidLocation& _s )
7288 {
7289 return *this;
7290 }
7291 #endif
7292
7293 class _Marshaller_Components_InvalidLocation : public ::CORBA::StaticTypeInfo {
7294 typedef ::Components::InvalidLocation _MICO_T;
7295 public:
7296 StaticValueType create () const;
7297 void assign (StaticValueType dst, const StaticValueType src) const;
7298 void free (StaticValueType) const;
7299 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
7300 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
7301 };
7302
7303
7304 ::CORBA::StaticValueType _Marshaller_Components_InvalidLocation::create() const
7305 {
7306 return (StaticValueType) new _MICO_T;
7307 }
7308
7309 void _Marshaller_Components_InvalidLocation::assign( StaticValueType d, const StaticValueType s ) const
7310 {
7311 *(_MICO_T*) d = *(_MICO_T*) s;
7312 }
7313
7314 void _Marshaller_Components_InvalidLocation::free( StaticValueType v ) const
7315 {
7316 delete (_MICO_T*) v;
7317 }
7318
7319 ::CORBA::Boolean _Marshaller_Components_InvalidLocation::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
7320 {
7321 string repoid;
7322 return
7323 dc.except_begin( repoid ) &&
7324 dc.except_end();
7325 }
7326
7327 void _Marshaller_Components_InvalidLocation::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
7328 {
7329 ec.except_begin( "IDL:omg.org/Components/InvalidLocation:1.0" );
7330 ec.except_end();
7331 }
7332
7333 ::CORBA::StaticTypeInfo *_marshaller_Components_InvalidLocation;
7334
7335 void Components::InvalidLocation::_throwit() const
7336 {
7337 #ifdef HAVE_EXCEPTIONS
7338 #ifdef HAVE_STD_EH
7339 throw *this;
7340 #else
7341 throw InvalidLocation_var( (Components::InvalidLocation*)_clone() );
7342 #endif
7343 #else
7344 CORBA::Exception::_throw_failed( _clone() );
7345 #endif
7346 }
7347
7348 const char *Components::InvalidLocation::_repoid() const
7349 {
7350 return "IDL:omg.org/Components/InvalidLocation:1.0";
7351 }
7352
7353 void Components::InvalidLocation::_encode( CORBA::DataEncoder &_en ) const
7354 {
7355 _marshaller_Components_InvalidLocation->marshal( _en, (void*) this );
7356 }
7357
7358 void Components::InvalidLocation::_encode_any( CORBA::Any & ) const
7359 {
7360
7361 assert(0);
7362 }
7363
7364 CORBA::Exception *Components::InvalidLocation::_clone() const
7365 {
7366 return new InvalidLocation( *this );
7367 }
7368
7369 Components::InvalidLocation *Components::InvalidLocation::_downcast( CORBA::Exception *_ex )
7370 {
7371 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidLocation:1.0" ) )
7372 return (InvalidLocation *) _ex;
7373 return NULL;
7374 }
7375
7376 const Components::InvalidLocation *Components::InvalidLocation::_downcast( const CORBA::Exception *_ex )
7377 {
7378 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidLocation:1.0" ) )
7379 return (InvalidLocation *) _ex;
7380 return NULL;
7381 }
7382
7383
7384 #ifdef HAVE_EXPLICIT_STRUCT_OPS
7385 Components::CreateFailure::CreateFailure()
7386 {
7387 }
7388
7389 Components::CreateFailure::CreateFailure( const CreateFailure& _s )
7390 {
7391 }
7392
7393 Components::CreateFailure::~CreateFailure()
7394 {
7395 }
7396
7397 Components::CreateFailure&
7398 Components::CreateFailure::operator=( const CreateFailure& _s )
7399 {
7400 return *this;
7401 }
7402 #endif
7403
7404 class _Marshaller_Components_CreateFailure : public ::CORBA::StaticTypeInfo {
7405 typedef ::Components::CreateFailure _MICO_T;
7406 public:
7407 StaticValueType create () const;
7408 void assign (StaticValueType dst, const StaticValueType src) const;
7409 void free (StaticValueType) const;
7410 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
7411 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
7412 };
7413
7414
7415 ::CORBA::StaticValueType _Marshaller_Components_CreateFailure::create() const
7416 {
7417 return (StaticValueType) new _MICO_T;
7418 }
7419
7420 void _Marshaller_Components_CreateFailure::assign( StaticValueType d, const StaticValueType s ) const
7421 {
7422 *(_MICO_T*) d = *(_MICO_T*) s;
7423 }
7424
7425 void _Marshaller_Components_CreateFailure::free( StaticValueType v ) const
7426 {
7427 delete (_MICO_T*) v;
7428 }
7429
7430 ::CORBA::Boolean _Marshaller_Components_CreateFailure::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
7431 {
7432 string repoid;
7433 return
7434 dc.except_begin( repoid ) &&
7435 dc.except_end();
7436 }
7437
7438 void _Marshaller_Components_CreateFailure::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
7439 {
7440 ec.except_begin( "IDL:omg.org/Components/CreateFailure:1.0" );
7441 ec.except_end();
7442 }
7443
7444 ::CORBA::StaticTypeInfo *_marshaller_Components_CreateFailure;
7445
7446 void Components::CreateFailure::_throwit() const
7447 {
7448 #ifdef HAVE_EXCEPTIONS
7449 #ifdef HAVE_STD_EH
7450 throw *this;
7451 #else
7452 throw CreateFailure_var( (Components::CreateFailure*)_clone() );
7453 #endif
7454 #else
7455 CORBA::Exception::_throw_failed( _clone() );
7456 #endif
7457 }
7458
7459 const char *Components::CreateFailure::_repoid() const
7460 {
7461 return "IDL:omg.org/Components/CreateFailure:1.0";
7462 }
7463
7464 void Components::CreateFailure::_encode( CORBA::DataEncoder &_en ) const
7465 {
7466 _marshaller_Components_CreateFailure->marshal( _en, (void*) this );
7467 }
7468
7469 void Components::CreateFailure::_encode_any( CORBA::Any & ) const
7470 {
7471
7472 assert(0);
7473 }
7474
7475 CORBA::Exception *Components::CreateFailure::_clone() const
7476 {
7477 return new CreateFailure( *this );
7478 }
7479
7480 Components::CreateFailure *Components::CreateFailure::_downcast( CORBA::Exception *_ex )
7481 {
7482 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/CreateFailure:1.0" ) )
7483 return (CreateFailure *) _ex;
7484 return NULL;
7485 }
7486
7487 const Components::CreateFailure *Components::CreateFailure::_downcast( const CORBA::Exception *_ex )
7488 {
7489 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/CreateFailure:1.0" ) )
7490 return (CreateFailure *) _ex;
7491 return NULL;
7492 }
7493
7494
7495 #ifdef HAVE_EXPLICIT_STRUCT_OPS
7496 Components::RemoveFailure::RemoveFailure()
7497 {
7498 }
7499
7500 Components::RemoveFailure::RemoveFailure( const RemoveFailure& _s )
7501 {
7502 }
7503
7504 Components::RemoveFailure::~RemoveFailure()
7505 {
7506 }
7507
7508 Components::RemoveFailure&
7509 Components::RemoveFailure::operator=( const RemoveFailure& _s )
7510 {
7511 return *this;
7512 }
7513 #endif
7514
7515 class _Marshaller_Components_RemoveFailure : public ::CORBA::StaticTypeInfo {
7516 typedef ::Components::RemoveFailure _MICO_T;
7517 public:
7518 StaticValueType create () const;
7519 void assign (StaticValueType dst, const StaticValueType src) const;
7520 void free (StaticValueType) const;
7521 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
7522 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
7523 };
7524
7525
7526 ::CORBA::StaticValueType _Marshaller_Components_RemoveFailure::create() const
7527 {
7528 return (StaticValueType) new _MICO_T;
7529 }
7530
7531 void _Marshaller_Components_RemoveFailure::assign( StaticValueType d, const StaticValueType s ) const
7532 {
7533 *(_MICO_T*) d = *(_MICO_T*) s;
7534 }
7535
7536 void _Marshaller_Components_RemoveFailure::free( StaticValueType v ) const
7537 {
7538 delete (_MICO_T*) v;
7539 }
7540
7541 ::CORBA::Boolean _Marshaller_Components_RemoveFailure::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
7542 {
7543 string repoid;
7544 return
7545 dc.except_begin( repoid ) &&
7546 dc.except_end();
7547 }
7548
7549 void _Marshaller_Components_RemoveFailure::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
7550 {
7551 ec.except_begin( "IDL:omg.org/Components/RemoveFailure:1.0" );
7552 ec.except_end();
7553 }
7554
7555 ::CORBA::StaticTypeInfo *_marshaller_Components_RemoveFailure;
7556
7557 void Components::RemoveFailure::_throwit() const
7558 {
7559 #ifdef HAVE_EXCEPTIONS
7560 #ifdef HAVE_STD_EH
7561 throw *this;
7562 #else
7563 throw RemoveFailure_var( (Components::RemoveFailure*)_clone() );
7564 #endif
7565 #else
7566 CORBA::Exception::_throw_failed( _clone() );
7567 #endif
7568 }
7569
7570 const char *Components::RemoveFailure::_repoid() const
7571 {
7572 return "IDL:omg.org/Components/RemoveFailure:1.0";
7573 }
7574
7575 void Components::RemoveFailure::_encode( CORBA::DataEncoder &_en ) const
7576 {
7577 _marshaller_Components_RemoveFailure->marshal( _en, (void*) this );
7578 }
7579
7580 void Components::RemoveFailure::_encode_any( CORBA::Any & ) const
7581 {
7582
7583 assert(0);
7584 }
7585
7586 CORBA::Exception *Components::RemoveFailure::_clone() const
7587 {
7588 return new RemoveFailure( *this );
7589 }
7590
7591 Components::RemoveFailure *Components::RemoveFailure::_downcast( CORBA::Exception *_ex )
7592 {
7593 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/RemoveFailure:1.0" ) )
7594 return (RemoveFailure *) _ex;
7595 return NULL;
7596 }
7597
7598 const Components::RemoveFailure *Components::RemoveFailure::_downcast( const CORBA::Exception *_ex )
7599 {
7600 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/RemoveFailure:1.0" ) )
7601 return (RemoveFailure *) _ex;
7602 return NULL;
7603 }
7604
7605
7606 #ifdef HAVE_EXPLICIT_STRUCT_OPS
7607 Components::InstallationFailure::InstallationFailure()
7608 {
7609 }
7610
7611 Components::InstallationFailure::InstallationFailure( const InstallationFailure& _s )
7612 {
7613 }
7614
7615 Components::InstallationFailure::~InstallationFailure()
7616 {
7617 }
7618
7619 Components::InstallationFailure&
7620 Components::InstallationFailure::operator=( const InstallationFailure& _s )
7621 {
7622 return *this;
7623 }
7624 #endif
7625
7626 class _Marshaller_Components_InstallationFailure : public ::CORBA::StaticTypeInfo {
7627 typedef ::Components::InstallationFailure _MICO_T;
7628 public:
7629 StaticValueType create () const;
7630 void assign (StaticValueType dst, const StaticValueType src) const;
7631 void free (StaticValueType) const;
7632 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
7633 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
7634 };
7635
7636
7637 ::CORBA::StaticValueType _Marshaller_Components_InstallationFailure::create() const
7638 {
7639 return (StaticValueType) new _MICO_T;
7640 }
7641
7642 void _Marshaller_Components_InstallationFailure::assign( StaticValueType d, const StaticValueType s ) const
7643 {
7644 *(_MICO_T*) d = *(_MICO_T*) s;
7645 }
7646
7647 void _Marshaller_Components_InstallationFailure::free( StaticValueType v ) const
7648 {
7649 delete (_MICO_T*) v;
7650 }
7651
7652 ::CORBA::Boolean _Marshaller_Components_InstallationFailure::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
7653 {
7654 string repoid;
7655 return
7656 dc.except_begin( repoid ) &&
7657 dc.except_end();
7658 }
7659
7660 void _Marshaller_Components_InstallationFailure::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
7661 {
7662 ec.except_begin( "IDL:omg.org/Components/InstallationFailure:1.0" );
7663 ec.except_end();
7664 }
7665
7666 ::CORBA::StaticTypeInfo *_marshaller_Components_InstallationFailure;
7667
7668 void Components::InstallationFailure::_throwit() const
7669 {
7670 #ifdef HAVE_EXCEPTIONS
7671 #ifdef HAVE_STD_EH
7672 throw *this;
7673 #else
7674 throw InstallationFailure_var( (Components::InstallationFailure*)_clone() );
7675 #endif
7676 #else
7677 CORBA::Exception::_throw_failed( _clone() );
7678 #endif
7679 }
7680
7681 const char *Components::InstallationFailure::_repoid() const
7682 {
7683 return "IDL:omg.org/Components/InstallationFailure:1.0";
7684 }
7685
7686 void Components::InstallationFailure::_encode( CORBA::DataEncoder &_en ) const
7687 {
7688 _marshaller_Components_InstallationFailure->marshal( _en, (void*) this );
7689 }
7690
7691 void Components::InstallationFailure::_encode_any( CORBA::Any & ) const
7692 {
7693
7694 assert(0);
7695 }
7696
7697 CORBA::Exception *Components::InstallationFailure::_clone() const
7698 {
7699 return new InstallationFailure( *this );
7700 }
7701
7702 Components::InstallationFailure *Components::InstallationFailure::_downcast( CORBA::Exception *_ex )
7703 {
7704 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InstallationFailure:1.0" ) )
7705 return (InstallationFailure *) _ex;
7706 return NULL;
7707 }
7708
7709 const Components::InstallationFailure *Components::InstallationFailure::_downcast( const CORBA::Exception *_ex )
7710 {
7711 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InstallationFailure:1.0" ) )
7712 return (InstallationFailure *) _ex;
7713 return NULL;
7714 }
7715
7716
7717 #ifdef HAVE_EXPLICIT_STRUCT_OPS
7718 Components::InvalidAssembly::InvalidAssembly()
7719 {
7720 }
7721
7722 Components::InvalidAssembly::InvalidAssembly( const InvalidAssembly& _s )
7723 {
7724 }
7725
7726 Components::InvalidAssembly::~InvalidAssembly()
7727 {
7728 }
7729
7730 Components::InvalidAssembly&
7731 Components::InvalidAssembly::operator=( const InvalidAssembly& _s )
7732 {
7733 return *this;
7734 }
7735 #endif
7736
7737 class _Marshaller_Components_InvalidAssembly : public ::CORBA::StaticTypeInfo {
7738 typedef ::Components::InvalidAssembly _MICO_T;
7739 public:
7740 StaticValueType create () const;
7741 void assign (StaticValueType dst, const StaticValueType src) const;
7742 void free (StaticValueType) const;
7743 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
7744 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
7745 };
7746
7747
7748 ::CORBA::StaticValueType _Marshaller_Components_InvalidAssembly::create() const
7749 {
7750 return (StaticValueType) new _MICO_T;
7751 }
7752
7753 void _Marshaller_Components_InvalidAssembly::assign( StaticValueType d, const StaticValueType s ) const
7754 {
7755 *(_MICO_T*) d = *(_MICO_T*) s;
7756 }
7757
7758 void _Marshaller_Components_InvalidAssembly::free( StaticValueType v ) const
7759 {
7760 delete (_MICO_T*) v;
7761 }
7762
7763 ::CORBA::Boolean _Marshaller_Components_InvalidAssembly::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
7764 {
7765 string repoid;
7766 return
7767 dc.except_begin( repoid ) &&
7768 dc.except_end();
7769 }
7770
7771 void _Marshaller_Components_InvalidAssembly::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
7772 {
7773 ec.except_begin( "IDL:omg.org/Components/InvalidAssembly:1.0" );
7774 ec.except_end();
7775 }
7776
7777 ::CORBA::StaticTypeInfo *_marshaller_Components_InvalidAssembly;
7778
7779 void Components::InvalidAssembly::_throwit() const
7780 {
7781 #ifdef HAVE_EXCEPTIONS
7782 #ifdef HAVE_STD_EH
7783 throw *this;
7784 #else
7785 throw InvalidAssembly_var( (Components::InvalidAssembly*)_clone() );
7786 #endif
7787 #else
7788 CORBA::Exception::_throw_failed( _clone() );
7789 #endif
7790 }
7791
7792 const char *Components::InvalidAssembly::_repoid() const
7793 {
7794 return "IDL:omg.org/Components/InvalidAssembly:1.0";
7795 }
7796
7797 void Components::InvalidAssembly::_encode( CORBA::DataEncoder &_en ) const
7798 {
7799 _marshaller_Components_InvalidAssembly->marshal( _en, (void*) this );
7800 }
7801
7802 void Components::InvalidAssembly::_encode_any( CORBA::Any & ) const
7803 {
7804
7805 assert(0);
7806 }
7807
7808 CORBA::Exception *Components::InvalidAssembly::_clone() const
7809 {
7810 return new InvalidAssembly( *this );
7811 }
7812
7813 Components::InvalidAssembly *Components::InvalidAssembly::_downcast( CORBA::Exception *_ex )
7814 {
7815 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidAssembly:1.0" ) )
7816 return (InvalidAssembly *) _ex;
7817 return NULL;
7818 }
7819
7820 const Components::InvalidAssembly *Components::InvalidAssembly::_downcast( const CORBA::Exception *_ex )
7821 {
7822 if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/Components/InvalidAssembly:1.0" ) )
7823 return (InvalidAssembly *) _ex;
7824 return NULL;
7825 }
7826
7827
7828
7829
7830 Components::Container::~Container()
7831 {
7832 }
7833
7834 void *
7835 Components::Container::_narrow_helper( const char *_repoid )
7836 {
7837 if( strcmp( _repoid, "IDL:omg.org/Components/Container:1.0" ) == 0 )
7838 return (void *)this;
7839 return NULL;
7840 }
7841
7842 Components::Container_ptr
7843 Components::Container::_narrow( CORBA::Object_ptr _obj )
7844 {
7845 Components::Container_ptr _o;
7846 if( !CORBA::is_nil( _obj ) ) {
7847 void *_p;
7848 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/Container:1.0" )))
7849 return _duplicate( (Components::Container_ptr) _p );
7850 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/Container:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/Container:1.0")) {
7851 _o = new Components::Container_stub;
7852 _o->CORBA::Object::operator=( *_obj );
7853 return _o;
7854 }
7855 }
7856 return _nil();
7857 }
7858
7859 Components::Container_ptr
7860 Components::Container::_narrow( CORBA::AbstractBase_ptr _obj )
7861 {
7862 return _narrow (_obj->_to_object());
7863 }
7864
7865 class _Marshaller_Components_Container : public ::CORBA::StaticTypeInfo {
7866 typedef Components::Container_ptr _MICO_T;
7867 public:
7868 StaticValueType create () const;
7869 void assign (StaticValueType dst, const StaticValueType src) const;
7870 void free (StaticValueType) const;
7871 void release (StaticValueType) const;
7872 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
7873 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
7874 };
7875
7876
7877 ::CORBA::StaticValueType _Marshaller_Components_Container::create() const
7878 {
7879 return (StaticValueType) new _MICO_T( 0 );
7880 }
7881
7882 void _Marshaller_Components_Container::assign( StaticValueType d, const StaticValueType s ) const
7883 {
7884 *(_MICO_T*) d = ::Components::Container::_duplicate( *(_MICO_T*) s );
7885 }
7886
7887 void _Marshaller_Components_Container::free( StaticValueType v ) const
7888 {
7889 ::CORBA::release( *(_MICO_T *) v );
7890 delete (_MICO_T*) v;
7891 }
7892
7893 void _Marshaller_Components_Container::release( StaticValueType v ) const
7894 {
7895 ::CORBA::release( *(_MICO_T *) v );
7896 }
7897
7898 ::CORBA::Boolean _Marshaller_Components_Container::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
7899 {
7900 ::CORBA::Object_ptr obj;
7901 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
7902 return FALSE;
7903 *(_MICO_T *) v = ::Components::Container::_narrow( obj );
7904 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
7905 ::CORBA::release (obj);
7906 return ret;
7907 }
7908
7909 void _Marshaller_Components_Container::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
7910 {
7911 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
7912 ::CORBA::_stc_Object->marshal( ec, &obj );
7913 }
7914
7915 ::CORBA::StaticTypeInfo *_marshaller_Components_Container;
7916
7917
7918
7919
7920 Components::Container_stub::~Container_stub()
7921 {
7922 }
7923
7924 #ifndef MICO_CONF_NO_POA
7925
7926 void *
7927 POA_Components::Container::_narrow_helper (const char * repoid)
7928 {
7929 if (strcmp (repoid, "IDL:omg.org/Components/Container:1.0") == 0) {
7930 return (void *) this;
7931 }
7932 return NULL;
7933 }
7934
7935 POA_Components::Container *
7936 POA_Components::Container::_narrow (PortableServer::Servant serv)
7937 {
7938 void * p;
7939 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/Container:1.0")) != NULL) {
7940 serv->_add_ref ();
7941 return (POA_Components::Container *) p;
7942 }
7943 return NULL;
7944 }
7945
7946 Components::Container_stub_clp::Container_stub_clp ()
7947 {
7948 }
7949
7950 Components::Container_stub_clp::Container_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
7951 : CORBA::Object(*obj), PortableServer::StubBase(poa)
7952 {
7953 }
7954
7955 Components::Container_stub_clp::~Container_stub_clp ()
7956 {
7957 }
7958
7959 #endif // MICO_CONF_NO_POA
7960
7961 Components::ConfigValues* Components::Container_stub::configuration()
7962 {
7963 CORBA::StaticAny __res( _marshaller__seq_Components_ConfigValue );
7964
7965 CORBA::StaticRequest __req( this, "_get_configuration" );
7966 __req.set_result( &__res );
7967
7968 __req.invoke();
7969
7970 mico_sii_throw( &__req,
7971 0);
7972 return (Components::ConfigValues*) __res._retn();
7973 }
7974
7975
7976 #ifndef MICO_CONF_NO_POA
7977
7978 Components::ConfigValues*
7979 Components::Container_stub_clp::configuration()
7980 {
7981 return Components::Container_stub::configuration();
7982 }
7983
7984 #endif // MICO_CONF_NO_POA
7985
7986 Components::ComponentServer_ptr Components::Container_stub::get_component_server()
7987 {
7988 Components::ComponentServer_ptr _res;
7989 CORBA::StaticAny __res( _marshaller_Components_ComponentServer, &_res );
7990
7991 CORBA::StaticRequest __req( this, "get_component_server" );
7992 __req.set_result( &__res );
7993
7994 __req.invoke();
7995
7996 mico_sii_throw( &__req,
7997 0);
7998 return _res;
7999 }
8000
8001
8002 #ifndef MICO_CONF_NO_POA
8003
8004 Components::ComponentServer_ptr
8005 Components::Container_stub_clp::get_component_server()
8006 {
8007 PortableServer::Servant _serv = _preinvoke ();
8008 if (_serv) {
8009 POA_Components::Container * _myserv = POA_Components::Container::_narrow (_serv);
8010 if (_myserv) {
8011 Components::ComponentServer_ptr __res;
8012
8013 #ifdef HAVE_EXCEPTIONS
8014 try {
8015 #endif
8016 __res = _myserv->get_component_server();
8017 #ifdef HAVE_EXCEPTIONS
8018 }
8019 catch (...) {
8020 _myserv->_remove_ref();
8021 _postinvoke();
8022 throw;
8023 }
8024 #endif
8025
8026 _myserv->_remove_ref();
8027 _postinvoke ();
8028 return __res;
8029 }
8030 _postinvoke ();
8031 }
8032
8033 return Components::Container_stub::get_component_server();
8034 }
8035
8036 #endif // MICO_CONF_NO_POA
8037
8038 Components::CCMHome_ptr Components::Container_stub::install_home( const char* _par_id, const char* _par_entrypt, const Components::ConfigValues& _par_config )
8039 {
8040 CORBA::StaticAny _sa_id( CORBA::_stc_string, &_par_id );
8041 CORBA::StaticAny _sa_entrypt( CORBA::_stc_string, &_par_entrypt );
8042 CORBA::StaticAny _sa_config( _marshaller__seq_Components_ConfigValue, &_par_config );
8043 Components::CCMHome_ptr _res;
8044 CORBA::StaticAny __res( _marshaller_Components_CCMHome, &_res );
8045
8046 CORBA::StaticRequest __req( this, "install_home" );
8047 __req.add_in_arg( &_sa_id );
8048 __req.add_in_arg( &_sa_entrypt );
8049 __req.add_in_arg( &_sa_config );
8050 __req.set_result( &__res );
8051
8052 __req.invoke();
8053
8054 mico_sii_throw( &__req,
8055 _marshaller_Components_InvalidConfiguration, "IDL:omg.org/Components/InvalidConfiguration:1.0",
8056 _marshaller_Components_InstallationFailure, "IDL:omg.org/Components/InstallationFailure:1.0",
8057 0);
8058 return _res;
8059 }
8060
8061
8062 #ifndef MICO_CONF_NO_POA
8063
8064 Components::CCMHome_ptr
8065 Components::Container_stub_clp::install_home( const char* _par_id, const char* _par_entrypt, const Components::ConfigValues& _par_config )
8066 {
8067 return Components::Container_stub::install_home(_par_id, _par_entrypt, _par_config);
8068 }
8069
8070 #endif // MICO_CONF_NO_POA
8071
8072 void Components::Container_stub::remove_home( Components::CCMHome_ptr _par_href )
8073 {
8074 CORBA::StaticAny _sa_href( _marshaller_Components_CCMHome, &_par_href );
8075 CORBA::StaticRequest __req( this, "remove_home" );
8076 __req.add_in_arg( &_sa_href );
8077
8078 __req.invoke();
8079
8080 mico_sii_throw( &__req,
8081 _marshaller_Components_RemoveFailure, "IDL:omg.org/Components/RemoveFailure:1.0",
8082 0);
8083 }
8084
8085
8086 #ifndef MICO_CONF_NO_POA
8087
8088 void
8089 Components::Container_stub_clp::remove_home( Components::CCMHome_ptr _par_href )
8090 {
8091 PortableServer::Servant _serv = _preinvoke ();
8092 if (_serv) {
8093 POA_Components::Container * _myserv = POA_Components::Container::_narrow (_serv);
8094 if (_myserv) {
8095 #ifdef HAVE_EXCEPTIONS
8096 try {
8097 #endif
8098 _myserv->remove_home(_par_href);
8099 #ifdef HAVE_EXCEPTIONS
8100 }
8101 catch (...) {
8102 _myserv->_remove_ref();
8103 _postinvoke();
8104 throw;
8105 }
8106 #endif
8107
8108 _myserv->_remove_ref();
8109 _postinvoke ();
8110 return;
8111 }
8112 _postinvoke ();
8113 }
8114
8115 Components::Container_stub::remove_home(_par_href);
8116 }
8117
8118 #endif // MICO_CONF_NO_POA
8119
8120 Components::CCMHomes* Components::Container_stub::get_homes()
8121 {
8122 CORBA::StaticAny __res( _marshaller__seq_Components_CCMHome );
8123
8124 CORBA::StaticRequest __req( this, "get_homes" );
8125 __req.set_result( &__res );
8126
8127 __req.invoke();
8128
8129 mico_sii_throw( &__req,
8130 0);
8131 return (Components::CCMHomes*) __res._retn();
8132 }
8133
8134
8135 #ifndef MICO_CONF_NO_POA
8136
8137 Components::CCMHomes*
8138 Components::Container_stub_clp::get_homes()
8139 {
8140 PortableServer::Servant _serv = _preinvoke ();
8141 if (_serv) {
8142 POA_Components::Container * _myserv = POA_Components::Container::_narrow (_serv);
8143 if (_myserv) {
8144 Components::CCMHomes* __res;
8145
8146 #ifdef HAVE_EXCEPTIONS
8147 try {
8148 #endif
8149 __res = _myserv->get_homes();
8150 #ifdef HAVE_EXCEPTIONS
8151 }
8152 catch (...) {
8153 _myserv->_remove_ref();
8154 _postinvoke();
8155 throw;
8156 }
8157 #endif
8158
8159 _myserv->_remove_ref();
8160 _postinvoke ();
8161 return __res;
8162 }
8163 _postinvoke ();
8164 }
8165
8166 return Components::Container_stub::get_homes();
8167 }
8168
8169 #endif // MICO_CONF_NO_POA
8170
8171 void Components::Container_stub::remove()
8172 {
8173 CORBA::StaticRequest __req( this, "remove" );
8174
8175 __req.invoke();
8176
8177 mico_sii_throw( &__req,
8178 _marshaller_Components_RemoveFailure, "IDL:omg.org/Components/RemoveFailure:1.0",
8179 0);
8180 }
8181
8182
8183 #ifndef MICO_CONF_NO_POA
8184
8185 void
8186 Components::Container_stub_clp::remove()
8187 {
8188 PortableServer::Servant _serv = _preinvoke ();
8189 if (_serv) {
8190 POA_Components::Container * _myserv = POA_Components::Container::_narrow (_serv);
8191 if (_myserv) {
8192 #ifdef HAVE_EXCEPTIONS
8193 try {
8194 #endif
8195 _myserv->remove();
8196 #ifdef HAVE_EXCEPTIONS
8197 }
8198 catch (...) {
8199 _myserv->_remove_ref();
8200 _postinvoke();
8201 throw;
8202 }
8203 #endif
8204
8205 _myserv->_remove_ref();
8206 _postinvoke ();
8207 return;
8208 }
8209 _postinvoke ();
8210 }
8211
8212 Components::Container_stub::remove();
8213 }
8214
8215 #endif // MICO_CONF_NO_POA
8216
8217
8218
8219
8220
8221 Components::ComponentServer::~ComponentServer()
8222 {
8223 }
8224
8225 void *
8226 Components::ComponentServer::_narrow_helper( const char *_repoid )
8227 {
8228 if( strcmp( _repoid, "IDL:omg.org/Components/ComponentServer:1.0" ) == 0 )
8229 return (void *)this;
8230 return NULL;
8231 }
8232
8233 Components::ComponentServer_ptr
8234 Components::ComponentServer::_narrow( CORBA::Object_ptr _obj )
8235 {
8236 Components::ComponentServer_ptr _o;
8237 if( !CORBA::is_nil( _obj ) ) {
8238 void *_p;
8239 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/ComponentServer:1.0" )))
8240 return _duplicate( (Components::ComponentServer_ptr) _p );
8241 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/ComponentServer:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/ComponentServer:1.0")) {
8242 _o = new Components::ComponentServer_stub;
8243 _o->CORBA::Object::operator=( *_obj );
8244 return _o;
8245 }
8246 }
8247 return _nil();
8248 }
8249
8250 Components::ComponentServer_ptr
8251 Components::ComponentServer::_narrow( CORBA::AbstractBase_ptr _obj )
8252 {
8253 return _narrow (_obj->_to_object());
8254 }
8255
8256 class _Marshaller_Components_ComponentServer : public ::CORBA::StaticTypeInfo {
8257 typedef Components::ComponentServer_ptr _MICO_T;
8258 public:
8259 StaticValueType create () const;
8260 void assign (StaticValueType dst, const StaticValueType src) const;
8261 void free (StaticValueType) const;
8262 void release (StaticValueType) const;
8263 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
8264 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
8265 };
8266
8267
8268 ::CORBA::StaticValueType _Marshaller_Components_ComponentServer::create() const
8269 {
8270 return (StaticValueType) new _MICO_T( 0 );
8271 }
8272
8273 void _Marshaller_Components_ComponentServer::assign( StaticValueType d, const StaticValueType s ) const
8274 {
8275 *(_MICO_T*) d = ::Components::ComponentServer::_duplicate( *(_MICO_T*) s );
8276 }
8277
8278 void _Marshaller_Components_ComponentServer::free( StaticValueType v ) const
8279 {
8280 ::CORBA::release( *(_MICO_T *) v );
8281 delete (_MICO_T*) v;
8282 }
8283
8284 void _Marshaller_Components_ComponentServer::release( StaticValueType v ) const
8285 {
8286 ::CORBA::release( *(_MICO_T *) v );
8287 }
8288
8289 ::CORBA::Boolean _Marshaller_Components_ComponentServer::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
8290 {
8291 ::CORBA::Object_ptr obj;
8292 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
8293 return FALSE;
8294 *(_MICO_T *) v = ::Components::ComponentServer::_narrow( obj );
8295 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
8296 ::CORBA::release (obj);
8297 return ret;
8298 }
8299
8300 void _Marshaller_Components_ComponentServer::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
8301 {
8302 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
8303 ::CORBA::_stc_Object->marshal( ec, &obj );
8304 }
8305
8306 ::CORBA::StaticTypeInfo *_marshaller_Components_ComponentServer;
8307
8308
8309
8310
8311 Components::ComponentServer_stub::~ComponentServer_stub()
8312 {
8313 }
8314
8315 #ifndef MICO_CONF_NO_POA
8316
8317 void *
8318 POA_Components::ComponentServer::_narrow_helper (const char * repoid)
8319 {
8320 if (strcmp (repoid, "IDL:omg.org/Components/ComponentServer:1.0") == 0) {
8321 return (void *) this;
8322 }
8323 return NULL;
8324 }
8325
8326 POA_Components::ComponentServer *
8327 POA_Components::ComponentServer::_narrow (PortableServer::Servant serv)
8328 {
8329 void * p;
8330 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/ComponentServer:1.0")) != NULL) {
8331 serv->_add_ref ();
8332 return (POA_Components::ComponentServer *) p;
8333 }
8334 return NULL;
8335 }
8336
8337 Components::ComponentServer_stub_clp::ComponentServer_stub_clp ()
8338 {
8339 }
8340
8341 Components::ComponentServer_stub_clp::ComponentServer_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
8342 : CORBA::Object(*obj), PortableServer::StubBase(poa)
8343 {
8344 }
8345
8346 Components::ComponentServer_stub_clp::~ComponentServer_stub_clp ()
8347 {
8348 }
8349
8350 #endif // MICO_CONF_NO_POA
8351
8352 Components::ConfigValues* Components::ComponentServer_stub::configuration()
8353 {
8354 CORBA::StaticAny __res( _marshaller__seq_Components_ConfigValue );
8355
8356 CORBA::StaticRequest __req( this, "_get_configuration" );
8357 __req.set_result( &__res );
8358
8359 __req.invoke();
8360
8361 mico_sii_throw( &__req,
8362 0);
8363 return (Components::ConfigValues*) __res._retn();
8364 }
8365
8366
8367 #ifndef MICO_CONF_NO_POA
8368
8369 Components::ConfigValues*
8370 Components::ComponentServer_stub_clp::configuration()
8371 {
8372 return Components::ComponentServer_stub::configuration();
8373 }
8374
8375 #endif // MICO_CONF_NO_POA
8376
8377 Components::ServerActivator_ptr Components::ComponentServer_stub::get_server_activator()
8378 {
8379 Components::ServerActivator_ptr _res;
8380 CORBA::StaticAny __res( _marshaller_Components_ServerActivator, &_res );
8381
8382 CORBA::StaticRequest __req( this, "get_server_activator" );
8383 __req.set_result( &__res );
8384
8385 __req.invoke();
8386
8387 mico_sii_throw( &__req,
8388 0);
8389 return _res;
8390 }
8391
8392
8393 #ifndef MICO_CONF_NO_POA
8394
8395 Components::ServerActivator_ptr
8396 Components::ComponentServer_stub_clp::get_server_activator()
8397 {
8398 PortableServer::Servant _serv = _preinvoke ();
8399 if (_serv) {
8400 POA_Components::ComponentServer * _myserv = POA_Components::ComponentServer::_narrow (_serv);
8401 if (_myserv) {
8402 Components::ServerActivator_ptr __res;
8403
8404 #ifdef HAVE_EXCEPTIONS
8405 try {
8406 #endif
8407 __res = _myserv->get_server_activator();
8408 #ifdef HAVE_EXCEPTIONS
8409 }
8410 catch (...) {
8411 _myserv->_remove_ref();
8412 _postinvoke();
8413 throw;
8414 }
8415 #endif
8416
8417 _myserv->_remove_ref();
8418 _postinvoke ();
8419 return __res;
8420 }
8421 _postinvoke ();
8422 }
8423
8424 return Components::ComponentServer_stub::get_server_activator();
8425 }
8426
8427 #endif // MICO_CONF_NO_POA
8428
8429 Components::Container_ptr Components::ComponentServer_stub::create_container( const Components::ConfigValues& _par_config )
8430 {
8431 CORBA::StaticAny _sa_config( _marshaller__seq_Components_ConfigValue, &_par_config );
8432 Components::Container_ptr _res;
8433 CORBA::StaticAny __res( _marshaller_Components_Container, &_res );
8434
8435 CORBA::StaticRequest __req( this, "create_container" );
8436 __req.add_in_arg( &_sa_config );
8437 __req.set_result( &__res );
8438
8439 __req.invoke();
8440
8441 mico_sii_throw( &__req,
8442 _marshaller_Components_CreateFailure, "IDL:omg.org/Components/CreateFailure:1.0",
8443 _marshaller_Components_InvalidConfiguration, "IDL:omg.org/Components/InvalidConfiguration:1.0",
8444 0);
8445 return _res;
8446 }
8447
8448
8449 #ifndef MICO_CONF_NO_POA
8450
8451 Components::Container_ptr
8452 Components::ComponentServer_stub_clp::create_container( const Components::ConfigValues& _par_config )
8453 {
8454 return Components::ComponentServer_stub::create_container(_par_config);
8455 }
8456
8457 #endif // MICO_CONF_NO_POA
8458
8459 void Components::ComponentServer_stub::remove_container( Components::Container_ptr _par_cref )
8460 {
8461 CORBA::StaticAny _sa_cref( _marshaller_Components_Container, &_par_cref );
8462 CORBA::StaticRequest __req( this, "remove_container" );
8463 __req.add_in_arg( &_sa_cref );
8464
8465 __req.invoke();
8466
8467 mico_sii_throw( &__req,
8468 _marshaller_Components_RemoveFailure, "IDL:omg.org/Components/RemoveFailure:1.0",
8469 0);
8470 }
8471
8472
8473 #ifndef MICO_CONF_NO_POA
8474
8475 void
8476 Components::ComponentServer_stub_clp::remove_container( Components::Container_ptr _par_cref )
8477 {
8478 PortableServer::Servant _serv = _preinvoke ();
8479 if (_serv) {
8480 POA_Components::ComponentServer * _myserv = POA_Components::ComponentServer::_narrow (_serv);
8481 if (_myserv) {
8482 #ifdef HAVE_EXCEPTIONS
8483 try {
8484 #endif
8485 _myserv->remove_container(_par_cref);
8486 #ifdef HAVE_EXCEPTIONS
8487 }
8488 catch (...) {
8489 _myserv->_remove_ref();
8490 _postinvoke();
8491 throw;
8492 }
8493 #endif
8494
8495 _myserv->_remove_ref();
8496 _postinvoke ();
8497 return;
8498 }
8499 _postinvoke ();
8500 }
8501
8502 Components::ComponentServer_stub::remove_container(_par_cref);
8503 }
8504
8505 #endif // MICO_CONF_NO_POA
8506
8507 Components::Containers* Components::ComponentServer_stub::get_containers()
8508 {
8509 CORBA::StaticAny __res( _marshaller__seq_Components_Container );
8510
8511 CORBA::StaticRequest __req( this, "get_containers" );
8512 __req.set_result( &__res );
8513
8514 __req.invoke();
8515
8516 mico_sii_throw( &__req,
8517 0);
8518 return (Components::Containers*) __res._retn();
8519 }
8520
8521
8522 #ifndef MICO_CONF_NO_POA
8523
8524 Components::Containers*
8525 Components::ComponentServer_stub_clp::get_containers()
8526 {
8527 PortableServer::Servant _serv = _preinvoke ();
8528 if (_serv) {
8529 POA_Components::ComponentServer * _myserv = POA_Components::ComponentServer::_narrow (_serv);
8530 if (_myserv) {
8531 Components::Containers* __res;
8532
8533 #ifdef HAVE_EXCEPTIONS
8534 try {
8535 #endif
8536 __res = _myserv->get_containers();
8537 #ifdef HAVE_EXCEPTIONS
8538 }
8539 catch (...) {
8540 _myserv->_remove_ref();
8541 _postinvoke();
8542 throw;
8543 }
8544 #endif
8545
8546 _myserv->_remove_ref();
8547 _postinvoke ();
8548 return __res;
8549 }
8550 _postinvoke ();
8551 }
8552
8553 return Components::ComponentServer_stub::get_containers();
8554 }
8555
8556 #endif // MICO_CONF_NO_POA
8557
8558 void Components::ComponentServer_stub::remove()
8559 {
8560 CORBA::StaticRequest __req( this, "remove" );
8561
8562 __req.invoke();
8563
8564 mico_sii_throw( &__req,
8565 _marshaller_Components_RemoveFailure, "IDL:omg.org/Components/RemoveFailure:1.0",
8566 0);
8567 }
8568
8569
8570 #ifndef MICO_CONF_NO_POA
8571
8572 void
8573 Components::ComponentServer_stub_clp::remove()
8574 {
8575 PortableServer::Servant _serv = _preinvoke ();
8576 if (_serv) {
8577 POA_Components::ComponentServer * _myserv = POA_Components::ComponentServer::_narrow (_serv);
8578 if (_myserv) {
8579 #ifdef HAVE_EXCEPTIONS
8580 try {
8581 #endif
8582 _myserv->remove();
8583 #ifdef HAVE_EXCEPTIONS
8584 }
8585 catch (...) {
8586 _myserv->_remove_ref();
8587 _postinvoke();
8588 throw;
8589 }
8590 #endif
8591
8592 _myserv->_remove_ref();
8593 _postinvoke ();
8594 return;
8595 }
8596 _postinvoke ();
8597 }
8598
8599 Components::ComponentServer_stub::remove();
8600 }
8601
8602 #endif // MICO_CONF_NO_POA
8603
8604
8605
8606
8607
8608
8609
8610 Components::ComponentInstallation::~ComponentInstallation()
8611 {
8612 }
8613
8614 void *
8615 Components::ComponentInstallation::_narrow_helper( const char *_repoid )
8616 {
8617 if( strcmp( _repoid, "IDL:omg.org/Components/ComponentInstallation:1.0" ) == 0 )
8618 return (void *)this;
8619 return NULL;
8620 }
8621
8622 Components::ComponentInstallation_ptr
8623 Components::ComponentInstallation::_narrow( CORBA::Object_ptr _obj )
8624 {
8625 Components::ComponentInstallation_ptr _o;
8626 if( !CORBA::is_nil( _obj ) ) {
8627 void *_p;
8628 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/ComponentInstallation:1.0" )))
8629 return _duplicate( (Components::ComponentInstallation_ptr) _p );
8630 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/ComponentInstallation:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/ComponentInstallation:1.0")) {
8631 _o = new Components::ComponentInstallation_stub;
8632 _o->CORBA::Object::operator=( *_obj );
8633 return _o;
8634 }
8635 }
8636 return _nil();
8637 }
8638
8639 Components::ComponentInstallation_ptr
8640 Components::ComponentInstallation::_narrow( CORBA::AbstractBase_ptr _obj )
8641 {
8642 return _narrow (_obj->_to_object());
8643 }
8644
8645 class _Marshaller_Components_ComponentInstallation : public ::CORBA::StaticTypeInfo {
8646 typedef Components::ComponentInstallation_ptr _MICO_T;
8647 public:
8648 StaticValueType create () const;
8649 void assign (StaticValueType dst, const StaticValueType src) const;
8650 void free (StaticValueType) const;
8651 void release (StaticValueType) const;
8652 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
8653 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
8654 };
8655
8656
8657 ::CORBA::StaticValueType _Marshaller_Components_ComponentInstallation::create() const
8658 {
8659 return (StaticValueType) new _MICO_T( 0 );
8660 }
8661
8662 void _Marshaller_Components_ComponentInstallation::assign( StaticValueType d, const StaticValueType s ) const
8663 {
8664 *(_MICO_T*) d = ::Components::ComponentInstallation::_duplicate( *(_MICO_T*) s );
8665 }
8666
8667 void _Marshaller_Components_ComponentInstallation::free( StaticValueType v ) const
8668 {
8669 ::CORBA::release( *(_MICO_T *) v );
8670 delete (_MICO_T*) v;
8671 }
8672
8673 void _Marshaller_Components_ComponentInstallation::release( StaticValueType v ) const
8674 {
8675 ::CORBA::release( *(_MICO_T *) v );
8676 }
8677
8678 ::CORBA::Boolean _Marshaller_Components_ComponentInstallation::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
8679 {
8680 ::CORBA::Object_ptr obj;
8681 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
8682 return FALSE;
8683 *(_MICO_T *) v = ::Components::ComponentInstallation::_narrow( obj );
8684 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
8685 ::CORBA::release (obj);
8686 return ret;
8687 }
8688
8689 void _Marshaller_Components_ComponentInstallation::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
8690 {
8691 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
8692 ::CORBA::_stc_Object->marshal( ec, &obj );
8693 }
8694
8695 ::CORBA::StaticTypeInfo *_marshaller_Components_ComponentInstallation;
8696
8697
8698
8699
8700 Components::ComponentInstallation_stub::~ComponentInstallation_stub()
8701 {
8702 }
8703
8704 #ifndef MICO_CONF_NO_POA
8705
8706 void *
8707 POA_Components::ComponentInstallation::_narrow_helper (const char * repoid)
8708 {
8709 if (strcmp (repoid, "IDL:omg.org/Components/ComponentInstallation:1.0") == 0) {
8710 return (void *) this;
8711 }
8712 return NULL;
8713 }
8714
8715 POA_Components::ComponentInstallation *
8716 POA_Components::ComponentInstallation::_narrow (PortableServer::Servant serv)
8717 {
8718 void * p;
8719 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/ComponentInstallation:1.0")) != NULL) {
8720 serv->_add_ref ();
8721 return (POA_Components::ComponentInstallation *) p;
8722 }
8723 return NULL;
8724 }
8725
8726 Components::ComponentInstallation_stub_clp::ComponentInstallation_stub_clp ()
8727 {
8728 }
8729
8730 Components::ComponentInstallation_stub_clp::ComponentInstallation_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
8731 : CORBA::Object(*obj), PortableServer::StubBase(poa)
8732 {
8733 }
8734
8735 Components::ComponentInstallation_stub_clp::~ComponentInstallation_stub_clp ()
8736 {
8737 }
8738
8739 #endif // MICO_CONF_NO_POA
8740
8741 void Components::ComponentInstallation_stub::install( const char* _par_implUUID, const char* _par_component_loc )
8742 {
8743 CORBA::StaticAny _sa_implUUID( CORBA::_stc_string, &_par_implUUID );
8744 CORBA::StaticAny _sa_component_loc( CORBA::_stc_string, &_par_component_loc );
8745 CORBA::StaticRequest __req( this, "install" );
8746 __req.add_in_arg( &_sa_implUUID );
8747 __req.add_in_arg( &_sa_component_loc );
8748
8749 __req.invoke();
8750
8751 mico_sii_throw( &__req,
8752 _marshaller_Components_InvalidLocation, "IDL:omg.org/Components/InvalidLocation:1.0",
8753 _marshaller_Components_InstallationFailure, "IDL:omg.org/Components/InstallationFailure:1.0",
8754 0);
8755 }
8756
8757
8758 #ifndef MICO_CONF_NO_POA
8759
8760 void
8761 Components::ComponentInstallation_stub_clp::install( const char* _par_implUUID, const char* _par_component_loc )
8762 {
8763 PortableServer::Servant _serv = _preinvoke ();
8764 if (_serv) {
8765 POA_Components::ComponentInstallation * _myserv = POA_Components::ComponentInstallation::_narrow (_serv);
8766 if (_myserv) {
8767 #ifdef HAVE_EXCEPTIONS
8768 try {
8769 #endif
8770 _myserv->install(_par_implUUID, _par_component_loc);
8771 #ifdef HAVE_EXCEPTIONS
8772 }
8773 catch (...) {
8774 _myserv->_remove_ref();
8775 _postinvoke();
8776 throw;
8777 }
8778 #endif
8779
8780 _myserv->_remove_ref();
8781 _postinvoke ();
8782 return;
8783 }
8784 _postinvoke ();
8785 }
8786
8787 Components::ComponentInstallation_stub::install(_par_implUUID, _par_component_loc);
8788 }
8789
8790 #endif // MICO_CONF_NO_POA
8791
8792 void Components::ComponentInstallation_stub::replace( const char* _par_implUUID, const char* _par_component_loc )
8793 {
8794 CORBA::StaticAny _sa_implUUID( CORBA::_stc_string, &_par_implUUID );
8795 CORBA::StaticAny _sa_component_loc( CORBA::_stc_string, &_par_component_loc );
8796 CORBA::StaticRequest __req( this, "replace" );
8797 __req.add_in_arg( &_sa_implUUID );
8798 __req.add_in_arg( &_sa_component_loc );
8799
8800 __req.invoke();
8801
8802 mico_sii_throw( &__req,
8803 _marshaller_Components_InvalidLocation, "IDL:omg.org/Components/InvalidLocation:1.0",
8804 _marshaller_Components_InstallationFailure, "IDL:omg.org/Components/InstallationFailure:1.0",
8805 0);
8806 }
8807
8808
8809 #ifndef MICO_CONF_NO_POA
8810
8811 void
8812 Components::ComponentInstallation_stub_clp::replace( const char* _par_implUUID, const char* _par_component_loc )
8813 {
8814 PortableServer::Servant _serv = _preinvoke ();
8815 if (_serv) {
8816 POA_Components::ComponentInstallation * _myserv = POA_Components::ComponentInstallation::_narrow (_serv);
8817 if (_myserv) {
8818 #ifdef HAVE_EXCEPTIONS
8819 try {
8820 #endif
8821 _myserv->replace(_par_implUUID, _par_component_loc);
8822 #ifdef HAVE_EXCEPTIONS
8823 }
8824 catch (...) {
8825 _myserv->_remove_ref();
8826 _postinvoke();
8827 throw;
8828 }
8829 #endif
8830
8831 _myserv->_remove_ref();
8832 _postinvoke ();
8833 return;
8834 }
8835 _postinvoke ();
8836 }
8837
8838 Components::ComponentInstallation_stub::replace(_par_implUUID, _par_component_loc);
8839 }
8840
8841 #endif // MICO_CONF_NO_POA
8842
8843 void Components::ComponentInstallation_stub::remove( const char* _par_implUUID )
8844 {
8845 CORBA::StaticAny _sa_implUUID( CORBA::_stc_string, &_par_implUUID );
8846 CORBA::StaticRequest __req( this, "remove" );
8847 __req.add_in_arg( &_sa_implUUID );
8848
8849 __req.invoke();
8850
8851 mico_sii_throw( &__req,
8852 _marshaller_Components_UnknownImplId, "IDL:omg.org/Components/UnknownImplId:1.0",
8853 _marshaller_Components_RemoveFailure, "IDL:omg.org/Components/RemoveFailure:1.0",
8854 0);
8855 }
8856
8857
8858 #ifndef MICO_CONF_NO_POA
8859
8860 void
8861 Components::ComponentInstallation_stub_clp::remove( const char* _par_implUUID )
8862 {
8863 PortableServer::Servant _serv = _preinvoke ();
8864 if (_serv) {
8865 POA_Components::ComponentInstallation * _myserv = POA_Components::ComponentInstallation::_narrow (_serv);
8866 if (_myserv) {
8867 #ifdef HAVE_EXCEPTIONS
8868 try {
8869 #endif
8870 _myserv->remove(_par_implUUID);
8871 #ifdef HAVE_EXCEPTIONS
8872 }
8873 catch (...) {
8874 _myserv->_remove_ref();
8875 _postinvoke();
8876 throw;
8877 }
8878 #endif
8879
8880 _myserv->_remove_ref();
8881 _postinvoke ();
8882 return;
8883 }
8884 _postinvoke ();
8885 }
8886
8887 Components::ComponentInstallation_stub::remove(_par_implUUID);
8888 }
8889
8890 #endif // MICO_CONF_NO_POA
8891
8892 char* Components::ComponentInstallation_stub::get_implementation( const char* _par_implUUID )
8893 {
8894 CORBA::StaticAny _sa_implUUID( CORBA::_stc_string, &_par_implUUID );
8895 Components::Location _res;
8896 CORBA::StaticAny __res( CORBA::_stc_string, &_res );
8897
8898 CORBA::StaticRequest __req( this, "get_implementation" );
8899 __req.add_in_arg( &_sa_implUUID );
8900 __req.set_result( &__res );
8901
8902 __req.invoke();
8903
8904 mico_sii_throw( &__req,
8905 _marshaller_Components_UnknownImplId, "IDL:omg.org/Components/UnknownImplId:1.0",
8906 _marshaller_Components_InstallationFailure, "IDL:omg.org/Components/InstallationFailure:1.0",
8907 0);
8908 return _res;
8909 }
8910
8911
8912 #ifndef MICO_CONF_NO_POA
8913
8914 char*
8915 Components::ComponentInstallation_stub_clp::get_implementation( const char* _par_implUUID )
8916 {
8917 PortableServer::Servant _serv = _preinvoke ();
8918 if (_serv) {
8919 POA_Components::ComponentInstallation * _myserv = POA_Components::ComponentInstallation::_narrow (_serv);
8920 if (_myserv) {
8921 Components::Location __res;
8922
8923 #ifdef HAVE_EXCEPTIONS
8924 try {
8925 #endif
8926 __res = _myserv->get_implementation(_par_implUUID);
8927 #ifdef HAVE_EXCEPTIONS
8928 }
8929 catch (...) {
8930 _myserv->_remove_ref();
8931 _postinvoke();
8932 throw;
8933 }
8934 #endif
8935
8936 _myserv->_remove_ref();
8937 _postinvoke ();
8938 return __res;
8939 }
8940 _postinvoke ();
8941 }
8942
8943 return Components::ComponentInstallation_stub::get_implementation(_par_implUUID);
8944 }
8945
8946 #endif // MICO_CONF_NO_POA
8947
8948
8949 class _Marshaller_Components_AssemblyState : public ::CORBA::StaticTypeInfo {
8950 typedef Components::AssemblyState _MICO_T;
8951 public:
8952 StaticValueType create () const;
8953 void assign (StaticValueType dst, const StaticValueType src) const;
8954 void free (StaticValueType) const;
8955 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
8956 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
8957 };
8958
8959
8960 ::CORBA::StaticValueType _Marshaller_Components_AssemblyState::create() const
8961 {
8962 return (StaticValueType) new _MICO_T;
8963 }
8964
8965 void _Marshaller_Components_AssemblyState::assign( StaticValueType d, const StaticValueType s ) const
8966 {
8967 *(_MICO_T*) d = *(_MICO_T*) s;
8968 }
8969
8970 void _Marshaller_Components_AssemblyState::free( StaticValueType v ) const
8971 {
8972 delete (_MICO_T*) v;
8973 }
8974
8975 ::CORBA::Boolean _Marshaller_Components_AssemblyState::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
8976 {
8977 ::CORBA::ULong ul;
8978 if( !dc.enumeration( ul ) )
8979 return FALSE;
8980 *(_MICO_T*) v = (_MICO_T) ul;
8981 return TRUE;
8982 }
8983
8984 void _Marshaller_Components_AssemblyState::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
8985 {
8986 ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v );
8987 }
8988
8989 ::CORBA::StaticTypeInfo *_marshaller_Components_AssemblyState;
8990
8991
8992
8993
8994 Components::Assembly::~Assembly()
8995 {
8996 }
8997
8998 void *
8999 Components::Assembly::_narrow_helper( const char *_repoid )
9000 {
9001 if( strcmp( _repoid, "IDL:omg.org/Components/Assembly:1.0" ) == 0 )
9002 return (void *)this;
9003 return NULL;
9004 }
9005
9006 Components::Assembly_ptr
9007 Components::Assembly::_narrow( CORBA::Object_ptr _obj )
9008 {
9009 Components::Assembly_ptr _o;
9010 if( !CORBA::is_nil( _obj ) ) {
9011 void *_p;
9012 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/Assembly:1.0" )))
9013 return _duplicate( (Components::Assembly_ptr) _p );
9014 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/Assembly:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/Assembly:1.0")) {
9015 _o = new Components::Assembly_stub;
9016 _o->CORBA::Object::operator=( *_obj );
9017 return _o;
9018 }
9019 }
9020 return _nil();
9021 }
9022
9023 Components::Assembly_ptr
9024 Components::Assembly::_narrow( CORBA::AbstractBase_ptr _obj )
9025 {
9026 return _narrow (_obj->_to_object());
9027 }
9028
9029 class _Marshaller_Components_Assembly : public ::CORBA::StaticTypeInfo {
9030 typedef Components::Assembly_ptr _MICO_T;
9031 public:
9032 StaticValueType create () const;
9033 void assign (StaticValueType dst, const StaticValueType src) const;
9034 void free (StaticValueType) const;
9035 void release (StaticValueType) const;
9036 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
9037 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
9038 };
9039
9040
9041 ::CORBA::StaticValueType _Marshaller_Components_Assembly::create() const
9042 {
9043 return (StaticValueType) new _MICO_T( 0 );
9044 }
9045
9046 void _Marshaller_Components_Assembly::assign( StaticValueType d, const StaticValueType s ) const
9047 {
9048 *(_MICO_T*) d = ::Components::Assembly::_duplicate( *(_MICO_T*) s );
9049 }
9050
9051 void _Marshaller_Components_Assembly::free( StaticValueType v ) const
9052 {
9053 ::CORBA::release( *(_MICO_T *) v );
9054 delete (_MICO_T*) v;
9055 }
9056
9057 void _Marshaller_Components_Assembly::release( StaticValueType v ) const
9058 {
9059 ::CORBA::release( *(_MICO_T *) v );
9060 }
9061
9062 ::CORBA::Boolean _Marshaller_Components_Assembly::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
9063 {
9064 ::CORBA::Object_ptr obj;
9065 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
9066 return FALSE;
9067 *(_MICO_T *) v = ::Components::Assembly::_narrow( obj );
9068 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
9069 ::CORBA::release (obj);
9070 return ret;
9071 }
9072
9073 void _Marshaller_Components_Assembly::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
9074 {
9075 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
9076 ::CORBA::_stc_Object->marshal( ec, &obj );
9077 }
9078
9079 ::CORBA::StaticTypeInfo *_marshaller_Components_Assembly;
9080
9081
9082
9083
9084 Components::Assembly_stub::~Assembly_stub()
9085 {
9086 }
9087
9088 #ifndef MICO_CONF_NO_POA
9089
9090 void *
9091 POA_Components::Assembly::_narrow_helper (const char * repoid)
9092 {
9093 if (strcmp (repoid, "IDL:omg.org/Components/Assembly:1.0") == 0) {
9094 return (void *) this;
9095 }
9096 return NULL;
9097 }
9098
9099 POA_Components::Assembly *
9100 POA_Components::Assembly::_narrow (PortableServer::Servant serv)
9101 {
9102 void * p;
9103 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/Assembly:1.0")) != NULL) {
9104 serv->_add_ref ();
9105 return (POA_Components::Assembly *) p;
9106 }
9107 return NULL;
9108 }
9109
9110 Components::Assembly_stub_clp::Assembly_stub_clp ()
9111 {
9112 }
9113
9114 Components::Assembly_stub_clp::Assembly_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
9115 : CORBA::Object(*obj), PortableServer::StubBase(poa)
9116 {
9117 }
9118
9119 Components::Assembly_stub_clp::~Assembly_stub_clp ()
9120 {
9121 }
9122
9123 #endif // MICO_CONF_NO_POA
9124
9125 void Components::Assembly_stub::build()
9126 {
9127 CORBA::StaticRequest __req( this, "build" );
9128
9129 __req.invoke();
9130
9131 mico_sii_throw( &__req,
9132 _marshaller_Components_CreateFailure, "IDL:omg.org/Components/CreateFailure:1.0",
9133 0);
9134 }
9135
9136
9137 #ifndef MICO_CONF_NO_POA
9138
9139 void
9140 Components::Assembly_stub_clp::build()
9141 {
9142 PortableServer::Servant _serv = _preinvoke ();
9143 if (_serv) {
9144 POA_Components::Assembly * _myserv = POA_Components::Assembly::_narrow (_serv);
9145 if (_myserv) {
9146 #ifdef HAVE_EXCEPTIONS
9147 try {
9148 #endif
9149 _myserv->build();
9150 #ifdef HAVE_EXCEPTIONS
9151 }
9152 catch (...) {
9153 _myserv->_remove_ref();
9154 _postinvoke();
9155 throw;
9156 }
9157 #endif
9158
9159 _myserv->_remove_ref();
9160 _postinvoke ();
9161 return;
9162 }
9163 _postinvoke ();
9164 }
9165
9166 Components::Assembly_stub::build();
9167 }
9168
9169 #endif // MICO_CONF_NO_POA
9170
9171 void Components::Assembly_stub::tear_down()
9172 {
9173 CORBA::StaticRequest __req( this, "tear_down" );
9174
9175 __req.invoke();
9176
9177 mico_sii_throw( &__req,
9178 _marshaller_Components_RemoveFailure, "IDL:omg.org/Components/RemoveFailure:1.0",
9179 0);
9180 }
9181
9182
9183 #ifndef MICO_CONF_NO_POA
9184
9185 void
9186 Components::Assembly_stub_clp::tear_down()
9187 {
9188 PortableServer::Servant _serv = _preinvoke ();
9189 if (_serv) {
9190 POA_Components::Assembly * _myserv = POA_Components::Assembly::_narrow (_serv);
9191 if (_myserv) {
9192 #ifdef HAVE_EXCEPTIONS
9193 try {
9194 #endif
9195 _myserv->tear_down();
9196 #ifdef HAVE_EXCEPTIONS
9197 }
9198 catch (...) {
9199 _myserv->_remove_ref();
9200 _postinvoke();
9201 throw;
9202 }
9203 #endif
9204
9205 _myserv->_remove_ref();
9206 _postinvoke ();
9207 return;
9208 }
9209 _postinvoke ();
9210 }
9211
9212 Components::Assembly_stub::tear_down();
9213 }
9214
9215 #endif // MICO_CONF_NO_POA
9216
9217 Components::AssemblyState Components::Assembly_stub::get_state()
9218 {
9219 Components::AssemblyState _res;
9220 CORBA::StaticAny __res( _marshaller_Components_AssemblyState, &_res );
9221
9222 CORBA::StaticRequest __req( this, "get_state" );
9223 __req.set_result( &__res );
9224
9225 __req.invoke();
9226
9227 mico_sii_throw( &__req,
9228 0);
9229 return _res;
9230 }
9231
9232
9233 #ifndef MICO_CONF_NO_POA
9234
9235 Components::AssemblyState
9236 Components::Assembly_stub_clp::get_state()
9237 {
9238 PortableServer::Servant _serv = _preinvoke ();
9239 if (_serv) {
9240 POA_Components::Assembly * _myserv = POA_Components::Assembly::_narrow (_serv);
9241 if (_myserv) {
9242 Components::AssemblyState __res;
9243
9244 #ifdef HAVE_EXCEPTIONS
9245 try {
9246 #endif
9247 __res = _myserv->get_state();
9248 #ifdef HAVE_EXCEPTIONS
9249 }
9250 catch (...) {
9251 _myserv->_remove_ref();
9252 _postinvoke();
9253 throw;
9254 }
9255 #endif
9256
9257 _myserv->_remove_ref();
9258 _postinvoke ();
9259 return __res;
9260 }
9261 _postinvoke ();
9262 }
9263
9264 return Components::Assembly_stub::get_state();
9265 }
9266
9267 #endif // MICO_CONF_NO_POA
9268
9269
9270
9271
9272 Components::AssemblyFactory::~AssemblyFactory()
9273 {
9274 }
9275
9276 void *
9277 Components::AssemblyFactory::_narrow_helper( const char *_repoid )
9278 {
9279 if( strcmp( _repoid, "IDL:omg.org/Components/AssemblyFactory:1.0" ) == 0 )
9280 return (void *)this;
9281 return NULL;
9282 }
9283
9284 Components::AssemblyFactory_ptr
9285 Components::AssemblyFactory::_narrow( CORBA::Object_ptr _obj )
9286 {
9287 Components::AssemblyFactory_ptr _o;
9288 if( !CORBA::is_nil( _obj ) ) {
9289 void *_p;
9290 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/AssemblyFactory:1.0" )))
9291 return _duplicate( (Components::AssemblyFactory_ptr) _p );
9292 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/AssemblyFactory:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/AssemblyFactory:1.0")) {
9293 _o = new Components::AssemblyFactory_stub;
9294 _o->CORBA::Object::operator=( *_obj );
9295 return _o;
9296 }
9297 }
9298 return _nil();
9299 }
9300
9301 Components::AssemblyFactory_ptr
9302 Components::AssemblyFactory::_narrow( CORBA::AbstractBase_ptr _obj )
9303 {
9304 return _narrow (_obj->_to_object());
9305 }
9306
9307 class _Marshaller_Components_AssemblyFactory : public ::CORBA::StaticTypeInfo {
9308 typedef Components::AssemblyFactory_ptr _MICO_T;
9309 public:
9310 StaticValueType create () const;
9311 void assign (StaticValueType dst, const StaticValueType src) const;
9312 void free (StaticValueType) const;
9313 void release (StaticValueType) const;
9314 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
9315 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
9316 };
9317
9318
9319 ::CORBA::StaticValueType _Marshaller_Components_AssemblyFactory::create() const
9320 {
9321 return (StaticValueType) new _MICO_T( 0 );
9322 }
9323
9324 void _Marshaller_Components_AssemblyFactory::assign( StaticValueType d, const StaticValueType s ) const
9325 {
9326 *(_MICO_T*) d = ::Components::AssemblyFactory::_duplicate( *(_MICO_T*) s );
9327 }
9328
9329 void _Marshaller_Components_AssemblyFactory::free( StaticValueType v ) const
9330 {
9331 ::CORBA::release( *(_MICO_T *) v );
9332 delete (_MICO_T*) v;
9333 }
9334
9335 void _Marshaller_Components_AssemblyFactory::release( StaticValueType v ) const
9336 {
9337 ::CORBA::release( *(_MICO_T *) v );
9338 }
9339
9340 ::CORBA::Boolean _Marshaller_Components_AssemblyFactory::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
9341 {
9342 ::CORBA::Object_ptr obj;
9343 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
9344 return FALSE;
9345 *(_MICO_T *) v = ::Components::AssemblyFactory::_narrow( obj );
9346 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
9347 ::CORBA::release (obj);
9348 return ret;
9349 }
9350
9351 void _Marshaller_Components_AssemblyFactory::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
9352 {
9353 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
9354 ::CORBA::_stc_Object->marshal( ec, &obj );
9355 }
9356
9357 ::CORBA::StaticTypeInfo *_marshaller_Components_AssemblyFactory;
9358
9359
9360
9361
9362 Components::AssemblyFactory_stub::~AssemblyFactory_stub()
9363 {
9364 }
9365
9366 #ifndef MICO_CONF_NO_POA
9367
9368 void *
9369 POA_Components::AssemblyFactory::_narrow_helper (const char * repoid)
9370 {
9371 if (strcmp (repoid, "IDL:omg.org/Components/AssemblyFactory:1.0") == 0) {
9372 return (void *) this;
9373 }
9374 return NULL;
9375 }
9376
9377 POA_Components::AssemblyFactory *
9378 POA_Components::AssemblyFactory::_narrow (PortableServer::Servant serv)
9379 {
9380 void * p;
9381 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/AssemblyFactory:1.0")) != NULL) {
9382 serv->_add_ref ();
9383 return (POA_Components::AssemblyFactory *) p;
9384 }
9385 return NULL;
9386 }
9387
9388 Components::AssemblyFactory_stub_clp::AssemblyFactory_stub_clp ()
9389 {
9390 }
9391
9392 Components::AssemblyFactory_stub_clp::AssemblyFactory_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
9393 : CORBA::Object(*obj), PortableServer::StubBase(poa)
9394 {
9395 }
9396
9397 Components::AssemblyFactory_stub_clp::~AssemblyFactory_stub_clp ()
9398 {
9399 }
9400
9401 #endif // MICO_CONF_NO_POA
9402
9403 Components::Cookie* Components::AssemblyFactory_stub::create( const char* _par_assembly_loc )
9404 {
9405 CORBA::StaticAny _sa_assembly_loc( CORBA::_stc_string, &_par_assembly_loc );
9406 Components::Cookie* _res;
9407 CORBA::StaticAny __res( _marshaller_Components_Cookie, &_res );
9408
9409 CORBA::StaticRequest __req( this, "create" );
9410 __req.add_in_arg( &_sa_assembly_loc );
9411 __req.set_result( &__res );
9412
9413 __req.invoke();
9414
9415 mico_sii_throw( &__req,
9416 _marshaller_Components_InvalidLocation, "IDL:omg.org/Components/InvalidLocation:1.0",
9417 _marshaller_Components_CreateFailure, "IDL:omg.org/Components/CreateFailure:1.0",
9418 0);
9419 return _res;
9420 }
9421
9422
9423 #ifndef MICO_CONF_NO_POA
9424
9425 Components::Cookie*
9426 Components::AssemblyFactory_stub_clp::create( const char* _par_assembly_loc )
9427 {
9428 PortableServer::Servant _serv = _preinvoke ();
9429 if (_serv) {
9430 POA_Components::AssemblyFactory * _myserv = POA_Components::AssemblyFactory::_narrow (_serv);
9431 if (_myserv) {
9432 Components::Cookie* __res;
9433
9434 #ifdef HAVE_EXCEPTIONS
9435 try {
9436 #endif
9437 __res = _myserv->create(_par_assembly_loc);
9438 #ifdef HAVE_EXCEPTIONS
9439 }
9440 catch (...) {
9441 _myserv->_remove_ref();
9442 _postinvoke();
9443 throw;
9444 }
9445 #endif
9446
9447 _myserv->_remove_ref();
9448 _postinvoke ();
9449 Components::Cookie* __res2 = Components::Cookie::_downcast (__res->_copy_value ());
9450 CORBA::remove_ref (__res);
9451 return __res2;
9452 }
9453 _postinvoke ();
9454 }
9455
9456 return Components::AssemblyFactory_stub::create(_par_assembly_loc);
9457 }
9458
9459 #endif // MICO_CONF_NO_POA
9460
9461 Components::Assembly_ptr Components::AssemblyFactory_stub::lookup( Components::Cookie* _par_c )
9462 {
9463 CORBA::StaticAny _sa_c( _marshaller_Components_Cookie, &_par_c );
9464 Components::Assembly_ptr _res;
9465 CORBA::StaticAny __res( _marshaller_Components_Assembly, &_res );
9466
9467 CORBA::StaticRequest __req( this, "lookup" );
9468 __req.add_in_arg( &_sa_c );
9469 __req.set_result( &__res );
9470
9471 __req.invoke();
9472
9473 mico_sii_throw( &__req,
9474 _marshaller_Components_InvalidAssembly, "IDL:omg.org/Components/InvalidAssembly:1.0",
9475 0);
9476 return _res;
9477 }
9478
9479
9480 #ifndef MICO_CONF_NO_POA
9481
9482 Components::Assembly_ptr
9483 Components::AssemblyFactory_stub_clp::lookup( Components::Cookie* _par_c )
9484 {
9485 PortableServer::Servant _serv = _preinvoke ();
9486 if (_serv) {
9487 POA_Components::AssemblyFactory * _myserv = POA_Components::AssemblyFactory::_narrow (_serv);
9488 if (_myserv) {
9489 Components::Assembly_ptr __res;
9490
9491 Components::Cookie* _copy_of_par_c;
9492 _copy_of_par_c = Components::Cookie::_downcast (_par_c->_copy_value());
9493 #ifdef HAVE_EXCEPTIONS
9494 try {
9495 #endif
9496 __res = _myserv->lookup(_copy_of_par_c);
9497 #ifdef HAVE_EXCEPTIONS
9498 }
9499 catch (...) {
9500 _myserv->_remove_ref();
9501 _postinvoke();
9502 throw;
9503 }
9504 #endif
9505
9506 _myserv->_remove_ref();
9507 _postinvoke ();
9508 CORBA::remove_ref (_copy_of_par_c);
9509 return __res;
9510 }
9511 _postinvoke ();
9512 }
9513
9514 return Components::AssemblyFactory_stub::lookup(_par_c);
9515 }
9516
9517 #endif // MICO_CONF_NO_POA
9518
9519 void Components::AssemblyFactory_stub::destroy( Components::Cookie* _par_c )
9520 {
9521 CORBA::StaticAny _sa_c( _marshaller_Components_Cookie, &_par_c );
9522 CORBA::StaticRequest __req( this, "destroy" );
9523 __req.add_in_arg( &_sa_c );
9524
9525 __req.invoke();
9526
9527 mico_sii_throw( &__req,
9528 _marshaller_Components_InvalidAssembly, "IDL:omg.org/Components/InvalidAssembly:1.0",
9529 _marshaller_Components_RemoveFailure, "IDL:omg.org/Components/RemoveFailure:1.0",
9530 0);
9531 }
9532
9533
9534 #ifndef MICO_CONF_NO_POA
9535
9536 void
9537 Components::AssemblyFactory_stub_clp::destroy( Components::Cookie* _par_c )
9538 {
9539 PortableServer::Servant _serv = _preinvoke ();
9540 if (_serv) {
9541 POA_Components::AssemblyFactory * _myserv = POA_Components::AssemblyFactory::_narrow (_serv);
9542 if (_myserv) {
9543 Components::Cookie* _copy_of_par_c;
9544 _copy_of_par_c = Components::Cookie::_downcast (_par_c->_copy_value());
9545 #ifdef HAVE_EXCEPTIONS
9546 try {
9547 #endif
9548 _myserv->destroy(_copy_of_par_c);
9549 #ifdef HAVE_EXCEPTIONS
9550 }
9551 catch (...) {
9552 _myserv->_remove_ref();
9553 _postinvoke();
9554 throw;
9555 }
9556 #endif
9557
9558 _myserv->_remove_ref();
9559 _postinvoke ();
9560 CORBA::remove_ref (_copy_of_par_c);
9561 return;
9562 }
9563 _postinvoke ();
9564 }
9565
9566 Components::AssemblyFactory_stub::destroy(_par_c);
9567 }
9568
9569 #endif // MICO_CONF_NO_POA
9570
9571
9572
9573
9574 Components::ServerActivator::~ServerActivator()
9575 {
9576 }
9577
9578 void *
9579 Components::ServerActivator::_narrow_helper( const char *_repoid )
9580 {
9581 if( strcmp( _repoid, "IDL:omg.org/Components/ServerActivator:1.0" ) == 0 )
9582 return (void *)this;
9583 return NULL;
9584 }
9585
9586 Components::ServerActivator_ptr
9587 Components::ServerActivator::_narrow( CORBA::Object_ptr _obj )
9588 {
9589 Components::ServerActivator_ptr _o;
9590 if( !CORBA::is_nil( _obj ) ) {
9591 void *_p;
9592 if( (_p = _obj->_narrow_helper( "IDL:omg.org/Components/ServerActivator:1.0" )))
9593 return _duplicate( (Components::ServerActivator_ptr) _p );
9594 if (!strcmp (_obj->_repoid(), "IDL:omg.org/Components/ServerActivator:1.0") || _obj->_is_a_remote ("IDL:omg.org/Components/ServerActivator:1.0")) {
9595 _o = new Components::ServerActivator_stub;
9596 _o->CORBA::Object::operator=( *_obj );
9597 return _o;
9598 }
9599 }
9600 return _nil();
9601 }
9602
9603 Components::ServerActivator_ptr
9604 Components::ServerActivator::_narrow( CORBA::AbstractBase_ptr _obj )
9605 {
9606 return _narrow (_obj->_to_object());
9607 }
9608
9609 class _Marshaller_Components_ServerActivator : public ::CORBA::StaticTypeInfo {
9610 typedef Components::ServerActivator_ptr _MICO_T;
9611 public:
9612 StaticValueType create () const;
9613 void assign (StaticValueType dst, const StaticValueType src) const;
9614 void free (StaticValueType) const;
9615 void release (StaticValueType) const;
9616 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
9617 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
9618 };
9619
9620
9621 ::CORBA::StaticValueType _Marshaller_Components_ServerActivator::create() const
9622 {
9623 return (StaticValueType) new _MICO_T( 0 );
9624 }
9625
9626 void _Marshaller_Components_ServerActivator::assign( StaticValueType d, const StaticValueType s ) const
9627 {
9628 *(_MICO_T*) d = ::Components::ServerActivator::_duplicate( *(_MICO_T*) s );
9629 }
9630
9631 void _Marshaller_Components_ServerActivator::free( StaticValueType v ) const
9632 {
9633 ::CORBA::release( *(_MICO_T *) v );
9634 delete (_MICO_T*) v;
9635 }
9636
9637 void _Marshaller_Components_ServerActivator::release( StaticValueType v ) const
9638 {
9639 ::CORBA::release( *(_MICO_T *) v );
9640 }
9641
9642 ::CORBA::Boolean _Marshaller_Components_ServerActivator::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
9643 {
9644 ::CORBA::Object_ptr obj;
9645 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
9646 return FALSE;
9647 *(_MICO_T *) v = ::Components::ServerActivator::_narrow( obj );
9648 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
9649 ::CORBA::release (obj);
9650 return ret;
9651 }
9652
9653 void _Marshaller_Components_ServerActivator::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
9654 {
9655 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
9656 ::CORBA::_stc_Object->marshal( ec, &obj );
9657 }
9658
9659 ::CORBA::StaticTypeInfo *_marshaller_Components_ServerActivator;
9660
9661
9662
9663
9664 Components::ServerActivator_stub::~ServerActivator_stub()
9665 {
9666 }
9667
9668 #ifndef MICO_CONF_NO_POA
9669
9670 void *
9671 POA_Components::ServerActivator::_narrow_helper (const char * repoid)
9672 {
9673 if (strcmp (repoid, "IDL:omg.org/Components/ServerActivator:1.0") == 0) {
9674 return (void *) this;
9675 }
9676 return NULL;
9677 }
9678
9679 POA_Components::ServerActivator *
9680 POA_Components::ServerActivator::_narrow (PortableServer::Servant serv)
9681 {
9682 void * p;
9683 if ((p = serv->_narrow_helper ("IDL:omg.org/Components/ServerActivator:1.0")) != NULL) {
9684 serv->_add_ref ();
9685 return (POA_Components::ServerActivator *) p;
9686 }
9687 return NULL;
9688 }
9689
9690 Components::ServerActivator_stub_clp::ServerActivator_stub_clp ()
9691 {
9692 }
9693
9694 Components::ServerActivator_stub_clp::ServerActivator_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
9695 : CORBA::Object(*obj), PortableServer::StubBase(poa)
9696 {
9697 }
9698
9699 Components::ServerActivator_stub_clp::~ServerActivator_stub_clp ()
9700 {
9701 }
9702
9703 #endif // MICO_CONF_NO_POA
9704
9705 Components::ComponentServer_ptr Components::ServerActivator_stub::create_component_server( const Components::ConfigValues& _par_config )
9706 {
9707 CORBA::StaticAny _sa_config( _marshaller__seq_Components_ConfigValue, &_par_config );
9708 Components::ComponentServer_ptr _res;
9709 CORBA::StaticAny __res( _marshaller_Components_ComponentServer, &_res );
9710
9711 CORBA::StaticRequest __req( this, "create_component_server" );
9712 __req.add_in_arg( &_sa_config );
9713 __req.set_result( &__res );
9714
9715 __req.invoke();
9716
9717 mico_sii_throw( &__req,
9718 _marshaller_Components_CreateFailure, "IDL:omg.org/Components/CreateFailure:1.0",
9719 _marshaller_Components_InvalidConfiguration, "IDL:omg.org/Components/InvalidConfiguration:1.0",
9720 0);
9721 return _res;
9722 }
9723
9724
9725 #ifndef MICO_CONF_NO_POA
9726
9727 Components::ComponentServer_ptr
9728 Components::ServerActivator_stub_clp::create_component_server( const Components::ConfigValues& _par_config )
9729 {
9730 return Components::ServerActivator_stub::create_component_server(_par_config);
9731 }
9732
9733 #endif // MICO_CONF_NO_POA
9734
9735 void Components::ServerActivator_stub::remove_component_server( Components::ComponentServer_ptr _par_server )
9736 {
9737 CORBA::StaticAny _sa_server( _marshaller_Components_ComponentServer, &_par_server );
9738 CORBA::StaticRequest __req( this, "remove_component_server" );
9739 __req.add_in_arg( &_sa_server );
9740
9741 __req.invoke();
9742
9743 mico_sii_throw( &__req,
9744 _marshaller_Components_RemoveFailure, "IDL:omg.org/Components/RemoveFailure:1.0",
9745 0);
9746 }
9747
9748
9749 #ifndef MICO_CONF_NO_POA
9750
9751 void
9752 Components::ServerActivator_stub_clp::remove_component_server( Components::ComponentServer_ptr _par_server )
9753 {
9754 PortableServer::Servant _serv = _preinvoke ();
9755 if (_serv) {
9756 POA_Components::ServerActivator * _myserv = POA_Components::ServerActivator::_narrow (_serv);
9757 if (_myserv) {
9758 #ifdef HAVE_EXCEPTIONS
9759 try {
9760 #endif
9761 _myserv->remove_component_server(_par_server);
9762 #ifdef HAVE_EXCEPTIONS
9763 }
9764 catch (...) {
9765 _myserv->_remove_ref();
9766 _postinvoke();
9767 throw;
9768 }
9769 #endif
9770
9771 _myserv->_remove_ref();
9772 _postinvoke ();
9773 return;
9774 }
9775 _postinvoke ();
9776 }
9777
9778 Components::ServerActivator_stub::remove_component_server(_par_server);
9779 }
9780
9781 #endif // MICO_CONF_NO_POA
9782
9783 Components::ComponentServers* Components::ServerActivator_stub::get_component_servers()
9784 {
9785 CORBA::StaticAny __res( _marshaller__seq_Components_ComponentServer );
9786
9787 CORBA::StaticRequest __req( this, "get_component_servers" );
9788 __req.set_result( &__res );
9789
9790 __req.invoke();
9791
9792 mico_sii_throw( &__req,
9793 0);
9794 return (Components::ComponentServers*) __res._retn();
9795 }
9796
9797
9798 #ifndef MICO_CONF_NO_POA
9799
9800 Components::ComponentServers*
9801 Components::ServerActivator_stub_clp::get_component_servers()
9802 {
9803 PortableServer::Servant _serv = _preinvoke ();
9804 if (_serv) {
9805 POA_Components::ServerActivator * _myserv = POA_Components::ServerActivator::_narrow (_serv);
9806 if (_myserv) {
9807 Components::ComponentServers* __res;
9808
9809 #ifdef HAVE_EXCEPTIONS
9810 try {
9811 #endif
9812 __res = _myserv->get_component_servers();
9813 #ifdef HAVE_EXCEPTIONS
9814 }
9815 catch (...) {
9816 _myserv->_remove_ref();
9817 _postinvoke();
9818 throw;
9819 }
9820 #endif
9821
9822 _myserv->_remove_ref();
9823 _postinvoke ();
9824 return __res;
9825 }
9826 _postinvoke ();
9827 }
9828
9829 return Components::ServerActivator_stub::get_component_servers();
9830 }
9831
9832 #endif // MICO_CONF_NO_POA
9833
9834
9835
9836
9837 MICOCCM::MicoCCMD::~MicoCCMD()
9838 {
9839 }
9840
9841 void *
9842 MICOCCM::MicoCCMD::_narrow_helper( const char *_repoid )
9843 {
9844 if( strcmp( _repoid, "IDL:mico.org/MICOCCM/MicoCCMD:1.0" ) == 0 )
9845 return (void *)this;
9846 {
9847 void *_p;
9848 if ((_p = Components::ServerActivator::_narrow_helper( _repoid )))
9849 return _p;
9850 }
9851 {
9852 void *_p;
9853 if ((_p = Components::ComponentInstallation::_narrow_helper( _repoid )))
9854 return _p;
9855 }
9856 {
9857 void *_p;
9858 if ((_p = Components::AssemblyFactory::_narrow_helper( _repoid )))
9859 return _p;
9860 }
9861 return NULL;
9862 }
9863
9864 MICOCCM::MicoCCMD_ptr
9865 MICOCCM::MicoCCMD::_narrow( CORBA::Object_ptr _obj )
9866 {
9867 MICOCCM::MicoCCMD_ptr _o;
9868 if( !CORBA::is_nil( _obj ) ) {
9869 void *_p;
9870 if( (_p = _obj->_narrow_helper( "IDL:mico.org/MICOCCM/MicoCCMD:1.0" )))
9871 return _duplicate( (MICOCCM::MicoCCMD_ptr) _p );
9872 if (!strcmp (_obj->_repoid(), "IDL:mico.org/MICOCCM/MicoCCMD:1.0") || _obj->_is_a_remote ("IDL:mico.org/MICOCCM/MicoCCMD:1.0")) {
9873 _o = new MICOCCM::MicoCCMD_stub;
9874 _o->CORBA::Object::operator=( *_obj );
9875 return _o;
9876 }
9877 }
9878 return _nil();
9879 }
9880
9881 MICOCCM::MicoCCMD_ptr
9882 MICOCCM::MicoCCMD::_narrow( CORBA::AbstractBase_ptr _obj )
9883 {
9884 return _narrow (_obj->_to_object());
9885 }
9886
9887 class _Marshaller_MICOCCM_MicoCCMD : public ::CORBA::StaticTypeInfo {
9888 typedef MICOCCM::MicoCCMD_ptr _MICO_T;
9889 public:
9890 StaticValueType create () const;
9891 void assign (StaticValueType dst, const StaticValueType src) const;
9892 void free (StaticValueType) const;
9893 void release (StaticValueType) const;
9894 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
9895 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
9896 };
9897
9898
9899 ::CORBA::StaticValueType _Marshaller_MICOCCM_MicoCCMD::create() const
9900 {
9901 return (StaticValueType) new _MICO_T( 0 );
9902 }
9903
9904 void _Marshaller_MICOCCM_MicoCCMD::assign( StaticValueType d, const StaticValueType s ) const
9905 {
9906 *(_MICO_T*) d = ::MICOCCM::MicoCCMD::_duplicate( *(_MICO_T*) s );
9907 }
9908
9909 void _Marshaller_MICOCCM_MicoCCMD::free( StaticValueType v ) const
9910 {
9911 ::CORBA::release( *(_MICO_T *) v );
9912 delete (_MICO_T*) v;
9913 }
9914
9915 void _Marshaller_MICOCCM_MicoCCMD::release( StaticValueType v ) const
9916 {
9917 ::CORBA::release( *(_MICO_T *) v );
9918 }
9919
9920 ::CORBA::Boolean _Marshaller_MICOCCM_MicoCCMD::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
9921 {
9922 ::CORBA::Object_ptr obj;
9923 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
9924 return FALSE;
9925 *(_MICO_T *) v = ::MICOCCM::MicoCCMD::_narrow( obj );
9926 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
9927 ::CORBA::release (obj);
9928 return ret;
9929 }
9930
9931 void _Marshaller_MICOCCM_MicoCCMD::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
9932 {
9933 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
9934 ::CORBA::_stc_Object->marshal( ec, &obj );
9935 }
9936
9937 ::CORBA::StaticTypeInfo *_marshaller_MICOCCM_MicoCCMD;
9938
9939
9940
9941
9942 MICOCCM::MicoCCMD_stub::~MicoCCMD_stub()
9943 {
9944 }
9945
9946 #ifndef MICO_CONF_NO_POA
9947
9948 void *
9949 POA_MICOCCM::MicoCCMD::_narrow_helper (const char * repoid)
9950 {
9951 void * p;
9952 if (strcmp (repoid, "IDL:mico.org/MICOCCM/MicoCCMD:1.0") == 0) {
9953 return (void *) this;
9954 }
9955 if ((p = POA_Components::ServerActivator::_narrow_helper (repoid)) != NULL)
9956 {
9957 return p;
9958 }
9959 if ((p = POA_Components::ComponentInstallation::_narrow_helper (repoid)) != NULL)
9960 {
9961 return p;
9962 }
9963 if ((p = POA_Components::AssemblyFactory::_narrow_helper (repoid)) != NULL)
9964 {
9965 return p;
9966 }
9967 return NULL;
9968 }
9969
9970 POA_MICOCCM::MicoCCMD *
9971 POA_MICOCCM::MicoCCMD::_narrow (PortableServer::Servant serv)
9972 {
9973 void * p;
9974 if ((p = serv->_narrow_helper ("IDL:mico.org/MICOCCM/MicoCCMD:1.0")) != NULL) {
9975 serv->_add_ref ();
9976 return (POA_MICOCCM::MicoCCMD *) p;
9977 }
9978 return NULL;
9979 }
9980
9981 MICOCCM::MicoCCMD_stub_clp::MicoCCMD_stub_clp ()
9982 {
9983 }
9984
9985 MICOCCM::MicoCCMD_stub_clp::MicoCCMD_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
9986 : CORBA::Object(*obj), PortableServer::StubBase(poa)
9987 {
9988 }
9989
9990 MICOCCM::MicoCCMD_stub_clp::~MicoCCMD_stub_clp ()
9991 {
9992 }
9993
9994 #endif // MICO_CONF_NO_POA
9995
9996 CORBA::Object_ptr MICOCCM::MicoCCMD_stub::exec( const char* _par_prog, const Components::NameList& _par_args, const char* _par_iorfile )
9997 {
9998 CORBA::StaticAny _sa_prog( CORBA::_stc_string, &_par_prog );
9999 CORBA::StaticAny _sa_args( CORBA::_stcseq_string, &_par_args );
10000 CORBA::StaticAny _sa_iorfile( CORBA::_stc_string, &_par_iorfile );
10001 CORBA::Object_ptr _res;
10002 CORBA::StaticAny __res( CORBA::_stc_Object, &_res );
10003
10004 CORBA::StaticRequest __req( this, "exec" );
10005 __req.add_in_arg( &_sa_prog );
10006 __req.add_in_arg( &_sa_args );
10007 __req.add_in_arg( &_sa_iorfile );
10008 __req.set_result( &__res );
10009
10010 __req.invoke();
10011
10012 mico_sii_throw( &__req,
10013 _marshaller_Components_CreateFailure, "IDL:omg.org/Components/CreateFailure:1.0",
10014 0);
10015 return _res;
10016 }
10017
10018
10019 #ifndef MICO_CONF_NO_POA
10020
10021 CORBA::Object_ptr
10022 MICOCCM::MicoCCMD_stub_clp::exec( const char* _par_prog, const Components::NameList& _par_args, const char* _par_iorfile )
10023 {
10024 PortableServer::Servant _serv = _preinvoke ();
10025 if (_serv) {
10026 POA_MICOCCM::MicoCCMD * _myserv = POA_MICOCCM::MicoCCMD::_narrow (_serv);
10027 if (_myserv) {
10028 CORBA::Object_ptr __res;
10029
10030 #ifdef HAVE_EXCEPTIONS
10031 try {
10032 #endif
10033 __res = _myserv->exec(_par_prog, _par_args, _par_iorfile);
10034 #ifdef HAVE_EXCEPTIONS
10035 }
10036 catch (...) {
10037 _myserv->_remove_ref();
10038 _postinvoke();
10039 throw;
10040 }
10041 #endif
10042
10043 _myserv->_remove_ref();
10044 _postinvoke ();
10045 return __res;
10046 }
10047 _postinvoke ();
10048 }
10049
10050 return MICOCCM::MicoCCMD_stub::exec(_par_prog, _par_args, _par_iorfile);
10051 }
10052
10053 #endif // MICO_CONF_NO_POA
10054
10055 void MICOCCM::MicoCCMD_stub::callback( const char* _par_token, CORBA::Object_ptr _par_csref )
10056 {
10057 CORBA::StaticAny _sa_token( CORBA::_stc_string, &_par_token );
10058 CORBA::StaticAny _sa_csref( CORBA::_stc_Object, &_par_csref );
10059 CORBA::StaticRequest __req( this, "callback" );
10060 __req.add_in_arg( &_sa_token );
10061 __req.add_in_arg( &_sa_csref );
10062
10063 __req.invoke();
10064
10065 mico_sii_throw( &__req,
10066 0);
10067 }
10068
10069
10070 #ifndef MICO_CONF_NO_POA
10071
10072 void
10073 MICOCCM::MicoCCMD_stub_clp::callback( const char* _par_token, CORBA::Object_ptr _par_csref )
10074 {
10075 PortableServer::Servant _serv = _preinvoke ();
10076 if (_serv) {
10077 POA_MICOCCM::MicoCCMD * _myserv = POA_MICOCCM::MicoCCMD::_narrow (_serv);
10078 if (_myserv) {
10079 #ifdef HAVE_EXCEPTIONS
10080 try {
10081 #endif
10082 _myserv->callback(_par_token, _par_csref);
10083 #ifdef HAVE_EXCEPTIONS
10084 }
10085 catch (...) {
10086 _myserv->_remove_ref();
10087 _postinvoke();
10088 throw;
10089 }
10090 #endif
10091
10092 _myserv->_remove_ref();
10093 _postinvoke ();
10094 return;
10095 }
10096 _postinvoke ();
10097 }
10098
10099 MICOCCM::MicoCCMD_stub::callback(_par_token, _par_csref);
10100 }
10101
10102 #endif // MICO_CONF_NO_POA
10103
10104
10105
10106
10107 MICOCCM::ComponentServer::~ComponentServer()
10108 {
10109 }
10110
10111 void *
10112 MICOCCM::ComponentServer::_narrow_helper( const char *_repoid )
10113 {
10114 if( strcmp( _repoid, "IDL:mico.org/MICOCCM/ComponentServer:1.0" ) == 0 )
10115 return (void *)this;
10116 {
10117 void *_p;
10118 if ((_p = Components::ComponentServer::_narrow_helper( _repoid )))
10119 return _p;
10120 }
10121 return NULL;
10122 }
10123
10124 MICOCCM::ComponentServer_ptr
10125 MICOCCM::ComponentServer::_narrow( CORBA::Object_ptr _obj )
10126 {
10127 MICOCCM::ComponentServer_ptr _o;
10128 if( !CORBA::is_nil( _obj ) ) {
10129 void *_p;
10130 if( (_p = _obj->_narrow_helper( "IDL:mico.org/MICOCCM/ComponentServer:1.0" )))
10131 return _duplicate( (MICOCCM::ComponentServer_ptr) _p );
10132 if (!strcmp (_obj->_repoid(), "IDL:mico.org/MICOCCM/ComponentServer:1.0") || _obj->_is_a_remote ("IDL:mico.org/MICOCCM/ComponentServer:1.0")) {
10133 _o = new MICOCCM::ComponentServer_stub;
10134 _o->CORBA::Object::operator=( *_obj );
10135 return _o;
10136 }
10137 }
10138 return _nil();
10139 }
10140
10141 MICOCCM::ComponentServer_ptr
10142 MICOCCM::ComponentServer::_narrow( CORBA::AbstractBase_ptr _obj )
10143 {
10144 return _narrow (_obj->_to_object());
10145 }
10146
10147 class _Marshaller_MICOCCM_ComponentServer : public ::CORBA::StaticTypeInfo {
10148 typedef MICOCCM::ComponentServer_ptr _MICO_T;
10149 public:
10150 StaticValueType create () const;
10151 void assign (StaticValueType dst, const StaticValueType src) const;
10152 void free (StaticValueType) const;
10153 void release (StaticValueType) const;
10154 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10155 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10156 };
10157
10158
10159 ::CORBA::StaticValueType _Marshaller_MICOCCM_ComponentServer::create() const
10160 {
10161 return (StaticValueType) new _MICO_T( 0 );
10162 }
10163
10164 void _Marshaller_MICOCCM_ComponentServer::assign( StaticValueType d, const StaticValueType s ) const
10165 {
10166 *(_MICO_T*) d = ::MICOCCM::ComponentServer::_duplicate( *(_MICO_T*) s );
10167 }
10168
10169 void _Marshaller_MICOCCM_ComponentServer::free( StaticValueType v ) const
10170 {
10171 ::CORBA::release( *(_MICO_T *) v );
10172 delete (_MICO_T*) v;
10173 }
10174
10175 void _Marshaller_MICOCCM_ComponentServer::release( StaticValueType v ) const
10176 {
10177 ::CORBA::release( *(_MICO_T *) v );
10178 }
10179
10180 ::CORBA::Boolean _Marshaller_MICOCCM_ComponentServer::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10181 {
10182 ::CORBA::Object_ptr obj;
10183 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
10184 return FALSE;
10185 *(_MICO_T *) v = ::MICOCCM::ComponentServer::_narrow( obj );
10186 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
10187 ::CORBA::release (obj);
10188 return ret;
10189 }
10190
10191 void _Marshaller_MICOCCM_ComponentServer::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
10192 {
10193 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
10194 ::CORBA::_stc_Object->marshal( ec, &obj );
10195 }
10196
10197 ::CORBA::StaticTypeInfo *_marshaller_MICOCCM_ComponentServer;
10198
10199
10200
10201
10202 MICOCCM::ComponentServer_stub::~ComponentServer_stub()
10203 {
10204 }
10205
10206 #ifndef MICO_CONF_NO_POA
10207
10208 void *
10209 POA_MICOCCM::ComponentServer::_narrow_helper (const char * repoid)
10210 {
10211 void * p;
10212 if (strcmp (repoid, "IDL:mico.org/MICOCCM/ComponentServer:1.0") == 0) {
10213 return (void *) this;
10214 }
10215 if ((p = POA_Components::ComponentServer::_narrow_helper (repoid)) != NULL)
10216 {
10217 return p;
10218 }
10219 return NULL;
10220 }
10221
10222 POA_MICOCCM::ComponentServer *
10223 POA_MICOCCM::ComponentServer::_narrow (PortableServer::Servant serv)
10224 {
10225 void * p;
10226 if ((p = serv->_narrow_helper ("IDL:mico.org/MICOCCM/ComponentServer:1.0")) != NULL) {
10227 serv->_add_ref ();
10228 return (POA_MICOCCM::ComponentServer *) p;
10229 }
10230 return NULL;
10231 }
10232
10233 MICOCCM::ComponentServer_stub_clp::ComponentServer_stub_clp ()
10234 {
10235 }
10236
10237 MICOCCM::ComponentServer_stub_clp::ComponentServer_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
10238 : CORBA::Object(*obj), PortableServer::StubBase(poa)
10239 {
10240 }
10241
10242 MICOCCM::ComponentServer_stub_clp::~ComponentServer_stub_clp ()
10243 {
10244 }
10245
10246 #endif // MICO_CONF_NO_POA
10247
10248 void MICOCCM::ComponentServer_stub::set_config_values( const Components::ConfigValues& _par_config )
10249 {
10250 CORBA::StaticAny _sa_config( _marshaller__seq_Components_ConfigValue, &_par_config );
10251 CORBA::StaticRequest __req( this, "set_config_values" );
10252 __req.add_in_arg( &_sa_config );
10253
10254 __req.invoke();
10255
10256 mico_sii_throw( &__req,
10257 0);
10258 }
10259
10260
10261 #ifndef MICO_CONF_NO_POA
10262
10263 void
10264 MICOCCM::ComponentServer_stub_clp::set_config_values( const Components::ConfigValues& _par_config )
10265 {
10266 MICOCCM::ComponentServer_stub::set_config_values(_par_config);
10267 }
10268
10269 #endif // MICO_CONF_NO_POA
10270
10271
10272
10273
10274 HPI::HomeFinder::~HomeFinder()
10275 {
10276 }
10277
10278 void *
10279 HPI::HomeFinder::_narrow_helper( const char *_repoid )
10280 {
10281 if( strcmp( _repoid, "IDL:HPI/HomeFinder:1.0" ) == 0 )
10282 return (void *)this;
10283 {
10284 void *_p;
10285 if ((_p = Components::HomeFinder::_narrow_helper( _repoid )))
10286 return _p;
10287 }
10288 return NULL;
10289 }
10290
10291 HPI::HomeFinder_ptr
10292 HPI::HomeFinder::_narrow( CORBA::Object_ptr _obj )
10293 {
10294 HPI::HomeFinder_ptr _o;
10295 if( !CORBA::is_nil( _obj ) ) {
10296 void *_p;
10297 if( (_p = _obj->_narrow_helper( "IDL:HPI/HomeFinder:1.0" )))
10298 return _duplicate( (HPI::HomeFinder_ptr) _p );
10299 if (!strcmp (_obj->_repoid(), "IDL:HPI/HomeFinder:1.0") || _obj->_is_a_remote ("IDL:HPI/HomeFinder:1.0")) {
10300 _o = new HPI::HomeFinder_stub;
10301 _o->CORBA::Object::operator=( *_obj );
10302 return _o;
10303 }
10304 }
10305 return _nil();
10306 }
10307
10308 HPI::HomeFinder_ptr
10309 HPI::HomeFinder::_narrow( CORBA::AbstractBase_ptr _obj )
10310 {
10311 return _narrow (_obj->_to_object());
10312 }
10313
10314 class _Marshaller_HPI_HomeFinder : public ::CORBA::StaticTypeInfo {
10315 typedef HPI::HomeFinder_ptr _MICO_T;
10316 public:
10317 StaticValueType create () const;
10318 void assign (StaticValueType dst, const StaticValueType src) const;
10319 void free (StaticValueType) const;
10320 void release (StaticValueType) const;
10321 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10322 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10323 };
10324
10325
10326 ::CORBA::StaticValueType _Marshaller_HPI_HomeFinder::create() const
10327 {
10328 return (StaticValueType) new _MICO_T( 0 );
10329 }
10330
10331 void _Marshaller_HPI_HomeFinder::assign( StaticValueType d, const StaticValueType s ) const
10332 {
10333 *(_MICO_T*) d = ::HPI::HomeFinder::_duplicate( *(_MICO_T*) s );
10334 }
10335
10336 void _Marshaller_HPI_HomeFinder::free( StaticValueType v ) const
10337 {
10338 ::CORBA::release( *(_MICO_T *) v );
10339 delete (_MICO_T*) v;
10340 }
10341
10342 void _Marshaller_HPI_HomeFinder::release( StaticValueType v ) const
10343 {
10344 ::CORBA::release( *(_MICO_T *) v );
10345 }
10346
10347 ::CORBA::Boolean _Marshaller_HPI_HomeFinder::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10348 {
10349 ::CORBA::Object_ptr obj;
10350 if (!::CORBA::_stc_Object->demarshal(dc, &obj))
10351 return FALSE;
10352 *(_MICO_T *) v = ::HPI::HomeFinder::_narrow( obj );
10353 ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
10354 ::CORBA::release (obj);
10355 return ret;
10356 }
10357
10358 void _Marshaller_HPI_HomeFinder::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
10359 {
10360 ::CORBA::Object_ptr obj = *(_MICO_T *) v;
10361 ::CORBA::_stc_Object->marshal( ec, &obj );
10362 }
10363
10364 ::CORBA::StaticTypeInfo *_marshaller_HPI_HomeFinder;
10365
10366
10367
10368
10369 HPI::HomeFinder_stub::~HomeFinder_stub()
10370 {
10371 }
10372
10373 #ifndef MICO_CONF_NO_POA
10374
10375 void *
10376 POA_HPI::HomeFinder::_narrow_helper (const char * repoid)
10377 {
10378 void * p;
10379 if (strcmp (repoid, "IDL:HPI/HomeFinder:1.0") == 0) {
10380 return (void *) this;
10381 }
10382 if ((p = POA_Components::HomeFinder::_narrow_helper (repoid)) != NULL)
10383 {
10384 return p;
10385 }
10386 return NULL;
10387 }
10388
10389 POA_HPI::HomeFinder *
10390 POA_HPI::HomeFinder::_narrow (PortableServer::Servant serv)
10391 {
10392 void * p;
10393 if ((p = serv->_narrow_helper ("IDL:HPI/HomeFinder:1.0")) != NULL) {
10394 serv->_add_ref ();
10395 return (POA_HPI::HomeFinder *) p;
10396 }
10397 return NULL;
10398 }
10399
10400 HPI::HomeFinder_stub_clp::HomeFinder_stub_clp ()
10401 {
10402 }
10403
10404 HPI::HomeFinder_stub_clp::HomeFinder_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
10405 : CORBA::Object(*obj), PortableServer::StubBase(poa)
10406 {
10407 }
10408
10409 HPI::HomeFinder_stub_clp::~HomeFinder_stub_clp ()
10410 {
10411 }
10412
10413 #endif // MICO_CONF_NO_POA
10414
10415 CORBA::Long HPI::HomeFinder_stub::_cxx_register( const char* _par_comp_repid, const char* _par_home_repid, Components::CCMHome_ptr _par_the_home )
10416 {
10417 CORBA::StaticAny _sa_comp_repid( CORBA::_stc_string, &_par_comp_repid );
10418 CORBA::StaticAny _sa_home_repid( CORBA::_stc_string, &_par_home_repid );
10419 CORBA::StaticAny _sa_the_home( _marshaller_Components_CCMHome, &_par_the_home );
10420 CORBA::Long _res;
10421 CORBA::StaticAny __res( CORBA::_stc_long, &_res );
10422
10423 CORBA::StaticRequest __req( this, "register" );
10424 __req.add_in_arg( &_sa_comp_repid );
10425 __req.add_in_arg( &_sa_home_repid );
10426 __req.add_in_arg( &_sa_the_home );
10427 __req.set_result( &__res );
10428
10429 __req.invoke();
10430
10431 mico_sii_throw( &__req,
10432 0);
10433 return _res;
10434 }
10435
10436
10437 #ifndef MICO_CONF_NO_POA
10438
10439 CORBA::Long
10440 HPI::HomeFinder_stub_clp::_cxx_register( const char* _par_comp_repid, const char* _par_home_repid, Components::CCMHome_ptr _par_the_home )
10441 {
10442 PortableServer::Servant _serv = _preinvoke ();
10443 if (_serv) {
10444 POA_HPI::HomeFinder * _myserv = POA_HPI::HomeFinder::_narrow (_serv);
10445 if (_myserv) {
10446 CORBA::Long __res;
10447
10448 #ifdef HAVE_EXCEPTIONS
10449 try {
10450 #endif
10451 __res = _myserv->_cxx_register(_par_comp_repid, _par_home_repid, _par_the_home);
10452 #ifdef HAVE_EXCEPTIONS
10453 }
10454 catch (...) {
10455 _myserv->_remove_ref();
10456 _postinvoke();
10457 throw;
10458 }
10459 #endif
10460
10461 _myserv->_remove_ref();
10462 _postinvoke ();
10463 return __res;
10464 }
10465 _postinvoke ();
10466 }
10467
10468 return HPI::HomeFinder_stub::_cxx_register(_par_comp_repid, _par_home_repid, _par_the_home);
10469 }
10470
10471 #endif // MICO_CONF_NO_POA
10472
10473 void HPI::HomeFinder_stub::unregister( CORBA::Long _par_cookie )
10474 {
10475 CORBA::StaticAny _sa_cookie( CORBA::_stc_long, &_par_cookie );
10476 CORBA::StaticRequest __req( this, "unregister" );
10477 __req.add_in_arg( &_sa_cookie );
10478
10479 __req.invoke();
10480
10481 mico_sii_throw( &__req,
10482 _marshaller_Components_HomeNotFound, "IDL:omg.org/Components/HomeNotFound:1.0",
10483 0);
10484 }
10485
10486
10487 #ifndef MICO_CONF_NO_POA
10488
10489 void
10490 HPI::HomeFinder_stub_clp::unregister( CORBA::Long _par_cookie )
10491 {
10492 PortableServer::Servant _serv = _preinvoke ();
10493 if (_serv) {
10494 POA_HPI::HomeFinder * _myserv = POA_HPI::HomeFinder::_narrow (_serv);
10495 if (_myserv) {
10496 #ifdef HAVE_EXCEPTIONS
10497 try {
10498 #endif
10499 _myserv->unregister(_par_cookie);
10500 #ifdef HAVE_EXCEPTIONS
10501 }
10502 catch (...) {
10503 _myserv->_remove_ref();
10504 _postinvoke();
10505 throw;
10506 }
10507 #endif
10508
10509 _myserv->_remove_ref();
10510 _postinvoke ();
10511 return;
10512 }
10513 _postinvoke ();
10514 }
10515
10516 HPI::HomeFinder_stub::unregister(_par_cookie);
10517 }
10518
10519 #endif // MICO_CONF_NO_POA
10520
10521 class _Marshaller__seq_Components_FacetDescription : public ::CORBA::StaticTypeInfo {
10522 typedef SequenceTmpl< Components::FacetDescription_var,MICO_TID_DEF> _MICO_T;
10523 public:
10524 StaticValueType create () const;
10525 void assign (StaticValueType dst, const StaticValueType src) const;
10526 void free (StaticValueType) const;
10527 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10528 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10529 };
10530
10531
10532 ::CORBA::StaticValueType _Marshaller__seq_Components_FacetDescription::create() const
10533 {
10534 return (StaticValueType) new _MICO_T;
10535 }
10536
10537 void _Marshaller__seq_Components_FacetDescription::assign( StaticValueType d, const StaticValueType s ) const
10538 {
10539 *(_MICO_T*) d = *(_MICO_T*) s;
10540 }
10541
10542 void _Marshaller__seq_Components_FacetDescription::free( StaticValueType v ) const
10543 {
10544 delete (_MICO_T*) v;
10545 }
10546
10547 ::CORBA::Boolean _Marshaller__seq_Components_FacetDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10548 {
10549 ::CORBA::ULong len;
10550 if( !dc.seq_begin( len ) )
10551 return FALSE;
10552 ((_MICO_T *) v)->length( len );
10553 for( ::CORBA::ULong i = 0; i < len; i++ ) {
10554 if( !_marshaller_Components_FacetDescription->demarshal( dc, &(*(_MICO_T*)v)[i]._for_demarshal() ) )
10555 return FALSE;
10556 }
10557 return dc.seq_end();
10558 }
10559
10560 void _Marshaller__seq_Components_FacetDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
10561 {
10562 ::CORBA::ULong len = ((_MICO_T *) v)->length();
10563 ec.seq_begin( len );
10564 for( ::CORBA::ULong i = 0; i < len; i++ )
10565 _marshaller_Components_FacetDescription->marshal( ec, &(*(_MICO_T*)v)[i].inout() );
10566 ec.seq_end();
10567 }
10568
10569 ::CORBA::StaticTypeInfo *_marshaller__seq_Components_FacetDescription;
10570
10571 class _Marshaller__seq_Components_ConnectionDescription : public ::CORBA::StaticTypeInfo {
10572 typedef SequenceTmpl< Components::ConnectionDescription_var,MICO_TID_DEF> _MICO_T;
10573 public:
10574 StaticValueType create () const;
10575 void assign (StaticValueType dst, const StaticValueType src) const;
10576 void free (StaticValueType) const;
10577 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10578 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10579 };
10580
10581
10582 ::CORBA::StaticValueType _Marshaller__seq_Components_ConnectionDescription::create() const
10583 {
10584 return (StaticValueType) new _MICO_T;
10585 }
10586
10587 void _Marshaller__seq_Components_ConnectionDescription::assign( StaticValueType d, const StaticValueType s ) const
10588 {
10589 *(_MICO_T*) d = *(_MICO_T*) s;
10590 }
10591
10592 void _Marshaller__seq_Components_ConnectionDescription::free( StaticValueType v ) const
10593 {
10594 delete (_MICO_T*) v;
10595 }
10596
10597 ::CORBA::Boolean _Marshaller__seq_Components_ConnectionDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10598 {
10599 ::CORBA::ULong len;
10600 if( !dc.seq_begin( len ) )
10601 return FALSE;
10602 ((_MICO_T *) v)->length( len );
10603 for( ::CORBA::ULong i = 0; i < len; i++ ) {
10604 if( !_marshaller_Components_ConnectionDescription->demarshal( dc, &(*(_MICO_T*)v)[i]._for_demarshal() ) )
10605 return FALSE;
10606 }
10607 return dc.seq_end();
10608 }
10609
10610 void _Marshaller__seq_Components_ConnectionDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
10611 {
10612 ::CORBA::ULong len = ((_MICO_T *) v)->length();
10613 ec.seq_begin( len );
10614 for( ::CORBA::ULong i = 0; i < len; i++ )
10615 _marshaller_Components_ConnectionDescription->marshal( ec, &(*(_MICO_T*)v)[i].inout() );
10616 ec.seq_end();
10617 }
10618
10619 ::CORBA::StaticTypeInfo *_marshaller__seq_Components_ConnectionDescription;
10620
10621 class _Marshaller__seq_Components_ReceptacleDescription : public ::CORBA::StaticTypeInfo {
10622 typedef SequenceTmpl< Components::ReceptacleDescription_var,MICO_TID_DEF> _MICO_T;
10623 public:
10624 StaticValueType create () const;
10625 void assign (StaticValueType dst, const StaticValueType src) const;
10626 void free (StaticValueType) const;
10627 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10628 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10629 };
10630
10631
10632 ::CORBA::StaticValueType _Marshaller__seq_Components_ReceptacleDescription::create() const
10633 {
10634 return (StaticValueType) new _MICO_T;
10635 }
10636
10637 void _Marshaller__seq_Components_ReceptacleDescription::assign( StaticValueType d, const StaticValueType s ) const
10638 {
10639 *(_MICO_T*) d = *(_MICO_T*) s;
10640 }
10641
10642 void _Marshaller__seq_Components_ReceptacleDescription::free( StaticValueType v ) const
10643 {
10644 delete (_MICO_T*) v;
10645 }
10646
10647 ::CORBA::Boolean _Marshaller__seq_Components_ReceptacleDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10648 {
10649 ::CORBA::ULong len;
10650 if( !dc.seq_begin( len ) )
10651 return FALSE;
10652 ((_MICO_T *) v)->length( len );
10653 for( ::CORBA::ULong i = 0; i < len; i++ ) {
10654 if( !_marshaller_Components_ReceptacleDescription->demarshal( dc, &(*(_MICO_T*)v)[i]._for_demarshal() ) )
10655 return FALSE;
10656 }
10657 return dc.seq_end();
10658 }
10659
10660 void _Marshaller__seq_Components_ReceptacleDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
10661 {
10662 ::CORBA::ULong len = ((_MICO_T *) v)->length();
10663 ec.seq_begin( len );
10664 for( ::CORBA::ULong i = 0; i < len; i++ )
10665 _marshaller_Components_ReceptacleDescription->marshal( ec, &(*(_MICO_T*)v)[i].inout() );
10666 ec.seq_end();
10667 }
10668
10669 ::CORBA::StaticTypeInfo *_marshaller__seq_Components_ReceptacleDescription;
10670
10671 class _Marshaller__seq_Components_ConsumerDescription : public ::CORBA::StaticTypeInfo {
10672 typedef SequenceTmpl< Components::ConsumerDescription_var,MICO_TID_DEF> _MICO_T;
10673 public:
10674 StaticValueType create () const;
10675 void assign (StaticValueType dst, const StaticValueType src) const;
10676 void free (StaticValueType) const;
10677 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10678 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10679 };
10680
10681
10682 ::CORBA::StaticValueType _Marshaller__seq_Components_ConsumerDescription::create() const
10683 {
10684 return (StaticValueType) new _MICO_T;
10685 }
10686
10687 void _Marshaller__seq_Components_ConsumerDescription::assign( StaticValueType d, const StaticValueType s ) const
10688 {
10689 *(_MICO_T*) d = *(_MICO_T*) s;
10690 }
10691
10692 void _Marshaller__seq_Components_ConsumerDescription::free( StaticValueType v ) const
10693 {
10694 delete (_MICO_T*) v;
10695 }
10696
10697 ::CORBA::Boolean _Marshaller__seq_Components_ConsumerDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10698 {
10699 ::CORBA::ULong len;
10700 if( !dc.seq_begin( len ) )
10701 return FALSE;
10702 ((_MICO_T *) v)->length( len );
10703 for( ::CORBA::ULong i = 0; i < len; i++ ) {
10704 if( !_marshaller_Components_ConsumerDescription->demarshal( dc, &(*(_MICO_T*)v)[i]._for_demarshal() ) )
10705 return FALSE;
10706 }
10707 return dc.seq_end();
10708 }
10709
10710 void _Marshaller__seq_Components_ConsumerDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
10711 {
10712 ::CORBA::ULong len = ((_MICO_T *) v)->length();
10713 ec.seq_begin( len );
10714 for( ::CORBA::ULong i = 0; i < len; i++ )
10715 _marshaller_Components_ConsumerDescription->marshal( ec, &(*(_MICO_T*)v)[i].inout() );
10716 ec.seq_end();
10717 }
10718
10719 ::CORBA::StaticTypeInfo *_marshaller__seq_Components_ConsumerDescription;
10720
10721 class _Marshaller__seq_Components_EmitterDescription : public ::CORBA::StaticTypeInfo {
10722 typedef SequenceTmpl< Components::EmitterDescription_var,MICO_TID_DEF> _MICO_T;
10723 public:
10724 StaticValueType create () const;
10725 void assign (StaticValueType dst, const StaticValueType src) const;
10726 void free (StaticValueType) const;
10727 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10728 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10729 };
10730
10731
10732 ::CORBA::StaticValueType _Marshaller__seq_Components_EmitterDescription::create() const
10733 {
10734 return (StaticValueType) new _MICO_T;
10735 }
10736
10737 void _Marshaller__seq_Components_EmitterDescription::assign( StaticValueType d, const StaticValueType s ) const
10738 {
10739 *(_MICO_T*) d = *(_MICO_T*) s;
10740 }
10741
10742 void _Marshaller__seq_Components_EmitterDescription::free( StaticValueType v ) const
10743 {
10744 delete (_MICO_T*) v;
10745 }
10746
10747 ::CORBA::Boolean _Marshaller__seq_Components_EmitterDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10748 {
10749 ::CORBA::ULong len;
10750 if( !dc.seq_begin( len ) )
10751 return FALSE;
10752 ((_MICO_T *) v)->length( len );
10753 for( ::CORBA::ULong i = 0; i < len; i++ ) {
10754 if( !_marshaller_Components_EmitterDescription->demarshal( dc, &(*(_MICO_T*)v)[i]._for_demarshal() ) )
10755 return FALSE;
10756 }
10757 return dc.seq_end();
10758 }
10759
10760 void _Marshaller__seq_Components_EmitterDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
10761 {
10762 ::CORBA::ULong len = ((_MICO_T *) v)->length();
10763 ec.seq_begin( len );
10764 for( ::CORBA::ULong i = 0; i < len; i++ )
10765 _marshaller_Components_EmitterDescription->marshal( ec, &(*(_MICO_T*)v)[i].inout() );
10766 ec.seq_end();
10767 }
10768
10769 ::CORBA::StaticTypeInfo *_marshaller__seq_Components_EmitterDescription;
10770
10771 class _Marshaller__seq_Components_SubscriberDescription : public ::CORBA::StaticTypeInfo {
10772 typedef SequenceTmpl< Components::SubscriberDescription_var,MICO_TID_DEF> _MICO_T;
10773 public:
10774 StaticValueType create () const;
10775 void assign (StaticValueType dst, const StaticValueType src) const;
10776 void free (StaticValueType) const;
10777 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10778 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10779 };
10780
10781
10782 ::CORBA::StaticValueType _Marshaller__seq_Components_SubscriberDescription::create() const
10783 {
10784 return (StaticValueType) new _MICO_T;
10785 }
10786
10787 void _Marshaller__seq_Components_SubscriberDescription::assign( StaticValueType d, const StaticValueType s ) const
10788 {
10789 *(_MICO_T*) d = *(_MICO_T*) s;
10790 }
10791
10792 void _Marshaller__seq_Components_SubscriberDescription::free( StaticValueType v ) const
10793 {
10794 delete (_MICO_T*) v;
10795 }
10796
10797 ::CORBA::Boolean _Marshaller__seq_Components_SubscriberDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10798 {
10799 ::CORBA::ULong len;
10800 if( !dc.seq_begin( len ) )
10801 return FALSE;
10802 ((_MICO_T *) v)->length( len );
10803 for( ::CORBA::ULong i = 0; i < len; i++ ) {
10804 if( !_marshaller_Components_SubscriberDescription->demarshal( dc, &(*(_MICO_T*)v)[i]._for_demarshal() ) )
10805 return FALSE;
10806 }
10807 return dc.seq_end();
10808 }
10809
10810 void _Marshaller__seq_Components_SubscriberDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
10811 {
10812 ::CORBA::ULong len = ((_MICO_T *) v)->length();
10813 ec.seq_begin( len );
10814 for( ::CORBA::ULong i = 0; i < len; i++ )
10815 _marshaller_Components_SubscriberDescription->marshal( ec, &(*(_MICO_T*)v)[i].inout() );
10816 ec.seq_end();
10817 }
10818
10819 ::CORBA::StaticTypeInfo *_marshaller__seq_Components_SubscriberDescription;
10820
10821 class _Marshaller__seq_Components_PublisherDescription : public ::CORBA::StaticTypeInfo {
10822 typedef SequenceTmpl< Components::PublisherDescription_var,MICO_TID_DEF> _MICO_T;
10823 public:
10824 StaticValueType create () const;
10825 void assign (StaticValueType dst, const StaticValueType src) const;
10826 void free (StaticValueType) const;
10827 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10828 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10829 };
10830
10831
10832 ::CORBA::StaticValueType _Marshaller__seq_Components_PublisherDescription::create() const
10833 {
10834 return (StaticValueType) new _MICO_T;
10835 }
10836
10837 void _Marshaller__seq_Components_PublisherDescription::assign( StaticValueType d, const StaticValueType s ) const
10838 {
10839 *(_MICO_T*) d = *(_MICO_T*) s;
10840 }
10841
10842 void _Marshaller__seq_Components_PublisherDescription::free( StaticValueType v ) const
10843 {
10844 delete (_MICO_T*) v;
10845 }
10846
10847 ::CORBA::Boolean _Marshaller__seq_Components_PublisherDescription::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10848 {
10849 ::CORBA::ULong len;
10850 if( !dc.seq_begin( len ) )
10851 return FALSE;
10852 ((_MICO_T *) v)->length( len );
10853 for( ::CORBA::ULong i = 0; i < len; i++ ) {
10854 if( !_marshaller_Components_PublisherDescription->demarshal( dc, &(*(_MICO_T*)v)[i]._for_demarshal() ) )
10855 return FALSE;
10856 }
10857 return dc.seq_end();
10858 }
10859
10860 void _Marshaller__seq_Components_PublisherDescription::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
10861 {
10862 ::CORBA::ULong len = ((_MICO_T *) v)->length();
10863 ec.seq_begin( len );
10864 for( ::CORBA::ULong i = 0; i < len; i++ )
10865 _marshaller_Components_PublisherDescription->marshal( ec, &(*(_MICO_T*)v)[i].inout() );
10866 ec.seq_end();
10867 }
10868
10869 ::CORBA::StaticTypeInfo *_marshaller__seq_Components_PublisherDescription;
10870
10871 class _Marshaller__seq_Components_CCMHome : public ::CORBA::StaticTypeInfo {
10872 typedef IfaceSequenceTmpl< Components::CCMHome_var,Components::CCMHome_ptr> _MICO_T;
10873 public:
10874 StaticValueType create () const;
10875 void assign (StaticValueType dst, const StaticValueType src) const;
10876 void free (StaticValueType) const;
10877 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10878 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10879 };
10880
10881
10882 ::CORBA::StaticValueType _Marshaller__seq_Components_CCMHome::create() const
10883 {
10884 return (StaticValueType) new _MICO_T;
10885 }
10886
10887 void _Marshaller__seq_Components_CCMHome::assign( StaticValueType d, const StaticValueType s ) const
10888 {
10889 *(_MICO_T*) d = *(_MICO_T*) s;
10890 }
10891
10892 void _Marshaller__seq_Components_CCMHome::free( StaticValueType v ) const
10893 {
10894 delete (_MICO_T*) v;
10895 }
10896
10897 ::CORBA::Boolean _Marshaller__seq_Components_CCMHome::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10898 {
10899 ::CORBA::ULong len;
10900 if( !dc.seq_begin( len ) )
10901 return FALSE;
10902 ((_MICO_T *) v)->length( len );
10903 for( ::CORBA::ULong i = 0; i < len; i++ ) {
10904 if( !_marshaller_Components_CCMHome->demarshal( dc, &(*(_MICO_T*)v)[i]._for_demarshal() ) )
10905 return FALSE;
10906 }
10907 return dc.seq_end();
10908 }
10909
10910 void _Marshaller__seq_Components_CCMHome::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
10911 {
10912 ::CORBA::ULong len = ((_MICO_T *) v)->length();
10913 ec.seq_begin( len );
10914 for( ::CORBA::ULong i = 0; i < len; i++ )
10915 _marshaller_Components_CCMHome->marshal( ec, &(*(_MICO_T*)v)[i].inout() );
10916 ec.seq_end();
10917 }
10918
10919 ::CORBA::StaticTypeInfo *_marshaller__seq_Components_CCMHome;
10920
10921 class _Marshaller__seq_Components_ConfigValue : public ::CORBA::StaticTypeInfo {
10922 typedef SequenceTmpl< Components::ConfigValue_var,MICO_TID_DEF> _MICO_T;
10923 public:
10924 StaticValueType create () const;
10925 void assign (StaticValueType dst, const StaticValueType src) const;
10926 void free (StaticValueType) const;
10927 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10928 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10929 };
10930
10931
10932 ::CORBA::StaticValueType _Marshaller__seq_Components_ConfigValue::create() const
10933 {
10934 return (StaticValueType) new _MICO_T;
10935 }
10936
10937 void _Marshaller__seq_Components_ConfigValue::assign( StaticValueType d, const StaticValueType s ) const
10938 {
10939 *(_MICO_T*) d = *(_MICO_T*) s;
10940 }
10941
10942 void _Marshaller__seq_Components_ConfigValue::free( StaticValueType v ) const
10943 {
10944 delete (_MICO_T*) v;
10945 }
10946
10947 ::CORBA::Boolean _Marshaller__seq_Components_ConfigValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10948 {
10949 ::CORBA::ULong len;
10950 if( !dc.seq_begin( len ) )
10951 return FALSE;
10952 ((_MICO_T *) v)->length( len );
10953 for( ::CORBA::ULong i = 0; i < len; i++ ) {
10954 if( !_marshaller_Components_ConfigValue->demarshal( dc, &(*(_MICO_T*)v)[i]._for_demarshal() ) )
10955 return FALSE;
10956 }
10957 return dc.seq_end();
10958 }
10959
10960 void _Marshaller__seq_Components_ConfigValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
10961 {
10962 ::CORBA::ULong len = ((_MICO_T *) v)->length();
10963 ec.seq_begin( len );
10964 for( ::CORBA::ULong i = 0; i < len; i++ )
10965 _marshaller_Components_ConfigValue->marshal( ec, &(*(_MICO_T*)v)[i].inout() );
10966 ec.seq_end();
10967 }
10968
10969 ::CORBA::StaticTypeInfo *_marshaller__seq_Components_ConfigValue;
10970
10971 class _Marshaller__seq_Components_Container : public ::CORBA::StaticTypeInfo {
10972 typedef IfaceSequenceTmpl< Components::Container_var,Components::Container_ptr> _MICO_T;
10973 public:
10974 StaticValueType create () const;
10975 void assign (StaticValueType dst, const StaticValueType src) const;
10976 void free (StaticValueType) const;
10977 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
10978 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
10979 };
10980
10981
10982 ::CORBA::StaticValueType _Marshaller__seq_Components_Container::create() const
10983 {
10984 return (StaticValueType) new _MICO_T;
10985 }
10986
10987 void _Marshaller__seq_Components_Container::assign( StaticValueType d, const StaticValueType s ) const
10988 {
10989 *(_MICO_T*) d = *(_MICO_T*) s;
10990 }
10991
10992 void _Marshaller__seq_Components_Container::free( StaticValueType v ) const
10993 {
10994 delete (_MICO_T*) v;
10995 }
10996
10997 ::CORBA::Boolean _Marshaller__seq_Components_Container::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
10998 {
10999 ::CORBA::ULong len;
11000 if( !dc.seq_begin( len ) )
11001 return FALSE;
11002 ((_MICO_T *) v)->length( len );
11003 for( ::CORBA::ULong i = 0; i < len; i++ ) {
11004 if( !_marshaller_Components_Container->demarshal( dc, &(*(_MICO_T*)v)[i]._for_demarshal() ) )
11005 return FALSE;
11006 }
11007 return dc.seq_end();
11008 }
11009
11010 void _Marshaller__seq_Components_Container::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
11011 {
11012 ::CORBA::ULong len = ((_MICO_T *) v)->length();
11013 ec.seq_begin( len );
11014 for( ::CORBA::ULong i = 0; i < len; i++ )
11015 _marshaller_Components_Container->marshal( ec, &(*(_MICO_T*)v)[i].inout() );
11016 ec.seq_end();
11017 }
11018
11019 ::CORBA::StaticTypeInfo *_marshaller__seq_Components_Container;
11020
11021 class _Marshaller__seq_Components_ComponentServer : public ::CORBA::StaticTypeInfo {
11022 typedef IfaceSequenceTmpl< Components::ComponentServer_var,Components::ComponentServer_ptr> _MICO_T;
11023 public:
11024 StaticValueType create () const;
11025 void assign (StaticValueType dst, const StaticValueType src) const;
11026 void free (StaticValueType) const;
11027 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
11028 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
11029 };
11030
11031
11032 ::CORBA::StaticValueType _Marshaller__seq_Components_ComponentServer::create() const
11033 {
11034 return (StaticValueType) new _MICO_T;
11035 }
11036
11037 void _Marshaller__seq_Components_ComponentServer::assign( StaticValueType d, const StaticValueType s ) const
11038 {
11039 *(_MICO_T*) d = *(_MICO_T*) s;
11040 }
11041
11042 void _Marshaller__seq_Components_ComponentServer::free( StaticValueType v ) const
11043 {
11044 delete (_MICO_T*) v;
11045 }
11046
11047 ::CORBA::Boolean _Marshaller__seq_Components_ComponentServer::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
11048 {
11049 ::CORBA::ULong len;
11050 if( !dc.seq_begin( len ) )
11051 return FALSE;
11052 ((_MICO_T *) v)->length( len );
11053 for( ::CORBA::ULong i = 0; i < len; i++ ) {
11054 if( !_marshaller_Components_ComponentServer->demarshal( dc, &(*(_MICO_T*)v)[i]._for_demarshal() ) )
11055 return FALSE;
11056 }
11057 return dc.seq_end();
11058 }
11059
11060 void _Marshaller__seq_Components_ComponentServer::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
11061 {
11062 ::CORBA::ULong len = ((_MICO_T *) v)->length();
11063 ec.seq_begin( len );
11064 for( ::CORBA::ULong i = 0; i < len; i++ )
11065 _marshaller_Components_ComponentServer->marshal( ec, &(*(_MICO_T*)v)[i].inout() );
11066 ec.seq_end();
11067 }
11068
11069 ::CORBA::StaticTypeInfo *_marshaller__seq_Components_ComponentServer;
11070
11071 struct __tc_init_HOME {
11072 __tc_init_HOME()
11073 {
11074 _marshaller_Components_InvalidName = new _Marshaller_Components_InvalidName;
11075 _marshaller_Components_InvalidConfiguration = new _Marshaller_Components_InvalidConfiguration;
11076 _marshaller_Components_AlreadyConnected = new _Marshaller_Components_AlreadyConnected;
11077 _marshaller_Components_InvalidConnection = new _Marshaller_Components_InvalidConnection;
11078 _marshaller_Components_NoConnection = new _Marshaller_Components_NoConnection;
11079 _marshaller_Components_ExceededConnectionLimit = new _Marshaller_Components_ExceededConnectionLimit;
11080 _marshaller_Components_CookieRequired = new _Marshaller_Components_CookieRequired;
11081 _marshaller_Components_PortDescription = new _Marshaller_Components_PortDescription;
11082 _marshaller_Components_Cookie = new _Marshaller_Components_Cookie;
11083 _marshaller_Components_EventBase = new _Marshaller_Components_EventBase;
11084 _marshaller_Components_FacetDescription = new _Marshaller_Components_FacetDescription;
11085 _marshaller_Components_Navigation = new _Marshaller_Components_Navigation;
11086 _marshaller_Components_ConnectionDescription = new _Marshaller_Components_ConnectionDescription;
11087 _marshaller_Components_ReceptacleDescription = new _Marshaller_Components_ReceptacleDescription;
11088 _marshaller_Components_Receptacles = new _Marshaller_Components_Receptacles;
11089 _marshaller_Components_BadEventType = new _Marshaller_Components_BadEventType;
11090 _marshaller_Components_EventConsumerBase = new _Marshaller_Components_EventConsumerBase;
11091 _marshaller_Components_ConsumerDescription = new _Marshaller_Components_ConsumerDescription;
11092 _marshaller_Components_EmitterDescription = new _Marshaller_Components_EmitterDescription;
11093 _marshaller_Components_SubscriberDescription = new _Marshaller_Components_SubscriberDescription;
11094 _marshaller_Components_PublisherDescription = new _Marshaller_Components_PublisherDescription;
11095 _marshaller_Components_Events = new _Marshaller_Components_Events;
11096 _marshaller_Components_CCMHome = new _Marshaller_Components_CCMHome;
11097 _marshaller_Components_ComponentPortDescription = new _Marshaller_Components_ComponentPortDescription;
11098 _marshaller_Components_CCMObject = new _Marshaller_Components_CCMObject;
11099 _marshaller_Components_DuplicateKeyValue = new _Marshaller_Components_DuplicateKeyValue;
11100 _marshaller_Components_UnknownKeyValue = new _Marshaller_Components_UnknownKeyValue;
11101 _marshaller_Components_InvalidKey = new _Marshaller_Components_InvalidKey;
11102 _marshaller_Components_KeylessCCMHome = new _Marshaller_Components_KeylessCCMHome;
11103 _marshaller_Components_HomeNotFound = new _Marshaller_Components_HomeNotFound;
11104 _marshaller_Components_HomeFinder = new _Marshaller_Components_HomeFinder;
11105 _marshaller_Components_WrongComponentType = new _Marshaller_Components_WrongComponentType;
11106 _marshaller_Components_Configurator = new _Marshaller_Components_Configurator;
11107 _marshaller_Components_ConfigValue = new _Marshaller_Components_ConfigValue;
11108 _marshaller_Components_StandardConfigurator = new _Marshaller_Components_StandardConfigurator;
11109 _marshaller_Components_IllegalState = new _Marshaller_Components_IllegalState;
11110 _marshaller_Components_CCMExceptionReason = new _Marshaller_Components_CCMExceptionReason;
11111 _marshaller_Components_CCMException = new _Marshaller_Components_CCMException;
11112 _marshaller_Components_UnknownImplId = new _Marshaller_Components_UnknownImplId;
11113 _marshaller_Components_InvalidLocation = new _Marshaller_Components_InvalidLocation;
11114 _marshaller_Components_CreateFailure = new _Marshaller_Components_CreateFailure;
11115 _marshaller_Components_RemoveFailure = new _Marshaller_Components_RemoveFailure;
11116 _marshaller_Components_InstallationFailure = new _Marshaller_Components_InstallationFailure;
11117 _marshaller_Components_InvalidAssembly = new _Marshaller_Components_InvalidAssembly;
11118 _marshaller_Components_Container = new _Marshaller_Components_Container;
11119 _marshaller_Components_ComponentServer = new _Marshaller_Components_ComponentServer;
11120 _marshaller_Components_ComponentInstallation = new _Marshaller_Components_ComponentInstallation;
11121 _marshaller_Components_AssemblyState = new _Marshaller_Components_AssemblyState;
11122 _marshaller_Components_Assembly = new _Marshaller_Components_Assembly;
11123 _marshaller_Components_AssemblyFactory = new _Marshaller_Components_AssemblyFactory;
11124 _marshaller_Components_ServerActivator = new _Marshaller_Components_ServerActivator;
11125 _marshaller_MICOCCM_MicoCCMD = new _Marshaller_MICOCCM_MicoCCMD;
11126 _marshaller_MICOCCM_ComponentServer = new _Marshaller_MICOCCM_ComponentServer;
11127 _marshaller_HPI_HomeFinder = new _Marshaller_HPI_HomeFinder;
11128 _marshaller__seq_Components_FacetDescription = new _Marshaller__seq_Components_FacetDescription;
11129 _marshaller__seq_Components_ConnectionDescription = new _Marshaller__seq_Components_ConnectionDescription;
11130 _marshaller__seq_Components_ReceptacleDescription = new _Marshaller__seq_Components_ReceptacleDescription;
11131 _marshaller__seq_Components_ConsumerDescription = new _Marshaller__seq_Components_ConsumerDescription;
11132 _marshaller__seq_Components_EmitterDescription = new _Marshaller__seq_Components_EmitterDescription;
11133 _marshaller__seq_Components_SubscriberDescription = new _Marshaller__seq_Components_SubscriberDescription;
11134 _marshaller__seq_Components_PublisherDescription = new _Marshaller__seq_Components_PublisherDescription;
11135 _marshaller__seq_Components_CCMHome = new _Marshaller__seq_Components_CCMHome;
11136 _marshaller__seq_Components_ConfigValue = new _Marshaller__seq_Components_ConfigValue;
11137 _marshaller__seq_Components_Container = new _Marshaller__seq_Components_Container;
11138 _marshaller__seq_Components_ComponentServer = new _Marshaller__seq_Components_ComponentServer;
11139 }
11140 };
11141
11142 static __tc_init_HOME __init_HOME;
11143
11144
11145
11146
11147
11148
11149 POA_Components::Navigation::~Navigation()
11150 {
11151 }
11152
11153 ::Components::Navigation_ptr
11154 POA_Components::Navigation::_this ()
11155 {
11156 CORBA::Object_var obj = PortableServer::ServantBase::_this();
11157 return ::Components::Navigation::_narrow (obj);
11158 }
11159
11160 CORBA::Boolean
11161 POA_Components::Navigation::_is_a (const char * repoid)
11162 {
11163 if (strcmp (repoid, "IDL:omg.org/Components/Navigation:1.0") == 0) {
11164 return TRUE;
11165 }
11166 return FALSE;
11167 }
11168
11169 CORBA::InterfaceDef_ptr
11170 POA_Components::Navigation::_get_interface ()
11171 {
11172 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/Navigation:1.0");
11173
11174 if (CORBA::is_nil (ifd)) {
11175 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
11176 }
11177
11178 return ifd;
11179 }
11180
11181 CORBA::RepositoryId
11182 POA_Components::Navigation::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
11183 {
11184 return CORBA::string_dup ("IDL:omg.org/Components/Navigation:1.0");
11185 }
11186
11187 CORBA::Object_ptr
11188 POA_Components::Navigation::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
11189 {
11190 return new ::Components::Navigation_stub_clp (poa, obj);
11191 }
11192
11193 bool
11194 POA_Components::Navigation::dispatch (CORBA::StaticServerRequest_ptr __req)
11195 {
11196 #ifdef HAVE_EXCEPTIONS
11197 try {
11198 #endif
11199 switch (mico_string_hash (__req->op_name(), 7)) {
11200 case 2:
11201 if( strcmp( __req->op_name(), "same_component" ) == 0 ) {
11202 CORBA::Object_var _par_ref;
11203 CORBA::StaticAny _sa_ref( CORBA::_stc_Object, &_par_ref._for_demarshal() );
11204
11205 CORBA::Boolean _res;
11206 CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
11207 __req->add_in_arg( &_sa_ref );
11208 __req->set_result( &__res );
11209
11210 if( !__req->read_args() )
11211 return true;
11212
11213 _res = same_component( _par_ref.inout() );
11214 __req->write_results();
11215 return true;
11216 }
11217 break;
11218 case 3:
11219 if( strcmp( __req->op_name(), "get_named_facets" ) == 0 ) {
11220 ::Components::NameList _par_names;
11221 CORBA::StaticAny _sa_names( CORBA::_stcseq_string, &_par_names );
11222
11223 ::Components::FacetDescriptions* _res;
11224 CORBA::StaticAny __res( _marshaller__seq_Components_FacetDescription );
11225 __req->add_in_arg( &_sa_names );
11226 __req->set_result( &__res );
11227
11228 if( !__req->read_args() )
11229 return true;
11230
11231 #ifdef HAVE_EXCEPTIONS
11232 try {
11233 #endif
11234 _res = get_named_facets( _par_names );
11235 __res.value( _marshaller__seq_Components_FacetDescription, _res );
11236 #ifdef HAVE_EXCEPTIONS
11237 } catch( ::Components::InvalidName_catch &_ex ) {
11238 __req->set_exception( _ex->_clone() );
11239 __req->write_results();
11240 return true;
11241 }
11242 #endif
11243 __req->write_results();
11244 delete _res;
11245 return true;
11246 }
11247 break;
11248 case 4:
11249 if( strcmp( __req->op_name(), "provide_facet" ) == 0 ) {
11250 ::Components::FeatureName_var _par_name;
11251 CORBA::StaticAny _sa_name( CORBA::_stc_string, &_par_name._for_demarshal() );
11252
11253 CORBA::Object_ptr _res;
11254 CORBA::StaticAny __res( CORBA::_stc_Object, &_res );
11255 __req->add_in_arg( &_sa_name );
11256 __req->set_result( &__res );
11257
11258 if( !__req->read_args() )
11259 return true;
11260
11261 #ifdef HAVE_EXCEPTIONS
11262 try {
11263 #endif
11264 _res = provide_facet( _par_name.inout() );
11265 #ifdef HAVE_EXCEPTIONS
11266 } catch( ::Components::InvalidName_catch &_ex ) {
11267 __req->set_exception( _ex->_clone() );
11268 __req->write_results();
11269 return true;
11270 }
11271 #endif
11272 __req->write_results();
11273 CORBA::release( _res );
11274 return true;
11275 }
11276 break;
11277 case 5:
11278 if( strcmp( __req->op_name(), "get_all_facets" ) == 0 ) {
11279 ::Components::FacetDescriptions* _res;
11280 CORBA::StaticAny __res( _marshaller__seq_Components_FacetDescription );
11281 __req->set_result( &__res );
11282
11283 if( !__req->read_args() )
11284 return true;
11285
11286 _res = get_all_facets();
11287 __res.value( _marshaller__seq_Components_FacetDescription, _res );
11288 __req->write_results();
11289 delete _res;
11290 return true;
11291 }
11292 break;
11293 }
11294 #ifdef HAVE_EXCEPTIONS
11295 } catch( CORBA::SystemException_catch &_ex ) {
11296 __req->set_exception( _ex->_clone() );
11297 __req->write_results();
11298 return true;
11299 } catch( ... ) {
11300 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
11301 __req->set_exception (_ex->_clone());
11302 __req->write_results ();
11303 return true;
11304 }
11305 #endif
11306
11307 return false;
11308 }
11309
11310 void
11311 POA_Components::Navigation::invoke (CORBA::StaticServerRequest_ptr __req)
11312 {
11313 if (dispatch (__req)) {
11314 return;
11315 }
11316
11317 CORBA::Exception * ex =
11318 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
11319 __req->set_exception (ex);
11320 __req->write_results();
11321 }
11322
11323
11324
11325 POA_Components::Receptacles::~Receptacles()
11326 {
11327 }
11328
11329 ::Components::Receptacles_ptr
11330 POA_Components::Receptacles::_this ()
11331 {
11332 CORBA::Object_var obj = PortableServer::ServantBase::_this();
11333 return ::Components::Receptacles::_narrow (obj);
11334 }
11335
11336 CORBA::Boolean
11337 POA_Components::Receptacles::_is_a (const char * repoid)
11338 {
11339 if (strcmp (repoid, "IDL:omg.org/Components/Receptacles:1.0") == 0) {
11340 return TRUE;
11341 }
11342 return FALSE;
11343 }
11344
11345 CORBA::InterfaceDef_ptr
11346 POA_Components::Receptacles::_get_interface ()
11347 {
11348 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/Receptacles:1.0");
11349
11350 if (CORBA::is_nil (ifd)) {
11351 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
11352 }
11353
11354 return ifd;
11355 }
11356
11357 CORBA::RepositoryId
11358 POA_Components::Receptacles::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
11359 {
11360 return CORBA::string_dup ("IDL:omg.org/Components/Receptacles:1.0");
11361 }
11362
11363 CORBA::Object_ptr
11364 POA_Components::Receptacles::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
11365 {
11366 return new ::Components::Receptacles_stub_clp (poa, obj);
11367 }
11368
11369 bool
11370 POA_Components::Receptacles::dispatch (CORBA::StaticServerRequest_ptr __req)
11371 {
11372 #ifdef HAVE_EXCEPTIONS
11373 try {
11374 #endif
11375 switch (mico_string_hash (__req->op_name(), 7)) {
11376 case 1:
11377 if( strcmp( __req->op_name(), "connect" ) == 0 ) {
11378 ::Components::FeatureName_var _par_name;
11379 CORBA::StaticAny _sa_name( CORBA::_stc_string, &_par_name._for_demarshal() );
11380 CORBA::Object_var _par_connection;
11381 CORBA::StaticAny _sa_connection( CORBA::_stc_Object, &_par_connection._for_demarshal() );
11382
11383 ::Components::Cookie* _res;
11384 CORBA::StaticAny __res( _marshaller_Components_Cookie, &_res );
11385 __req->add_in_arg( &_sa_name );
11386 __req->add_in_arg( &_sa_connection );
11387 __req->set_result( &__res );
11388
11389 if( !__req->read_args() )
11390 return true;
11391
11392 #ifdef HAVE_EXCEPTIONS
11393 try {
11394 #endif
11395 _res = connect( _par_name.inout(), _par_connection.inout() );
11396 #ifdef HAVE_EXCEPTIONS
11397 } catch( ::Components::InvalidName_catch &_ex ) {
11398 __req->set_exception( _ex->_clone() );
11399 __req->write_results();
11400 return true;
11401 } catch( ::Components::InvalidConnection_catch &_ex ) {
11402 __req->set_exception( _ex->_clone() );
11403 __req->write_results();
11404 return true;
11405 } catch( ::Components::AlreadyConnected_catch &_ex ) {
11406 __req->set_exception( _ex->_clone() );
11407 __req->write_results();
11408 return true;
11409 } catch( ::Components::ExceededConnectionLimit_catch &_ex ) {
11410 __req->set_exception( _ex->_clone() );
11411 __req->write_results();
11412 return true;
11413 }
11414 #endif
11415 __req->write_results();
11416 CORBA::remove_ref( _res );
11417 return true;
11418 }
11419 break;
11420 case 4:
11421 if( strcmp( __req->op_name(), "disconnect" ) == 0 ) {
11422 ::Components::FeatureName_var _par_name;
11423 CORBA::StaticAny _sa_name( CORBA::_stc_string, &_par_name._for_demarshal() );
11424 ::Components::Cookie_var _par_ck;
11425 CORBA::StaticAny _sa_ck( _marshaller_Components_Cookie, &_par_ck._for_demarshal() );
11426
11427 __req->add_in_arg( &_sa_name );
11428 __req->add_in_arg( &_sa_ck );
11429
11430 if( !__req->read_args() )
11431 return true;
11432
11433 #ifdef HAVE_EXCEPTIONS
11434 try {
11435 #endif
11436 disconnect( _par_name.inout(), _par_ck.inout() );
11437 #ifdef HAVE_EXCEPTIONS
11438 } catch( ::Components::InvalidName_catch &_ex ) {
11439 __req->set_exception( _ex->_clone() );
11440 __req->write_results();
11441 return true;
11442 } catch( ::Components::InvalidConnection_catch &_ex ) {
11443 __req->set_exception( _ex->_clone() );
11444 __req->write_results();
11445 return true;
11446 } catch( ::Components::CookieRequired_catch &_ex ) {
11447 __req->set_exception( _ex->_clone() );
11448 __req->write_results();
11449 return true;
11450 } catch( ::Components::NoConnection_catch &_ex ) {
11451 __req->set_exception( _ex->_clone() );
11452 __req->write_results();
11453 return true;
11454 }
11455 #endif
11456 __req->write_results();
11457 return true;
11458 }
11459 if( strcmp( __req->op_name(), "get_all_receptacles" ) == 0 ) {
11460 ::Components::ReceptacleDescriptions* _res;
11461 CORBA::StaticAny __res( _marshaller__seq_Components_ReceptacleDescription );
11462 __req->set_result( &__res );
11463
11464 if( !__req->read_args() )
11465 return true;
11466
11467 _res = get_all_receptacles();
11468 __res.value( _marshaller__seq_Components_ReceptacleDescription, _res );
11469 __req->write_results();
11470 delete _res;
11471 return true;
11472 }
11473 break;
11474 case 5:
11475 if( strcmp( __req->op_name(), "get_connections" ) == 0 ) {
11476 ::Components::FeatureName_var _par_name;
11477 CORBA::StaticAny _sa_name( CORBA::_stc_string, &_par_name._for_demarshal() );
11478
11479 ::Components::ConnectionDescriptions* _res;
11480 CORBA::StaticAny __res( _marshaller__seq_Components_ConnectionDescription );
11481 __req->add_in_arg( &_sa_name );
11482 __req->set_result( &__res );
11483
11484 if( !__req->read_args() )
11485 return true;
11486
11487 #ifdef HAVE_EXCEPTIONS
11488 try {
11489 #endif
11490 _res = get_connections( _par_name.inout() );
11491 __res.value( _marshaller__seq_Components_ConnectionDescription, _res );
11492 #ifdef HAVE_EXCEPTIONS
11493 } catch( ::Components::InvalidName_catch &_ex ) {
11494 __req->set_exception( _ex->_clone() );
11495 __req->write_results();
11496 return true;
11497 }
11498 #endif
11499 __req->write_results();
11500 delete _res;
11501 return true;
11502 }
11503 if( strcmp( __req->op_name(), "get_named_receptacles" ) == 0 ) {
11504 ::Components::NameList _par_names;
11505 CORBA::StaticAny _sa_names( CORBA::_stcseq_string, &_par_names );
11506
11507 ::Components::ReceptacleDescriptions* _res;
11508 CORBA::StaticAny __res( _marshaller__seq_Components_ReceptacleDescription );
11509 __req->add_in_arg( &_sa_names );
11510 __req->set_result( &__res );
11511
11512 if( !__req->read_args() )
11513 return true;
11514
11515 #ifdef HAVE_EXCEPTIONS
11516 try {
11517 #endif
11518 _res = get_named_receptacles( _par_names );
11519 __res.value( _marshaller__seq_Components_ReceptacleDescription, _res );
11520 #ifdef HAVE_EXCEPTIONS
11521 } catch( ::Components::InvalidName_catch &_ex ) {
11522 __req->set_exception( _ex->_clone() );
11523 __req->write_results();
11524 return true;
11525 }
11526 #endif
11527 __req->write_results();
11528 delete _res;
11529 return true;
11530 }
11531 break;
11532 }
11533 #ifdef HAVE_EXCEPTIONS
11534 } catch( CORBA::SystemException_catch &_ex ) {
11535 __req->set_exception( _ex->_clone() );
11536 __req->write_results();
11537 return true;
11538 } catch( ... ) {
11539 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
11540 __req->set_exception (_ex->_clone());
11541 __req->write_results ();
11542 return true;
11543 }
11544 #endif
11545
11546 return false;
11547 }
11548
11549 void
11550 POA_Components::Receptacles::invoke (CORBA::StaticServerRequest_ptr __req)
11551 {
11552 if (dispatch (__req)) {
11553 return;
11554 }
11555
11556 CORBA::Exception * ex =
11557 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
11558 __req->set_exception (ex);
11559 __req->write_results();
11560 }
11561
11562
11563
11564 POA_Components::EventConsumerBase::~EventConsumerBase()
11565 {
11566 }
11567
11568 ::Components::EventConsumerBase_ptr
11569 POA_Components::EventConsumerBase::_this ()
11570 {
11571 CORBA::Object_var obj = PortableServer::ServantBase::_this();
11572 return ::Components::EventConsumerBase::_narrow (obj);
11573 }
11574
11575 CORBA::Boolean
11576 POA_Components::EventConsumerBase::_is_a (const char * repoid)
11577 {
11578 if (strcmp (repoid, "IDL:omg.org/Components/EventConsumerBase:1.0") == 0) {
11579 return TRUE;
11580 }
11581 return FALSE;
11582 }
11583
11584 CORBA::InterfaceDef_ptr
11585 POA_Components::EventConsumerBase::_get_interface ()
11586 {
11587 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/EventConsumerBase:1.0");
11588
11589 if (CORBA::is_nil (ifd)) {
11590 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
11591 }
11592
11593 return ifd;
11594 }
11595
11596 CORBA::RepositoryId
11597 POA_Components::EventConsumerBase::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
11598 {
11599 return CORBA::string_dup ("IDL:omg.org/Components/EventConsumerBase:1.0");
11600 }
11601
11602 CORBA::Object_ptr
11603 POA_Components::EventConsumerBase::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
11604 {
11605 return new ::Components::EventConsumerBase_stub_clp (poa, obj);
11606 }
11607
11608 bool
11609 POA_Components::EventConsumerBase::dispatch (CORBA::StaticServerRequest_ptr __req)
11610 {
11611 #ifdef HAVE_EXCEPTIONS
11612 try {
11613 #endif
11614 if( strcmp( __req->op_name(), "push_event" ) == 0 ) {
11615 ::Components::EventBase_var _par_evt;
11616 CORBA::StaticAny _sa_evt( _marshaller_Components_EventBase, &_par_evt._for_demarshal() );
11617
11618 __req->add_in_arg( &_sa_evt );
11619
11620 if( !__req->read_args() )
11621 return true;
11622
11623 #ifdef HAVE_EXCEPTIONS
11624 try {
11625 #endif
11626 push_event( _par_evt.inout() );
11627 #ifdef HAVE_EXCEPTIONS
11628 } catch( ::Components::BadEventType_catch &_ex ) {
11629 __req->set_exception( _ex->_clone() );
11630 __req->write_results();
11631 return true;
11632 }
11633 #endif
11634 __req->write_results();
11635 return true;
11636 }
11637 #ifdef HAVE_EXCEPTIONS
11638 } catch( CORBA::SystemException_catch &_ex ) {
11639 __req->set_exception( _ex->_clone() );
11640 __req->write_results();
11641 return true;
11642 } catch( ... ) {
11643 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
11644 __req->set_exception (_ex->_clone());
11645 __req->write_results ();
11646 return true;
11647 }
11648 #endif
11649
11650 return false;
11651 }
11652
11653 void
11654 POA_Components::EventConsumerBase::invoke (CORBA::StaticServerRequest_ptr __req)
11655 {
11656 if (dispatch (__req)) {
11657 return;
11658 }
11659
11660 CORBA::Exception * ex =
11661 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
11662 __req->set_exception (ex);
11663 __req->write_results();
11664 }
11665
11666
11667
11668 POA_Components::Events::~Events()
11669 {
11670 }
11671
11672 ::Components::Events_ptr
11673 POA_Components::Events::_this ()
11674 {
11675 CORBA::Object_var obj = PortableServer::ServantBase::_this();
11676 return ::Components::Events::_narrow (obj);
11677 }
11678
11679 CORBA::Boolean
11680 POA_Components::Events::_is_a (const char * repoid)
11681 {
11682 if (strcmp (repoid, "IDL:omg.org/Components/Events:1.0") == 0) {
11683 return TRUE;
11684 }
11685 return FALSE;
11686 }
11687
11688 CORBA::InterfaceDef_ptr
11689 POA_Components::Events::_get_interface ()
11690 {
11691 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/Events:1.0");
11692
11693 if (CORBA::is_nil (ifd)) {
11694 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
11695 }
11696
11697 return ifd;
11698 }
11699
11700 CORBA::RepositoryId
11701 POA_Components::Events::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
11702 {
11703 return CORBA::string_dup ("IDL:omg.org/Components/Events:1.0");
11704 }
11705
11706 CORBA::Object_ptr
11707 POA_Components::Events::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
11708 {
11709 return new ::Components::Events_stub_clp (poa, obj);
11710 }
11711
11712 bool
11713 POA_Components::Events::dispatch (CORBA::StaticServerRequest_ptr __req)
11714 {
11715 #ifdef HAVE_EXCEPTIONS
11716 try {
11717 #endif
11718 switch (mico_string_hash (__req->op_name(), 17)) {
11719 case 1:
11720 if( strcmp( __req->op_name(), "get_named_consumers" ) == 0 ) {
11721 ::Components::NameList _par_names;
11722 CORBA::StaticAny _sa_names( CORBA::_stcseq_string, &_par_names );
11723
11724 ::Components::ConsumerDescriptions* _res;
11725 CORBA::StaticAny __res( _marshaller__seq_Components_ConsumerDescription );
11726 __req->add_in_arg( &_sa_names );
11727 __req->set_result( &__res );
11728
11729 if( !__req->read_args() )
11730 return true;
11731
11732 _res = get_named_consumers( _par_names );
11733 __res.value( _marshaller__seq_Components_ConsumerDescription, _res );
11734 __req->write_results();
11735 delete _res;
11736 return true;
11737 }
11738 break;
11739 case 2:
11740 if( strcmp( __req->op_name(), "get_consumer" ) == 0 ) {
11741 ::Components::FeatureName_var _par_sink_name;
11742 CORBA::StaticAny _sa_sink_name( CORBA::_stc_string, &_par_sink_name._for_demarshal() );
11743
11744 ::Components::EventConsumerBase_ptr _res;
11745 CORBA::StaticAny __res( _marshaller_Components_EventConsumerBase, &_res );
11746 __req->add_in_arg( &_sa_sink_name );
11747 __req->set_result( &__res );
11748
11749 if( !__req->read_args() )
11750 return true;
11751
11752 #ifdef HAVE_EXCEPTIONS
11753 try {
11754 #endif
11755 _res = get_consumer( _par_sink_name.inout() );
11756 #ifdef HAVE_EXCEPTIONS
11757 } catch( ::Components::InvalidName_catch &_ex ) {
11758 __req->set_exception( _ex->_clone() );
11759 __req->write_results();
11760 return true;
11761 }
11762 #endif
11763 __req->write_results();
11764 CORBA::release( _res );
11765 return true;
11766 }
11767 if( strcmp( __req->op_name(), "subscribe" ) == 0 ) {
11768 ::Components::FeatureName_var _par_publisher_name;
11769 CORBA::StaticAny _sa_publisher_name( CORBA::_stc_string, &_par_publisher_name._for_demarshal() );
11770 ::Components::EventConsumerBase_var _par_subscriber;
11771 CORBA::StaticAny _sa_subscriber( _marshaller_Components_EventConsumerBase, &_par_subscriber._for_demarshal() );
11772
11773 ::Components::Cookie* _res;
11774 CORBA::StaticAny __res( _marshaller_Components_Cookie, &_res );
11775 __req->add_in_arg( &_sa_publisher_name );
11776 __req->add_in_arg( &_sa_subscriber );
11777 __req->set_result( &__res );
11778
11779 if( !__req->read_args() )
11780 return true;
11781
11782 #ifdef HAVE_EXCEPTIONS
11783 try {
11784 #endif
11785 _res = subscribe( _par_publisher_name.inout(), _par_subscriber.inout() );
11786 #ifdef HAVE_EXCEPTIONS
11787 } catch( ::Components::InvalidName_catch &_ex ) {
11788 __req->set_exception( _ex->_clone() );
11789 __req->write_results();
11790 return true;
11791 }
11792 #endif
11793 __req->write_results();
11794 CORBA::remove_ref( _res );
11795 return true;
11796 }
11797 if( strcmp( __req->op_name(), "disconnect_consumer" ) == 0 ) {
11798 ::Components::FeatureName_var _par_source_name;
11799 CORBA::StaticAny _sa_source_name( CORBA::_stc_string, &_par_source_name._for_demarshal() );
11800
11801 ::Components::EventConsumerBase_ptr _res;
11802 CORBA::StaticAny __res( _marshaller_Components_EventConsumerBase, &_res );
11803 __req->add_in_arg( &_sa_source_name );
11804 __req->set_result( &__res );
11805
11806 if( !__req->read_args() )
11807 return true;
11808
11809 #ifdef HAVE_EXCEPTIONS
11810 try {
11811 #endif
11812 _res = disconnect_consumer( _par_source_name.inout() );
11813 #ifdef HAVE_EXCEPTIONS
11814 } catch( ::Components::InvalidName_catch &_ex ) {
11815 __req->set_exception( _ex->_clone() );
11816 __req->write_results();
11817 return true;
11818 } catch( ::Components::NoConnection_catch &_ex ) {
11819 __req->set_exception( _ex->_clone() );
11820 __req->write_results();
11821 return true;
11822 }
11823 #endif
11824 __req->write_results();
11825 CORBA::release( _res );
11826 return true;
11827 }
11828 break;
11829 case 3:
11830 if( strcmp( __req->op_name(), "get_all_emitters" ) == 0 ) {
11831 ::Components::EmitterDescriptions* _res;
11832 CORBA::StaticAny __res( _marshaller__seq_Components_EmitterDescription );
11833 __req->set_result( &__res );
11834
11835 if( !__req->read_args() )
11836 return true;
11837
11838 _res = get_all_emitters();
11839 __res.value( _marshaller__seq_Components_EmitterDescription, _res );
11840 __req->write_results();
11841 delete _res;
11842 return true;
11843 }
11844 break;
11845 case 5:
11846 if( strcmp( __req->op_name(), "get_named_emitters" ) == 0 ) {
11847 ::Components::NameList _par_names;
11848 CORBA::StaticAny _sa_names( CORBA::_stcseq_string, &_par_names );
11849
11850 ::Components::EmitterDescriptions* _res;
11851 CORBA::StaticAny __res( _marshaller__seq_Components_EmitterDescription );
11852 __req->add_in_arg( &_sa_names );
11853 __req->set_result( &__res );
11854
11855 if( !__req->read_args() )
11856 return true;
11857
11858 _res = get_named_emitters( _par_names );
11859 __res.value( _marshaller__seq_Components_EmitterDescription, _res );
11860 __req->write_results();
11861 delete _res;
11862 return true;
11863 }
11864 break;
11865 case 9:
11866 if( strcmp( __req->op_name(), "get_all_publishers" ) == 0 ) {
11867 ::Components::PublisherDescriptions* _res;
11868 CORBA::StaticAny __res( _marshaller__seq_Components_PublisherDescription );
11869 __req->set_result( &__res );
11870
11871 if( !__req->read_args() )
11872 return true;
11873
11874 _res = get_all_publishers();
11875 __res.value( _marshaller__seq_Components_PublisherDescription, _res );
11876 __req->write_results();
11877 delete _res;
11878 return true;
11879 }
11880 if( strcmp( __req->op_name(), "get_named_publishers" ) == 0 ) {
11881 ::Components::NameList _par_names;
11882 CORBA::StaticAny _sa_names( CORBA::_stcseq_string, &_par_names );
11883
11884 ::Components::PublisherDescriptions* _res;
11885 CORBA::StaticAny __res( _marshaller__seq_Components_PublisherDescription );
11886 __req->add_in_arg( &_sa_names );
11887 __req->set_result( &__res );
11888
11889 if( !__req->read_args() )
11890 return true;
11891
11892 _res = get_named_publishers( _par_names );
11893 __res.value( _marshaller__seq_Components_PublisherDescription, _res );
11894 __req->write_results();
11895 delete _res;
11896 return true;
11897 }
11898 break;
11899 case 12:
11900 if( strcmp( __req->op_name(), "unsubscribe" ) == 0 ) {
11901 ::Components::FeatureName_var _par_publisher_name;
11902 CORBA::StaticAny _sa_publisher_name( CORBA::_stc_string, &_par_publisher_name._for_demarshal() );
11903 ::Components::Cookie_var _par_ck;
11904 CORBA::StaticAny _sa_ck( _marshaller_Components_Cookie, &_par_ck._for_demarshal() );
11905
11906 __req->add_in_arg( &_sa_publisher_name );
11907 __req->add_in_arg( &_sa_ck );
11908
11909 if( !__req->read_args() )
11910 return true;
11911
11912 #ifdef HAVE_EXCEPTIONS
11913 try {
11914 #endif
11915 unsubscribe( _par_publisher_name.inout(), _par_ck.inout() );
11916 #ifdef HAVE_EXCEPTIONS
11917 } catch( ::Components::InvalidName_catch &_ex ) {
11918 __req->set_exception( _ex->_clone() );
11919 __req->write_results();
11920 return true;
11921 } catch( ::Components::InvalidConnection_catch &_ex ) {
11922 __req->set_exception( _ex->_clone() );
11923 __req->write_results();
11924 return true;
11925 }
11926 #endif
11927 __req->write_results();
11928 return true;
11929 }
11930 break;
11931 case 13:
11932 if( strcmp( __req->op_name(), "connect_consumer" ) == 0 ) {
11933 ::Components::FeatureName_var _par_emitter_name;
11934 CORBA::StaticAny _sa_emitter_name( CORBA::_stc_string, &_par_emitter_name._for_demarshal() );
11935 ::Components::EventConsumerBase_var _par_consumer;
11936 CORBA::StaticAny _sa_consumer( _marshaller_Components_EventConsumerBase, &_par_consumer._for_demarshal() );
11937
11938 __req->add_in_arg( &_sa_emitter_name );
11939 __req->add_in_arg( &_sa_consumer );
11940
11941 if( !__req->read_args() )
11942 return true;
11943
11944 #ifdef HAVE_EXCEPTIONS
11945 try {
11946 #endif
11947 connect_consumer( _par_emitter_name.inout(), _par_consumer.inout() );
11948 #ifdef HAVE_EXCEPTIONS
11949 } catch( ::Components::InvalidName_catch &_ex ) {
11950 __req->set_exception( _ex->_clone() );
11951 __req->write_results();
11952 return true;
11953 } catch( ::Components::AlreadyConnected_catch &_ex ) {
11954 __req->set_exception( _ex->_clone() );
11955 __req->write_results();
11956 return true;
11957 }
11958 #endif
11959 __req->write_results();
11960 return true;
11961 }
11962 break;
11963 case 15:
11964 if( strcmp( __req->op_name(), "get_all_consumers" ) == 0 ) {
11965 ::Components::ConsumerDescriptions* _res;
11966 CORBA::StaticAny __res( _marshaller__seq_Components_ConsumerDescription );
11967 __req->set_result( &__res );
11968
11969 if( !__req->read_args() )
11970 return true;
11971
11972 _res = get_all_consumers();
11973 __res.value( _marshaller__seq_Components_ConsumerDescription, _res );
11974 __req->write_results();
11975 delete _res;
11976 return true;
11977 }
11978 break;
11979 }
11980 #ifdef HAVE_EXCEPTIONS
11981 } catch( CORBA::SystemException_catch &_ex ) {
11982 __req->set_exception( _ex->_clone() );
11983 __req->write_results();
11984 return true;
11985 } catch( ... ) {
11986 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
11987 __req->set_exception (_ex->_clone());
11988 __req->write_results ();
11989 return true;
11990 }
11991 #endif
11992
11993 return false;
11994 }
11995
11996 void
11997 POA_Components::Events::invoke (CORBA::StaticServerRequest_ptr __req)
11998 {
11999 if (dispatch (__req)) {
12000 return;
12001 }
12002
12003 CORBA::Exception * ex =
12004 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
12005 __req->set_exception (ex);
12006 __req->write_results();
12007 }
12008
12009
12010
12011 POA_Components::CCMHome::~CCMHome()
12012 {
12013 }
12014
12015 ::Components::CCMHome_ptr
12016 POA_Components::CCMHome::_this ()
12017 {
12018 CORBA::Object_var obj = PortableServer::ServantBase::_this();
12019 return ::Components::CCMHome::_narrow (obj);
12020 }
12021
12022 CORBA::Boolean
12023 POA_Components::CCMHome::_is_a (const char * repoid)
12024 {
12025 if (strcmp (repoid, "IDL:omg.org/Components/CCMHome:1.0") == 0) {
12026 return TRUE;
12027 }
12028 return FALSE;
12029 }
12030
12031 CORBA::InterfaceDef_ptr
12032 POA_Components::CCMHome::_get_interface ()
12033 {
12034 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/CCMHome:1.0");
12035
12036 if (CORBA::is_nil (ifd)) {
12037 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
12038 }
12039
12040 return ifd;
12041 }
12042
12043 CORBA::RepositoryId
12044 POA_Components::CCMHome::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
12045 {
12046 return CORBA::string_dup ("IDL:omg.org/Components/CCMHome:1.0");
12047 }
12048
12049 CORBA::Object_ptr
12050 POA_Components::CCMHome::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
12051 {
12052 return new ::Components::CCMHome_stub_clp (poa, obj);
12053 }
12054
12055 bool
12056 POA_Components::CCMHome::dispatch (CORBA::StaticServerRequest_ptr __req)
12057 {
12058 #ifdef HAVE_EXCEPTIONS
12059 try {
12060 #endif
12061 if( strcmp( __req->op_name(), "get_component_def" ) == 0 ) {
12062 CORBA::Object_ptr _res;
12063 CORBA::StaticAny __res( CORBA::_stc_Object, &_res );
12064 __req->set_result( &__res );
12065
12066 if( !__req->read_args() )
12067 return true;
12068
12069 _res = get_component_def();
12070 __req->write_results();
12071 CORBA::release( _res );
12072 return true;
12073 }
12074 if( strcmp( __req->op_name(), "get_home_def" ) == 0 ) {
12075 CORBA::Object_ptr _res;
12076 CORBA::StaticAny __res( CORBA::_stc_Object, &_res );
12077 __req->set_result( &__res );
12078
12079 if( !__req->read_args() )
12080 return true;
12081
12082 _res = get_home_def();
12083 __req->write_results();
12084 CORBA::release( _res );
12085 return true;
12086 }
12087 if( strcmp( __req->op_name(), "remove_component" ) == 0 ) {
12088 ::Components::CCMObject_var _par_comp;
12089 CORBA::StaticAny _sa_comp( _marshaller_Components_CCMObject, &_par_comp._for_demarshal() );
12090
12091 __req->add_in_arg( &_sa_comp );
12092
12093 if( !__req->read_args() )
12094 return true;
12095
12096 remove_component( _par_comp.inout() );
12097 __req->write_results();
12098 return true;
12099 }
12100 #ifdef HAVE_EXCEPTIONS
12101 } catch( CORBA::SystemException_catch &_ex ) {
12102 __req->set_exception( _ex->_clone() );
12103 __req->write_results();
12104 return true;
12105 } catch( ... ) {
12106 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
12107 __req->set_exception (_ex->_clone());
12108 __req->write_results ();
12109 return true;
12110 }
12111 #endif
12112
12113 return false;
12114 }
12115
12116 void
12117 POA_Components::CCMHome::invoke (CORBA::StaticServerRequest_ptr __req)
12118 {
12119 if (dispatch (__req)) {
12120 return;
12121 }
12122
12123 CORBA::Exception * ex =
12124 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
12125 __req->set_exception (ex);
12126 __req->write_results();
12127 }
12128
12129
12130
12131 POA_Components::CCMObject::~CCMObject()
12132 {
12133 }
12134
12135 ::Components::CCMObject_ptr
12136 POA_Components::CCMObject::_this ()
12137 {
12138 CORBA::Object_var obj = PortableServer::ServantBase::_this();
12139 return ::Components::CCMObject::_narrow (obj);
12140 }
12141
12142 CORBA::Boolean
12143 POA_Components::CCMObject::_is_a (const char * repoid)
12144 {
12145 if (strcmp (repoid, "IDL:omg.org/Components/CCMObject:1.0") == 0) {
12146 return TRUE;
12147 }
12148 if (POA_Components::Navigation::_is_a (repoid)) {
12149 return TRUE;
12150 }
12151 if (POA_Components::Receptacles::_is_a (repoid)) {
12152 return TRUE;
12153 }
12154 if (POA_Components::Events::_is_a (repoid)) {
12155 return TRUE;
12156 }
12157 return FALSE;
12158 }
12159
12160 CORBA::InterfaceDef_ptr
12161 POA_Components::CCMObject::_get_interface ()
12162 {
12163 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/CCMObject:1.0");
12164
12165 if (CORBA::is_nil (ifd)) {
12166 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
12167 }
12168
12169 return ifd;
12170 }
12171
12172 CORBA::RepositoryId
12173 POA_Components::CCMObject::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
12174 {
12175 return CORBA::string_dup ("IDL:omg.org/Components/CCMObject:1.0");
12176 }
12177
12178 CORBA::Object_ptr
12179 POA_Components::CCMObject::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
12180 {
12181 return new ::Components::CCMObject_stub_clp (poa, obj);
12182 }
12183
12184 bool
12185 POA_Components::CCMObject::dispatch (CORBA::StaticServerRequest_ptr __req)
12186 {
12187 #ifdef HAVE_EXCEPTIONS
12188 try {
12189 #endif
12190 switch (mico_string_hash (__req->op_name(), 7)) {
12191 case 1:
12192 if( strcmp( __req->op_name(), "remove" ) == 0 ) {
12193
12194 if( !__req->read_args() )
12195 return true;
12196
12197 remove();
12198 __req->write_results();
12199 return true;
12200 }
12201 break;
12202 case 2:
12203 if( strcmp( __req->op_name(), "get_ccm_home" ) == 0 ) {
12204 ::Components::CCMHome_ptr _res;
12205 CORBA::StaticAny __res( _marshaller_Components_CCMHome, &_res );
12206 __req->set_result( &__res );
12207
12208 if( !__req->read_args() )
12209 return true;
12210
12211 _res = get_ccm_home();
12212 __req->write_results();
12213 CORBA::release( _res );
12214 return true;
12215 }
12216 break;
12217 case 5:
12218 if( strcmp( __req->op_name(), "configuration_complete" ) == 0 ) {
12219
12220 if( !__req->read_args() )
12221 return true;
12222
12223 configuration_complete();
12224 __req->write_results();
12225 return true;
12226 }
12227 if( strcmp( __req->op_name(), "get_all_ports" ) == 0 ) {
12228 ::Components::ComponentPortDescription* _res;
12229 CORBA::StaticAny __res( _marshaller_Components_ComponentPortDescription, &_res );
12230 __req->set_result( &__res );
12231
12232 if( !__req->read_args() )
12233 return true;
12234
12235 _res = get_all_ports();
12236 __req->write_results();
12237 CORBA::remove_ref( _res );
12238 return true;
12239 }
12240 break;
12241 case 6:
12242 if( strcmp( __req->op_name(), "get_component_def" ) == 0 ) {
12243 CORBA::Object_ptr _res;
12244 CORBA::StaticAny __res( CORBA::_stc_Object, &_res );
12245 __req->set_result( &__res );
12246
12247 if( !__req->read_args() )
12248 return true;
12249
12250 _res = get_component_def();
12251 __req->write_results();
12252 CORBA::release( _res );
12253 return true;
12254 }
12255 break;
12256 }
12257 #ifdef HAVE_EXCEPTIONS
12258 } catch( CORBA::SystemException_catch &_ex ) {
12259 __req->set_exception( _ex->_clone() );
12260 __req->write_results();
12261 return true;
12262 } catch( ... ) {
12263 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
12264 __req->set_exception (_ex->_clone());
12265 __req->write_results ();
12266 return true;
12267 }
12268 #endif
12269
12270 if (POA_Components::Navigation::dispatch (__req)) {
12271 return true;
12272 }
12273
12274 if (POA_Components::Receptacles::dispatch (__req)) {
12275 return true;
12276 }
12277
12278 if (POA_Components::Events::dispatch (__req)) {
12279 return true;
12280 }
12281
12282 return false;
12283 }
12284
12285 void
12286 POA_Components::CCMObject::invoke (CORBA::StaticServerRequest_ptr __req)
12287 {
12288 if (dispatch (__req)) {
12289 return;
12290 }
12291
12292 CORBA::Exception * ex =
12293 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
12294 __req->set_exception (ex);
12295 __req->write_results();
12296 }
12297
12298
12299
12300 POA_Components::KeylessCCMHome::~KeylessCCMHome()
12301 {
12302 }
12303
12304 ::Components::KeylessCCMHome_ptr
12305 POA_Components::KeylessCCMHome::_this ()
12306 {
12307 CORBA::Object_var obj = PortableServer::ServantBase::_this();
12308 return ::Components::KeylessCCMHome::_narrow (obj);
12309 }
12310
12311 CORBA::Boolean
12312 POA_Components::KeylessCCMHome::_is_a (const char * repoid)
12313 {
12314 if (strcmp (repoid, "IDL:omg.org/Components/KeylessCCMHome:1.0") == 0) {
12315 return TRUE;
12316 }
12317 return FALSE;
12318 }
12319
12320 CORBA::InterfaceDef_ptr
12321 POA_Components::KeylessCCMHome::_get_interface ()
12322 {
12323 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/KeylessCCMHome:1.0");
12324
12325 if (CORBA::is_nil (ifd)) {
12326 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
12327 }
12328
12329 return ifd;
12330 }
12331
12332 CORBA::RepositoryId
12333 POA_Components::KeylessCCMHome::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
12334 {
12335 return CORBA::string_dup ("IDL:omg.org/Components/KeylessCCMHome:1.0");
12336 }
12337
12338 CORBA::Object_ptr
12339 POA_Components::KeylessCCMHome::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
12340 {
12341 return new ::Components::KeylessCCMHome_stub_clp (poa, obj);
12342 }
12343
12344 bool
12345 POA_Components::KeylessCCMHome::dispatch (CORBA::StaticServerRequest_ptr __req)
12346 {
12347 #ifdef HAVE_EXCEPTIONS
12348 try {
12349 #endif
12350 if( strcmp( __req->op_name(), "create_component" ) == 0 ) {
12351 ::Components::CCMObject_ptr _res;
12352 CORBA::StaticAny __res( _marshaller_Components_CCMObject, &_res );
12353 __req->set_result( &__res );
12354
12355 if( !__req->read_args() )
12356 return true;
12357
12358 _res = create_component();
12359 __req->write_results();
12360 CORBA::release( _res );
12361 return true;
12362 }
12363 #ifdef HAVE_EXCEPTIONS
12364 } catch( CORBA::SystemException_catch &_ex ) {
12365 __req->set_exception( _ex->_clone() );
12366 __req->write_results();
12367 return true;
12368 } catch( ... ) {
12369 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
12370 __req->set_exception (_ex->_clone());
12371 __req->write_results ();
12372 return true;
12373 }
12374 #endif
12375
12376 return false;
12377 }
12378
12379 void
12380 POA_Components::KeylessCCMHome::invoke (CORBA::StaticServerRequest_ptr __req)
12381 {
12382 if (dispatch (__req)) {
12383 return;
12384 }
12385
12386 CORBA::Exception * ex =
12387 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
12388 __req->set_exception (ex);
12389 __req->write_results();
12390 }
12391
12392
12393
12394 POA_Components::HomeFinder::~HomeFinder()
12395 {
12396 }
12397
12398 ::Components::HomeFinder_ptr
12399 POA_Components::HomeFinder::_this ()
12400 {
12401 CORBA::Object_var obj = PortableServer::ServantBase::_this();
12402 return ::Components::HomeFinder::_narrow (obj);
12403 }
12404
12405 CORBA::Boolean
12406 POA_Components::HomeFinder::_is_a (const char * repoid)
12407 {
12408 if (strcmp (repoid, "IDL:omg.org/Components/HomeFinder:1.0") == 0) {
12409 return TRUE;
12410 }
12411 return FALSE;
12412 }
12413
12414 CORBA::InterfaceDef_ptr
12415 POA_Components::HomeFinder::_get_interface ()
12416 {
12417 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/HomeFinder:1.0");
12418
12419 if (CORBA::is_nil (ifd)) {
12420 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
12421 }
12422
12423 return ifd;
12424 }
12425
12426 CORBA::RepositoryId
12427 POA_Components::HomeFinder::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
12428 {
12429 return CORBA::string_dup ("IDL:omg.org/Components/HomeFinder:1.0");
12430 }
12431
12432 CORBA::Object_ptr
12433 POA_Components::HomeFinder::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
12434 {
12435 return new ::Components::HomeFinder_stub_clp (poa, obj);
12436 }
12437
12438 bool
12439 POA_Components::HomeFinder::dispatch (CORBA::StaticServerRequest_ptr __req)
12440 {
12441 #ifdef HAVE_EXCEPTIONS
12442 try {
12443 #endif
12444 if( strcmp( __req->op_name(), "find_home_by_component_type" ) == 0 ) {
12445 CORBA::String_var _par_comp_repid;
12446 CORBA::StaticAny _sa_comp_repid( CORBA::_stc_string, &_par_comp_repid._for_demarshal() );
12447
12448 ::Components::CCMHome_ptr _res;
12449 CORBA::StaticAny __res( _marshaller_Components_CCMHome, &_res );
12450 __req->add_in_arg( &_sa_comp_repid );
12451 __req->set_result( &__res );
12452
12453 if( !__req->read_args() )
12454 return true;
12455
12456 #ifdef HAVE_EXCEPTIONS
12457 try {
12458 #endif
12459 _res = find_home_by_component_type( _par_comp_repid.inout() );
12460 #ifdef HAVE_EXCEPTIONS
12461 } catch( ::Components::HomeNotFound_catch &_ex ) {
12462 __req->set_exception( _ex->_clone() );
12463 __req->write_results();
12464 return true;
12465 }
12466 #endif
12467 __req->write_results();
12468 CORBA::release( _res );
12469 return true;
12470 }
12471 if( strcmp( __req->op_name(), "find_home_by_home_type" ) == 0 ) {
12472 CORBA::String_var _par_home_repid;
12473 CORBA::StaticAny _sa_home_repid( CORBA::_stc_string, &_par_home_repid._for_demarshal() );
12474
12475 ::Components::CCMHome_ptr _res;
12476 CORBA::StaticAny __res( _marshaller_Components_CCMHome, &_res );
12477 __req->add_in_arg( &_sa_home_repid );
12478 __req->set_result( &__res );
12479
12480 if( !__req->read_args() )
12481 return true;
12482
12483 #ifdef HAVE_EXCEPTIONS
12484 try {
12485 #endif
12486 _res = find_home_by_home_type( _par_home_repid.inout() );
12487 #ifdef HAVE_EXCEPTIONS
12488 } catch( ::Components::HomeNotFound_catch &_ex ) {
12489 __req->set_exception( _ex->_clone() );
12490 __req->write_results();
12491 return true;
12492 }
12493 #endif
12494 __req->write_results();
12495 CORBA::release( _res );
12496 return true;
12497 }
12498 if( strcmp( __req->op_name(), "find_home_by_name" ) == 0 ) {
12499 CORBA::String_var _par_home_name;
12500 CORBA::StaticAny _sa_home_name( CORBA::_stc_string, &_par_home_name._for_demarshal() );
12501
12502 ::Components::CCMHome_ptr _res;
12503 CORBA::StaticAny __res( _marshaller_Components_CCMHome, &_res );
12504 __req->add_in_arg( &_sa_home_name );
12505 __req->set_result( &__res );
12506
12507 if( !__req->read_args() )
12508 return true;
12509
12510 _res = find_home_by_name( _par_home_name.inout() );
12511 __req->write_results();
12512 CORBA::release( _res );
12513 return true;
12514 }
12515 #ifdef HAVE_EXCEPTIONS
12516 } catch( CORBA::SystemException_catch &_ex ) {
12517 __req->set_exception( _ex->_clone() );
12518 __req->write_results();
12519 return true;
12520 } catch( ... ) {
12521 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
12522 __req->set_exception (_ex->_clone());
12523 __req->write_results ();
12524 return true;
12525 }
12526 #endif
12527
12528 return false;
12529 }
12530
12531 void
12532 POA_Components::HomeFinder::invoke (CORBA::StaticServerRequest_ptr __req)
12533 {
12534 if (dispatch (__req)) {
12535 return;
12536 }
12537
12538 CORBA::Exception * ex =
12539 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
12540 __req->set_exception (ex);
12541 __req->write_results();
12542 }
12543
12544
12545
12546 POA_Components::Configurator::~Configurator()
12547 {
12548 }
12549
12550 ::Components::Configurator_ptr
12551 POA_Components::Configurator::_this ()
12552 {
12553 CORBA::Object_var obj = PortableServer::ServantBase::_this();
12554 return ::Components::Configurator::_narrow (obj);
12555 }
12556
12557 CORBA::Boolean
12558 POA_Components::Configurator::_is_a (const char * repoid)
12559 {
12560 if (strcmp (repoid, "IDL:omg.org/Components/Configurator:1.0") == 0) {
12561 return TRUE;
12562 }
12563 return FALSE;
12564 }
12565
12566 CORBA::InterfaceDef_ptr
12567 POA_Components::Configurator::_get_interface ()
12568 {
12569 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/Configurator:1.0");
12570
12571 if (CORBA::is_nil (ifd)) {
12572 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
12573 }
12574
12575 return ifd;
12576 }
12577
12578 CORBA::RepositoryId
12579 POA_Components::Configurator::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
12580 {
12581 return CORBA::string_dup ("IDL:omg.org/Components/Configurator:1.0");
12582 }
12583
12584 CORBA::Object_ptr
12585 POA_Components::Configurator::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
12586 {
12587 return new ::Components::Configurator_stub_clp (poa, obj);
12588 }
12589
12590 bool
12591 POA_Components::Configurator::dispatch (CORBA::StaticServerRequest_ptr __req)
12592 {
12593 #ifdef HAVE_EXCEPTIONS
12594 try {
12595 #endif
12596 if( strcmp( __req->op_name(), "configure" ) == 0 ) {
12597 ::Components::CCMObject_var _par_comp;
12598 CORBA::StaticAny _sa_comp( _marshaller_Components_CCMObject, &_par_comp._for_demarshal() );
12599
12600 __req->add_in_arg( &_sa_comp );
12601
12602 if( !__req->read_args() )
12603 return true;
12604
12605 #ifdef HAVE_EXCEPTIONS
12606 try {
12607 #endif
12608 configure( _par_comp.inout() );
12609 #ifdef HAVE_EXCEPTIONS
12610 } catch( ::Components::WrongComponentType_catch &_ex ) {
12611 __req->set_exception( _ex->_clone() );
12612 __req->write_results();
12613 return true;
12614 }
12615 #endif
12616 __req->write_results();
12617 return true;
12618 }
12619 #ifdef HAVE_EXCEPTIONS
12620 } catch( CORBA::SystemException_catch &_ex ) {
12621 __req->set_exception( _ex->_clone() );
12622 __req->write_results();
12623 return true;
12624 } catch( ... ) {
12625 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
12626 __req->set_exception (_ex->_clone());
12627 __req->write_results ();
12628 return true;
12629 }
12630 #endif
12631
12632 return false;
12633 }
12634
12635 void
12636 POA_Components::Configurator::invoke (CORBA::StaticServerRequest_ptr __req)
12637 {
12638 if (dispatch (__req)) {
12639 return;
12640 }
12641
12642 CORBA::Exception * ex =
12643 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
12644 __req->set_exception (ex);
12645 __req->write_results();
12646 }
12647
12648
12649
12650 POA_Components::StandardConfigurator::~StandardConfigurator()
12651 {
12652 }
12653
12654 ::Components::StandardConfigurator_ptr
12655 POA_Components::StandardConfigurator::_this ()
12656 {
12657 CORBA::Object_var obj = PortableServer::ServantBase::_this();
12658 return ::Components::StandardConfigurator::_narrow (obj);
12659 }
12660
12661 CORBA::Boolean
12662 POA_Components::StandardConfigurator::_is_a (const char * repoid)
12663 {
12664 if (strcmp (repoid, "IDL:omg.org/Components/StandardConfigurator:1.0") == 0) {
12665 return TRUE;
12666 }
12667 if (POA_Components::Configurator::_is_a (repoid)) {
12668 return TRUE;
12669 }
12670 return FALSE;
12671 }
12672
12673 CORBA::InterfaceDef_ptr
12674 POA_Components::StandardConfigurator::_get_interface ()
12675 {
12676 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/StandardConfigurator:1.0");
12677
12678 if (CORBA::is_nil (ifd)) {
12679 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
12680 }
12681
12682 return ifd;
12683 }
12684
12685 CORBA::RepositoryId
12686 POA_Components::StandardConfigurator::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
12687 {
12688 return CORBA::string_dup ("IDL:omg.org/Components/StandardConfigurator:1.0");
12689 }
12690
12691 CORBA::Object_ptr
12692 POA_Components::StandardConfigurator::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
12693 {
12694 return new ::Components::StandardConfigurator_stub_clp (poa, obj);
12695 }
12696
12697 bool
12698 POA_Components::StandardConfigurator::dispatch (CORBA::StaticServerRequest_ptr __req)
12699 {
12700 #ifdef HAVE_EXCEPTIONS
12701 try {
12702 #endif
12703 if( strcmp( __req->op_name(), "set_configuration" ) == 0 ) {
12704 ::Components::ConfigValues _par_descr;
12705 CORBA::StaticAny _sa_descr( _marshaller__seq_Components_ConfigValue, &_par_descr );
12706
12707 __req->add_in_arg( &_sa_descr );
12708
12709 if( !__req->read_args() )
12710 return true;
12711
12712 set_configuration( _par_descr );
12713 __req->write_results();
12714 return true;
12715 }
12716 #ifdef HAVE_EXCEPTIONS
12717 } catch( CORBA::SystemException_catch &_ex ) {
12718 __req->set_exception( _ex->_clone() );
12719 __req->write_results();
12720 return true;
12721 } catch( ... ) {
12722 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
12723 __req->set_exception (_ex->_clone());
12724 __req->write_results ();
12725 return true;
12726 }
12727 #endif
12728
12729 if (POA_Components::Configurator::dispatch (__req)) {
12730 return true;
12731 }
12732
12733 return false;
12734 }
12735
12736 void
12737 POA_Components::StandardConfigurator::invoke (CORBA::StaticServerRequest_ptr __req)
12738 {
12739 if (dispatch (__req)) {
12740 return;
12741 }
12742
12743 CORBA::Exception * ex =
12744 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
12745 __req->set_exception (ex);
12746 __req->write_results();
12747 }
12748
12749
12750
12751 POA_Components::Container::~Container()
12752 {
12753 }
12754
12755 ::Components::Container_ptr
12756 POA_Components::Container::_this ()
12757 {
12758 CORBA::Object_var obj = PortableServer::ServantBase::_this();
12759 return ::Components::Container::_narrow (obj);
12760 }
12761
12762 CORBA::Boolean
12763 POA_Components::Container::_is_a (const char * repoid)
12764 {
12765 if (strcmp (repoid, "IDL:omg.org/Components/Container:1.0") == 0) {
12766 return TRUE;
12767 }
12768 return FALSE;
12769 }
12770
12771 CORBA::InterfaceDef_ptr
12772 POA_Components::Container::_get_interface ()
12773 {
12774 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/Container:1.0");
12775
12776 if (CORBA::is_nil (ifd)) {
12777 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
12778 }
12779
12780 return ifd;
12781 }
12782
12783 CORBA::RepositoryId
12784 POA_Components::Container::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
12785 {
12786 return CORBA::string_dup ("IDL:omg.org/Components/Container:1.0");
12787 }
12788
12789 CORBA::Object_ptr
12790 POA_Components::Container::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
12791 {
12792 return new ::Components::Container_stub_clp (poa, obj);
12793 }
12794
12795 bool
12796 POA_Components::Container::dispatch (CORBA::StaticServerRequest_ptr __req)
12797 {
12798 #ifdef HAVE_EXCEPTIONS
12799 try {
12800 #endif
12801 switch (mico_string_hash (__req->op_name(), 11)) {
12802 case 6:
12803 if( strcmp( __req->op_name(), "install_home" ) == 0 ) {
12804 CORBA::String_var _par_id;
12805 CORBA::StaticAny _sa_id( CORBA::_stc_string, &_par_id._for_demarshal() );
12806 CORBA::String_var _par_entrypt;
12807 CORBA::StaticAny _sa_entrypt( CORBA::_stc_string, &_par_entrypt._for_demarshal() );
12808 ::Components::ConfigValues _par_config;
12809 CORBA::StaticAny _sa_config( _marshaller__seq_Components_ConfigValue, &_par_config );
12810
12811 ::Components::CCMHome_ptr _res;
12812 CORBA::StaticAny __res( _marshaller_Components_CCMHome, &_res );
12813 __req->add_in_arg( &_sa_id );
12814 __req->add_in_arg( &_sa_entrypt );
12815 __req->add_in_arg( &_sa_config );
12816 __req->set_result( &__res );
12817
12818 if( !__req->read_args() )
12819 return true;
12820
12821 #ifdef HAVE_EXCEPTIONS
12822 try {
12823 #endif
12824 _res = install_home( _par_id.inout(), _par_entrypt.inout(), _par_config );
12825 #ifdef HAVE_EXCEPTIONS
12826 } catch( ::Components::InvalidConfiguration_catch &_ex ) {
12827 __req->set_exception( _ex->_clone() );
12828 __req->write_results();
12829 return true;
12830 } catch( ::Components::InstallationFailure_catch &_ex ) {
12831 __req->set_exception( _ex->_clone() );
12832 __req->write_results();
12833 return true;
12834 }
12835 #endif
12836 __req->write_results();
12837 CORBA::release( _res );
12838 return true;
12839 }
12840 break;
12841 case 7:
12842 if( strcmp( __req->op_name(), "get_component_server" ) == 0 ) {
12843 ::Components::ComponentServer_ptr _res;
12844 CORBA::StaticAny __res( _marshaller_Components_ComponentServer, &_res );
12845 __req->set_result( &__res );
12846
12847 if( !__req->read_args() )
12848 return true;
12849
12850 _res = get_component_server();
12851 __req->write_results();
12852 CORBA::release( _res );
12853 return true;
12854 }
12855 break;
12856 case 8:
12857 if( strcmp( __req->op_name(), "remove_home" ) == 0 ) {
12858 ::Components::CCMHome_var _par_href;
12859 CORBA::StaticAny _sa_href( _marshaller_Components_CCMHome, &_par_href._for_demarshal() );
12860
12861 __req->add_in_arg( &_sa_href );
12862
12863 if( !__req->read_args() )
12864 return true;
12865
12866 #ifdef HAVE_EXCEPTIONS
12867 try {
12868 #endif
12869 remove_home( _par_href.inout() );
12870 #ifdef HAVE_EXCEPTIONS
12871 } catch( ::Components::RemoveFailure_catch &_ex ) {
12872 __req->set_exception( _ex->_clone() );
12873 __req->write_results();
12874 return true;
12875 }
12876 #endif
12877 __req->write_results();
12878 return true;
12879 }
12880 if( strcmp( __req->op_name(), "remove" ) == 0 ) {
12881
12882 if( !__req->read_args() )
12883 return true;
12884
12885 #ifdef HAVE_EXCEPTIONS
12886 try {
12887 #endif
12888 remove();
12889 #ifdef HAVE_EXCEPTIONS
12890 } catch( ::Components::RemoveFailure_catch &_ex ) {
12891 __req->set_exception( _ex->_clone() );
12892 __req->write_results();
12893 return true;
12894 }
12895 #endif
12896 __req->write_results();
12897 return true;
12898 }
12899 break;
12900 case 9:
12901 if( strcmp( __req->op_name(), "get_homes" ) == 0 ) {
12902 ::Components::CCMHomes* _res;
12903 CORBA::StaticAny __res( _marshaller__seq_Components_CCMHome );
12904 __req->set_result( &__res );
12905
12906 if( !__req->read_args() )
12907 return true;
12908
12909 _res = get_homes();
12910 __res.value( _marshaller__seq_Components_CCMHome, _res );
12911 __req->write_results();
12912 delete _res;
12913 return true;
12914 }
12915 break;
12916 case 10:
12917 if( strcmp( __req->op_name(), "_get_configuration" ) == 0 ) {
12918 ::Components::ConfigValues* _res;
12919 CORBA::StaticAny __res( _marshaller__seq_Components_ConfigValue );
12920 __req->set_result( &__res );
12921
12922 if( !__req->read_args() )
12923 return true;
12924
12925 _res = configuration();
12926 __res.value( _marshaller__seq_Components_ConfigValue, _res );
12927 __req->write_results();
12928 delete _res;
12929 return true;
12930 }
12931 break;
12932 }
12933 #ifdef HAVE_EXCEPTIONS
12934 } catch( CORBA::SystemException_catch &_ex ) {
12935 __req->set_exception( _ex->_clone() );
12936 __req->write_results();
12937 return true;
12938 } catch( ... ) {
12939 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
12940 __req->set_exception (_ex->_clone());
12941 __req->write_results ();
12942 return true;
12943 }
12944 #endif
12945
12946 return false;
12947 }
12948
12949 void
12950 POA_Components::Container::invoke (CORBA::StaticServerRequest_ptr __req)
12951 {
12952 if (dispatch (__req)) {
12953 return;
12954 }
12955
12956 CORBA::Exception * ex =
12957 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
12958 __req->set_exception (ex);
12959 __req->write_results();
12960 }
12961
12962
12963
12964 POA_Components::ComponentServer::~ComponentServer()
12965 {
12966 }
12967
12968 ::Components::ComponentServer_ptr
12969 POA_Components::ComponentServer::_this ()
12970 {
12971 CORBA::Object_var obj = PortableServer::ServantBase::_this();
12972 return ::Components::ComponentServer::_narrow (obj);
12973 }
12974
12975 CORBA::Boolean
12976 POA_Components::ComponentServer::_is_a (const char * repoid)
12977 {
12978 if (strcmp (repoid, "IDL:omg.org/Components/ComponentServer:1.0") == 0) {
12979 return TRUE;
12980 }
12981 return FALSE;
12982 }
12983
12984 CORBA::InterfaceDef_ptr
12985 POA_Components::ComponentServer::_get_interface ()
12986 {
12987 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/ComponentServer:1.0");
12988
12989 if (CORBA::is_nil (ifd)) {
12990 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
12991 }
12992
12993 return ifd;
12994 }
12995
12996 CORBA::RepositoryId
12997 POA_Components::ComponentServer::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
12998 {
12999 return CORBA::string_dup ("IDL:omg.org/Components/ComponentServer:1.0");
13000 }
13001
13002 CORBA::Object_ptr
13003 POA_Components::ComponentServer::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
13004 {
13005 return new ::Components::ComponentServer_stub_clp (poa, obj);
13006 }
13007
13008 bool
13009 POA_Components::ComponentServer::dispatch (CORBA::StaticServerRequest_ptr __req)
13010 {
13011 #ifdef HAVE_EXCEPTIONS
13012 try {
13013 #endif
13014 switch (mico_string_hash (__req->op_name(), 11)) {
13015 case 5:
13016 if( strcmp( __req->op_name(), "get_server_activator" ) == 0 ) {
13017 ::Components::ServerActivator_ptr _res;
13018 CORBA::StaticAny __res( _marshaller_Components_ServerActivator, &_res );
13019 __req->set_result( &__res );
13020
13021 if( !__req->read_args() )
13022 return true;
13023
13024 _res = get_server_activator();
13025 __req->write_results();
13026 CORBA::release( _res );
13027 return true;
13028 }
13029 if( strcmp( __req->op_name(), "remove_container" ) == 0 ) {
13030 ::Components::Container_var _par_cref;
13031 CORBA::StaticAny _sa_cref( _marshaller_Components_Container, &_par_cref._for_demarshal() );
13032
13033 __req->add_in_arg( &_sa_cref );
13034
13035 if( !__req->read_args() )
13036 return true;
13037
13038 #ifdef HAVE_EXCEPTIONS
13039 try {
13040 #endif
13041 remove_container( _par_cref.inout() );
13042 #ifdef HAVE_EXCEPTIONS
13043 } catch( ::Components::RemoveFailure_catch &_ex ) {
13044 __req->set_exception( _ex->_clone() );
13045 __req->write_results();
13046 return true;
13047 }
13048 #endif
13049 __req->write_results();
13050 return true;
13051 }
13052 break;
13053 case 7:
13054 if( strcmp( __req->op_name(), "create_container" ) == 0 ) {
13055 ::Components::ConfigValues _par_config;
13056 CORBA::StaticAny _sa_config( _marshaller__seq_Components_ConfigValue, &_par_config );
13057
13058 ::Components::Container_ptr _res;
13059 CORBA::StaticAny __res( _marshaller_Components_Container, &_res );
13060 __req->add_in_arg( &_sa_config );
13061 __req->set_result( &__res );
13062
13063 if( !__req->read_args() )
13064 return true;
13065
13066 #ifdef HAVE_EXCEPTIONS
13067 try {
13068 #endif
13069 _res = create_container( _par_config );
13070 #ifdef HAVE_EXCEPTIONS
13071 } catch( ::Components::CreateFailure_catch &_ex ) {
13072 __req->set_exception( _ex->_clone() );
13073 __req->write_results();
13074 return true;
13075 } catch( ::Components::InvalidConfiguration_catch &_ex ) {
13076 __req->set_exception( _ex->_clone() );
13077 __req->write_results();
13078 return true;
13079 }
13080 #endif
13081 __req->write_results();
13082 CORBA::release( _res );
13083 return true;
13084 }
13085 break;
13086 case 8:
13087 if( strcmp( __req->op_name(), "remove" ) == 0 ) {
13088
13089 if( !__req->read_args() )
13090 return true;
13091
13092 #ifdef HAVE_EXCEPTIONS
13093 try {
13094 #endif
13095 remove();
13096 #ifdef HAVE_EXCEPTIONS
13097 } catch( ::Components::RemoveFailure_catch &_ex ) {
13098 __req->set_exception( _ex->_clone() );
13099 __req->write_results();
13100 return true;
13101 }
13102 #endif
13103 __req->write_results();
13104 return true;
13105 }
13106 break;
13107 case 10:
13108 if( strcmp( __req->op_name(), "get_containers" ) == 0 ) {
13109 ::Components::Containers* _res;
13110 CORBA::StaticAny __res( _marshaller__seq_Components_Container );
13111 __req->set_result( &__res );
13112
13113 if( !__req->read_args() )
13114 return true;
13115
13116 _res = get_containers();
13117 __res.value( _marshaller__seq_Components_Container, _res );
13118 __req->write_results();
13119 delete _res;
13120 return true;
13121 }
13122 if( strcmp( __req->op_name(), "_get_configuration" ) == 0 ) {
13123 ::Components::ConfigValues* _res;
13124 CORBA::StaticAny __res( _marshaller__seq_Components_ConfigValue );
13125 __req->set_result( &__res );
13126
13127 if( !__req->read_args() )
13128 return true;
13129
13130 _res = configuration();
13131 __res.value( _marshaller__seq_Components_ConfigValue, _res );
13132 __req->write_results();
13133 delete _res;
13134 return true;
13135 }
13136 break;
13137 }
13138 #ifdef HAVE_EXCEPTIONS
13139 } catch( CORBA::SystemException_catch &_ex ) {
13140 __req->set_exception( _ex->_clone() );
13141 __req->write_results();
13142 return true;
13143 } catch( ... ) {
13144 CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
13145 __req->set_exception (_ex->_clone());
13146 __req->write_results ();
13147 return true;
13148 }
13149 #endif
13150
13151 return false;
13152 }
13153
13154 void
13155 POA_Components::ComponentServer::invoke (CORBA::StaticServerRequest_ptr __req)
13156 {
13157 if (dispatch (__req)) {
13158 return;
13159 }
13160
13161 CORBA::Exception * ex =
13162 new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
13163 __req->set_exception (ex);
13164 __req->write_results();
13165 }
13166
13167
13168
13169 POA_Components::ComponentInstallation::~ComponentInstallation()
13170 {
13171 }
13172
13173 ::Components::ComponentInstallation_ptr
13174 POA_Components::ComponentInstallation::_this ()
13175 {
13176 CORBA::Object_var obj = PortableServer::ServantBase::_this();
13177 return ::Components::ComponentInstallation::_narrow (obj);
13178 }
13179
13180 CORBA::Boolean
13181 POA_Components::ComponentInstallation::_is_a (const char * repoid)
13182 {
13183 if (strcmp (repoid, "IDL:omg.org/Components/ComponentInstallation:1.0") == 0) {
13184 return TRUE;
13185 }
13186 return FALSE;
13187 }
13188
13189 CORBA::InterfaceDef_ptr
13190 POA_Components::ComponentInstallation::_get_interface ()
13191 {
13192 CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:omg.org/Components/ComponentInstallation:1.0");
13193
13194 if (CORBA::is_nil (ifd)) {
13195 mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
13196 }
13197
13198 return ifd;
13199 }
13200
13201 CORBA::RepositoryId
13202 POA_Components::ComponentInstallation::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
13203 {
13204 return CORBA::string_dup ("IDL:omg.org/Components/ComponentInstallation:1.0");
13205 }
13206
13207 CORBA::Object_ptr
13208 POA_Components::ComponentInstallation::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
13209 {
13210 return new ::Components::ComponentInstallation_stub_clp (poa, obj);
13211 }
13212
13213 bool
13214 POA_Components::ComponentInstallation::dispatch (CORBA::StaticServerRequest_ptr __req)
13215 {
13216 #ifdef HAVE_EXCEPTIONS
13217 try {
13218 #endif
13219 switch (mico_string_hash (__req->op_name(), 7)) {
13220 case 0:
13221 if( strcmp( __req->op_name(), "replace" ) == 0 ) {
13222 ::Components::UUID_var _par_implUUID;
13223 CORBA::StaticAny _sa_implUUID( CORBA::_stc_string, &_par_implUUID._for_demarshal() );
13224 ::Components::Location_var _par_component_loc;
13225 CORBA::StaticAny _sa_component_loc( CORBA::_stc_string, &_par_component_loc._for_demarshal() );
13226
13227 __req->add_in_arg( &_sa_implUUID );
13228 __req->add_in_arg( &_sa_component_loc );
13229
13230 if( !__req->read_args() )
13231 return true;
13232
13233 #ifdef HAVE_EXCEPTIONS
13234 try {
13235 #endif
13236 replace( _par_implUUID.inout(), _par_component_loc.inout() );
13237 #ifdef HAVE_EXCEPTIONS
13238 } catch( ::Components::InvalidLocation_catch &_ex ) {
13239 __req->set_exception( _ex->_clone() );
13240 __req->write_results();
13241 return true;
13242 } catch( ::Components::InstallationFailure_catch &_ex ) {
13243 __req->set_exception( _ex->_clone() );
13244 __req->write_results();
13245 return true;
13246 }
13247 #endif
13248 __req->write_results();
13249 return true;
13250 }
13251 break;
13252 case 1:
13253 if( strcmp( __req->op_name(), "remove" ) == 0 ) {
13254 ::Components::UUID_var _par_implUUID;
13255 CORBA::StaticAny _sa_implUUID( CORBA::_stc_string, &_par_implUUID._for_demarshal() );
13256
13257 __req->add_in_arg( &_sa_implUUID );
13258
13259 if( !__req->read_args() )
13260 return true;
13261
13262 #ifdef HAVE_EXCEPTIONS
13263 try {
13264 #endif
13265 remove( _par_implUUID.inout() );
13266 #ifdef HAVE_EXCEPTIONS
13267 } catch( ::Components::UnknownImplId_catch &_ex ) {
13268 __req->set_exception( _ex->_clone() );
13269 __req->write_results();
13270 return true;
13271 } catch( ::Components::RemoveFailure_catch &_ex ) {
13272 __req->set_exception( _ex->_clone() );
13273 __req->write_results();
13274 return true;
13275 }
13276 #endif
13277 __req->write_results();
13278 return true;
13279 }
13280 if( strcmp( __req->op_name(), "get_implementation" ) == 0 ) {
13281 ::Components::UUID_var _par_implUUID;
13282 CORBA::StaticAny _sa_implUUID( CORBA::_stc_string, &_par_implUUID._for_demarshal() );
13283
13284 ::Components::Location _res;
13285 CORBA::StaticAny __res( CORBA::_stc_string, &_res );
13286 __req->add_in_arg( &_sa_implUUID );
13287 __req->set_result( &__res );
13288
13289 if( !__req->read_args() )
13290 return true;
13291
13292 #ifdef HAVE_EXCEPTIONS
13293 try {
13294 #endif
13295 _res = get_implementation( _par_implUUID.inout() );
13296 #ifdef HAVE_EXCEPTIONS
13297 } catch( ::Components::UnknownImplId_catch &_ex ) {
13298 __req->set_exception( _ex->_clone() );
13299 __req->write_results();
13300 return true;
13301 } catch( ::Components::InstallationFailure_catch &_ex ) {
13302 __req->set_exception( _ex->_clone() );
13303 __req->write_results();
13304 return true;
13305 }
13306 #endif
13307 __req->write_results();
13308 CORBA::string_free( _res );
13309 return true;
13310 }
13311 break;
13312 case 6:
13313 if( strcmp( __req->op_name(), "install" ) == 0 ) {
13314 ::Components::UUID_var _par_implUUID;
13315 CORBA::StaticAny _sa_implUUID( CORBA::_stc_string, &_par_implUUID._for_demarshal() );
13316 ::Components::Location_var _par_component_loc;
13317 CORBA::StaticAny _sa_component_loc( CORBA::_stc_string, &_par_component_loc._for_demarshal() );
13318
13319 __req->add_in_arg( &_sa_implUUID );
13320 __req->add_in_arg( &_sa_component_loc );
13321
13322 if( !__req->read_args() )
13323 return true;
13324
13325 #ifdef HAVE_EXCEPTIONS
13326 try {
13327 #endif
13328 install( _par_implUUID.inout(), _par_component_loc.inout() );
13329 #ifdef HAVE_EXCEPTIONS
13330 } catch( ::Components::InvalidLocation_catch &_ex ) {
13331 __req->set_exception( _ex->_clone() );
13332 __req->write_results();
13333 return true;
13334 &nb
