1
2
3 #include "ccm.h"
4
5
6 using namespace std;
7
8
9
10
11
12
13
14 #ifdef HAVE_EXPLICIT_STRUCT_OPS
15 Components::InvalidName::InvalidName()
16 {
17 }
18
19 Components::InvalidName::InvalidName( const InvalidName& _s )
20 {
21 }
22
23 Components::InvalidName::~InvalidName()
24 {
25 }
26
27 Components::InvalidName&
28 Components::InvalidName::operator=( const InvalidName& _s )
29 {
30 return *this;
31 }
32 #endif
33
34 class _Marshaller_Components_InvalidName : public ::CORBA::StaticTypeInfo {
35 typedef ::Components::InvalidName _MICO_T;
36 public:
37 StaticValueType create () const;
38 void assign (StaticValueType dst, const StaticValueType src) const;
39 void free (StaticValueType) const;
40 ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
41 void marshal (::CORBA::DataEncoder &, StaticValueType) const;
42 };
43
44
45 ::CORBA::StaticValueType _Marshaller_Components_InvalidName::create() const
{
46 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 )
