Helper.h (741 bytes)
HomeFinder.cpp (2.9k)
HomeFinder_Impl.cpp (3.2k)
HomeFinder_Impl.h (1.6k)
ccm.cpp (389.7k)
ccm.h (127.0k)
home.idl (11.9k)
home_old.idl (312 bytes)


more info here

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