1
2
3 #include <CORBA.h>
4 #include <mico/throw.h>
5
6 #ifndef __HOME_H__
7 #define __HOME_H__
8
9
10
11
12 namespace Components
13 {
14
15 class Navigation;
16 typedef Navigation *Navigation_ptr;
17 typedef Navigation_ptr NavigationRef;
18 typedef ObjVar< Navigation > Navigation_var;
19 typedef ObjOut< Navigation > Navigation_out;
20
21 class Receptacles;
22 typedef Receptacles *Receptacles_ptr;
23 typedef Receptacles_ptr ReceptaclesRef;
24 typedef ObjVar< Receptacles > Receptacles_var;
25 typedef ObjOut< Receptacles > Receptacles_out;
26
27 class EventConsumerBase;
28 typedef EventConsumerBase *EventConsumerBase_ptr;
29 typedef EventConsumerBase_ptr EventConsumerBaseRef;
30 typedef ObjVar< EventConsumerBase > EventConsumerBase_var;
31 typedef ObjOut< EventConsumerBase > EventConsumerBase_out;
32
33 class Events;
34 typedef Events *Events_ptr;
35 typedef Events_ptr EventsRef;
36 typedef ObjVar< Events > Events_var;
37 typedef ObjOut< Events > Events_out;
38
39 class CCMObject;
40 typedef CCMObject *CCMObject_ptr;
41 typedef CCMObject_ptr CCMObjectRef;
42 typedef ObjVar< CCMObject > CCMObject_var;
43 typedef ObjOut< CCMObject > CCMObject_out;
44
45 class CCMHome;
46 typedef CCMHome *CCMHome_ptr;
47 typedef CCMHome_ptr CCMHomeRef;
48 typedef ObjVar< CCMHome > CCMHome_var;
49 typedef ObjOut< CCMHome > CCMHome_out;
50
51 class KeylessCCMHome;
52 typedef KeylessCCMHome *KeylessCCMHome_ptr;
53 typedef KeylessCCMHome_ptr KeylessCCMHomeRef;
54 typedef ObjVar< KeylessCCMHome > KeylessCCMHome_var;
55 typedef ObjOut< KeylessCCMHome > KeylessCCMHome_out;
56
57 class HomeFinder;
58 typedef HomeFinder *HomeFinder_ptr;
59 typedef HomeFinder_ptr HomeFinderRef;
60 typedef ObjVar< HomeFinder > HomeFinder_var;
61 typedef ObjOut< HomeFinder > HomeFinder_out;
62
63 class Configurator;
64 typedef Configurator *Configurator_ptr;
65 typedef Configurator_ptr ConfiguratorRef;
66 typedef ObjVar< Configurator > Configurator_var;
67 typedef ObjOut< Configurator > Configurator_out;
68
69 class StandardConfigurator;
70 typedef StandardConfigurator *StandardConfigurator_ptr;
71 typedef StandardConfigurator_ptr StandardConfiguratorRef;
72 typedef ObjVar< StandardConfigurator > StandardConfigurator_var;
73 typedef ObjOut< StandardConfigurator > StandardConfigurator_out;
74
75 class CCMContext;
76 typedef CCMContext *CCMContext_ptr;
77 typedef CCMContext_ptr CCMContextRef;
78 typedef ObjVar< CCMContext > CCMContext_var;
79 typedef ObjOut< CCMContext > CCMContext_out;
80
81 class SessionContext;
82 typedef SessionContext *SessionContext_ptr;
83 typedef SessionContext_ptr SessionContextRef;
84 typedef ObjVar< SessionContext > SessionContext_var;
85 typedef ObjOut< SessionContext > SessionContext_out;
86
87 class EnterpriseComponent;
88 typedef EnterpriseComponent *EnterpriseComponent_ptr;
89 typedef EnterpriseComponent_ptr EnterpriseComponentRef;
90 typedef ObjVar< EnterpriseComponent > EnterpriseComponent_var;
91 typedef ObjOut< EnterpriseComponent > EnterpriseComponent_out;
92
93 class SessionComponent;
94 typedef SessionComponent *SessionComponent_ptr;
95 typedef SessionComponent_ptr SessionComponentRef;
96 typedef ObjVar< SessionComponent > SessionComponent_var;
97 typedef ObjOut< SessionComponent > SessionComponent_out;
98
99 class HomeExecutorBase;
100 typedef HomeExecutorBase *HomeExecutorBase_ptr;
101 typedef HomeExecutorBase_ptr HomeExecutorBaseRef;
102 typedef ObjVar< HomeExecutorBase > HomeExecutorBase_var;
103 typedef ObjOut< HomeExecutorBase > HomeExecutorBase_out;
104
105 class ExecutorLocator;
106 typedef ExecutorLocator *ExecutorLocator_ptr;
107 typedef ExecutorLocator_ptr ExecutorLocatorRef;
108 typedef ObjVar< ExecutorLocator > ExecutorLocator_var;
109 typedef ObjOut< ExecutorLocator > ExecutorLocator_out;
110
111 class ComponentServer;
112 typedef ComponentServer *ComponentServer_ptr;
113 typedef ComponentServer_ptr ComponentServerRef;
114 typedef ObjVar< ComponentServer > ComponentServer_var;
115 typedef ObjOut< ComponentServer > ComponentServer_out;
116
117 class Container;
118 typedef Container *Container_ptr;
119 typedef Container_ptr ContainerRef;
120 typedef ObjVar< Container > Container_var;
121 typedef ObjOut< Container > Container_out;
122
123 class ServerActivator;
124 typedef ServerActivator *ServerActivator_ptr;
125 typedef ServerActivator_ptr ServerActivatorRef;
126 typedef ObjVar< ServerActivator > ServerActivator_var;
127 typedef ObjOut< ServerActivator > ServerActivator_out;
128
129 class ComponentInstallation;
130 typedef ComponentInstallation *ComponentInstallation_ptr;
131 typedef ComponentInstallation_ptr ComponentInstallationRef;
132 typedef ObjVar< ComponentInstallation > ComponentInstallation_var;
133 typedef ObjOut< ComponentInstallation > ComponentInstallation_out;
134
135 class Assembly;
136 typedef Assembly *Assembly_ptr;
137 typedef Assembly_ptr AssemblyRef;
138 typedef ObjVar< Assembly > Assembly_var;
139 typedef ObjOut< Assembly > Assembly_out;
140
141 class AssemblyFactory;
142 typedef AssemblyFactory *AssemblyFactory_ptr;
143 typedef AssemblyFactory_ptr AssemblyFactoryRef;
144 typedef ObjVar< AssemblyFactory > AssemblyFactory_var;
145 typedef ObjOut< AssemblyFactory > AssemblyFactory_out;
146
147 }
148
149
150 namespace MICOCCM
151 {
152
153 class MicoCCMD;
154 typedef MicoCCMD *MicoCCMD_ptr;
155 typedef MicoCCMD_ptr MicoCCMDRef;
156 typedef ObjVar< MicoCCMD > MicoCCMD_var;
157 typedef ObjOut< MicoCCMD > MicoCCMD_out;
158
159 class ComponentServer;
160 typedef ComponentServer *ComponentServer_ptr;
161 typedef ComponentServer_ptr ComponentServerRef;
162 typedef ObjVar< ComponentServer > ComponentServer_var;
163 typedef ObjOut< ComponentServer > ComponentServer_out;
164
165 }
166
167
168 namespace HPI
169 {
170
171 class HomeFinder;
172 typedef HomeFinder *HomeFinder_ptr;
173 typedef HomeFinder_ptr HomeFinderRef;
174 typedef ObjVar< HomeFinder > HomeFinder_var;
175 typedef ObjOut< HomeFinder > HomeFinder_out;
176
177 }
178
179
180
181
182
183
184 namespace Components
185 {
186
187 typedef char* FeatureName;
188 typedef CORBA::String_var FeatureName_var;
189 typedef CORBA::String_out FeatureName_out;
190
191 typedef StringSequenceTmpl<CORBA::String_var> NameList;
192 typedef TSeqVar< StringSequenceTmpl<CORBA::String_var> > NameList_var;
193 typedef TSeqOut< StringSequenceTmpl<CORBA::String_var> > NameList_out;
194
195 struct InvalidName : public CORBA::UserException {
196 #ifdef HAVE_EXPLICIT_STRUCT_OPS
197 InvalidName();
198 ~InvalidName();
199 InvalidName( const InvalidName& s );
200 InvalidName& operator=( const InvalidName& s );
201 #endif //HAVE_EXPLICIT_STRUCT_OPS
202
203
204 #ifdef HAVE_STD_EH
205 InvalidName *operator->() { return this; }
206 InvalidName& operator*() { return *this; }
207 operator InvalidName*() { return this; }
208 #endif // HAVE_STD_EH
209
210 void _throwit() const;
211 const char *_repoid() const;
212 void _encode( CORBA::DataEncoder &en ) const;
213 void _encode_any( CORBA::Any &a ) const;
214 CORBA::Exception *_clone() const;
215 static InvalidName *_downcast( CORBA::Exception *ex );
216 static const InvalidName *_downcast( const CORBA::Exception *ex );
217 };
218
219 #ifdef HAVE_STD_EH
220 typedef InvalidName InvalidName_catch;
221 #else
222 typedef ExceptVar< InvalidName > InvalidName_var;
223 typedef TVarOut< InvalidName > InvalidName_out;
224 typedef InvalidName_var InvalidName_catch;
225 #endif // HAVE_STD_EH
226
227 struct InvalidConfiguration : public CORBA::UserException {
228 #ifdef HAVE_EXPLICIT_STRUCT_OPS
229 InvalidConfiguration();
230 ~InvalidConfiguration();
231 InvalidConfiguration( const InvalidConfiguration& s );
232 InvalidConfiguration& operator=( const InvalidConfiguration& s );
233 #endif //HAVE_EXPLICIT_STRUCT_OPS
234
235
236 #ifdef HAVE_STD_EH
237 InvalidConfiguration *operator->() { return this; }
238 InvalidConfiguration& operator*() { return *this; }
239 operator InvalidConfiguration*() { return this; }
240 #endif // HAVE_STD_EH
241
242 void _throwit() const;
243 const char *_repoid() const;
244 void _encode( CORBA::DataEncoder &en ) const;
245 void _encode_any( CORBA::Any &a ) const;
246 CORBA::Exception *_clone() const;
247 static InvalidConfiguration *_downcast( CORBA::Exception *ex );
248 static const InvalidConfiguration *_downcast( const CORBA::Exception *ex );
249 };
250
251 #ifdef HAVE_STD_EH
252 typedef InvalidConfiguration InvalidConfiguration_catch;
253 #else
254 typedef ExceptVar< InvalidConfiguration > InvalidConfiguration_var;
255 typedef TVarOut< InvalidConfiguration > InvalidConfiguration_out;
256 typedef InvalidConfiguration_var InvalidConfiguration_catch;
257 #endif // HAVE_STD_EH
258
259 struct AlreadyConnected : public CORBA::UserException {
260 #ifdef HAVE_EXPLICIT_STRUCT_OPS
261 AlreadyConnected();
262 ~AlreadyConnected();
263 AlreadyConnected( const AlreadyConnected& s );
264 AlreadyConnected& operator=( const AlreadyConnected& s );
265 #endif //HAVE_EXPLICIT_STRUCT_OPS
266
267
268 #ifdef HAVE_STD_EH
269 AlreadyConnected *operator->() { return this; }
270 AlreadyConnected& operator*() { return *this; }
271 operator AlreadyConnected*() { return this; }
272 #endif // HAVE_STD_EH
273
274 void _throwit() const;
275 const char *_repoid() const;
276 void _encode( CORBA::DataEncoder &en ) const;
277 void _encode_any( CORBA::Any &a ) const;
278 CORBA::Exception *_clone() const;
279 static AlreadyConnected *_downcast( CORBA::Exception *ex );
280 static const AlreadyConnected *_downcast( const CORBA::Exception *ex );
281 };
282
283 #ifdef HAVE_STD_EH
284 typedef AlreadyConnected AlreadyConnected_catch;
285 #else
286 typedef ExceptVar< AlreadyConnected > AlreadyConnected_var;
287 typedef TVarOut< AlreadyConnected > AlreadyConnected_out;
288 typedef AlreadyConnected_var AlreadyConnected_catch;
289 #endif // HAVE_STD_EH
290
291 struct InvalidConnection : public CORBA::UserException {
292 #ifdef HAVE_EXPLICIT_STRUCT_OPS
293 InvalidConnection();
294 ~InvalidConnection();
295 InvalidConnection( const InvalidConnection& s );
296 InvalidConnection& operator=( const InvalidConnection& s );
297 #endif //HAVE_EXPLICIT_STRUCT_OPS
298
299
300 #ifdef HAVE_STD_EH
301 InvalidConnection *operator->() { return this; }
302 InvalidConnection& operator*() { return *this; }
303 operator InvalidConnection*() { return this; }
304 #endif // HAVE_STD_EH
305
306 void _throwit() const;
307 const char *_repoid() const;
308 void _encode( CORBA::DataEncoder &en ) const;
309 void _encode_any( CORBA::Any &a ) const;
310 CORBA::Exception *_clone() const;
311 static InvalidConnection *_downcast( CORBA::Exception *ex );
312 static const InvalidConnection *_downcast( const CORBA::Exception *ex );
313 };
314
315 #ifdef HAVE_STD_EH
316 typedef InvalidConnection InvalidConnection_catch;
317 #else
318 typedef ExceptVar< InvalidConnection > InvalidConnection_var;
319 typedef TVarOut< InvalidConnection > InvalidConnection_out;
320 typedef InvalidConnection_var InvalidConnection_catch;
321 #endif // HAVE_STD_EH
322
323 struct NoConnection : public CORBA::UserException {
324 #ifdef HAVE_EXPLICIT_STRUCT_OPS
325 NoConnection();
326 ~NoConnection();
327 NoConnection( const NoConnection& s );
328 NoConnection& operator=( const NoConnection& s );
329 #endif //HAVE_EXPLICIT_STRUCT_OPS
330
331
332 #ifdef HAVE_STD_EH
333 NoConnection *operator->() { return this; }
334 NoConnection& operator*() { return *this; }
335 operator NoConnection*() { return this; }
336 #endif // HAVE_STD_EH
337
338 void _throwit() const;
339 const char *_repoid() const;
340 void _encode( CORBA::DataEncoder &en ) const;
341 void _encode_any( CORBA::Any &a ) const;
342 CORBA::Exception *_clone() const;
343 static NoConnection *_downcast( CORBA::Exception *ex );
344 static const NoConnection *_downcast( const CORBA::Exception *ex );
345 };
346
347 #ifdef HAVE_STD_EH
348 typedef NoConnection NoConnection_catch;
349 #else
350 typedef ExceptVar< NoConnection > NoConnection_var;
351 typedef TVarOut< NoConnection > NoConnection_out;
352 typedef NoConnection_var NoConnection_catch;
353 #endif // HAVE_STD_EH
354
355 struct ExceededConnectionLimit : public CORBA::UserException {
356 #ifdef HAVE_EXPLICIT_STRUCT_OPS
357 ExceededConnectionLimit();
358 ~ExceededConnectionLimit();
359 ExceededConnectionLimit( const ExceededConnectionLimit& s );
360 ExceededConnectionLimit& operator=( const ExceededConnectionLimit& s );
361 #endif //HAVE_EXPLICIT_STRUCT_OPS
362
363
364 #ifdef HAVE_STD_EH
365 ExceededConnectionLimit *operator->() { return this; }
366 ExceededConnectionLimit& operator*() { return *this; }
367 operator ExceededConnectionLimit*() { return this; }
368 #endif // HAVE_STD_EH
369
370 void _throwit() const;
371 const char *_repoid() const;
372 void _encode( CORBA::DataEncoder &en ) const;
373 void _encode_any( CORBA::Any &a ) const;
374 CORBA::Exception *_clone() const;
375 static ExceededConnectionLimit *_downcast( CORBA::Exception *ex );
376 static const ExceededConnectionLimit *_downcast( const CORBA::Exception *ex );
377 };
378
379 #ifdef HAVE_STD_EH
380 typedef ExceededConnectionLimit ExceededConnectionLimit_catch;
381 #else
382 typedef ExceptVar< ExceededConnectionLimit > ExceededConnectionLimit_var;
383 typedef TVarOut< ExceededConnectionLimit > ExceededConnectionLimit_out;
384 typedef ExceededConnectionLimit_var ExceededConnectionLimit_catch;
385 #endif // HAVE_STD_EH
386
387 struct CookieRequired : public CORBA::UserException {
388 #ifdef HAVE_EXPLICIT_STRUCT_OPS
389 CookieRequired();
390 ~CookieRequired();
391 CookieRequired( const CookieRequired& s );
392 CookieRequired& operator=( const CookieRequired& s );
393 #endif //HAVE_EXPLICIT_STRUCT_OPS
394
395
396 #ifdef HAVE_STD_EH
397 CookieRequired *operator->() { return this; }
398 CookieRequired& operator*() { return *this; }
399 operator CookieRequired*() { return this; }
400 #endif // HAVE_STD_EH
401
402 void _throwit() const;
403 const char *_repoid() const;
404 void _encode( CORBA::DataEncoder &en ) const;
405 void _encode_any( CORBA::Any &a ) const;
406 CORBA::Exception *_clone() const;
407 static CookieRequired *_downcast( CORBA::Exception *ex );
408 static const CookieRequired *_downcast( const CORBA::Exception *ex );
409 };
410
411 #ifdef HAVE_STD_EH
412 typedef CookieRequired CookieRequired_catch;
413 #else
414 typedef ExceptVar< CookieRequired > CookieRequired_var;
415 typedef TVarOut< CookieRequired > CookieRequired_out;
416 typedef CookieRequired_var CookieRequired_catch;
417 #endif // HAVE_STD_EH
418
419 class PortDescription;
420 typedef PortDescription *PortDescription_ptr;
421 typedef PortDescription_ptr PortDescriptionRef;
422 typedef ValueVar< PortDescription > PortDescription_var;
423 typedef ValueOut< PortDescription > PortDescription_out;
424
425
426
427 class PortDescription :
428 virtual public CORBA::ValueBase
429 {
430 public:
431 static PortDescription* _downcast (CORBA::ValueBase *);
432 static PortDescription* _downcast (CORBA::AbstractBase *);
433
434 virtual void name( char *_p ) = 0;
435 virtual void name( const char *_p ) = 0;
436 virtual void name( const CORBA::String_var &_p ) = 0;
437 virtual const char *name() const = 0;
438
439 virtual void type_id( char *_p ) = 0;
440 virtual void type_id( const char *_p ) = 0;
441 virtual void type_id( const CORBA::String_var &_p ) = 0;
442 virtual const char *type_id() const = 0;
443
444
445 public:
446 CORBA::ValueBase * _copy_value ();
447 CORBA::ValueDef_ptr get_value_def ();
448 virtual void * _narrow_helper (const char *);
449 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
450 void _marshal_members (CORBA::DataEncoder &);
451 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
452
453 protected:
454 PortDescription ();
455 virtual ~PortDescription ();
456 void _copy_members (const PortDescription&);
457
458 private:
459 PortDescription (const PortDescription &);
460 void operator= (const PortDescription &);
461 };
462
463 class Cookie;
464 typedef Cookie *Cookie_ptr;
465 typedef Cookie_ptr CookieRef;
466 typedef ValueVar< Cookie > Cookie_var;
467 typedef ValueOut< Cookie > Cookie_out;
468
469
470
471 class Cookie :
472 virtual public CORBA::ValueBase
473 {
474 public:
475 static Cookie* _downcast (CORBA::ValueBase *);
476 static Cookie* _downcast (CORBA::AbstractBase *);
477
478 typedef SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> _CookieValue_seq;
479 virtual void CookieValue( const _CookieValue_seq & _p) = 0;
480 virtual const _CookieValue_seq & CookieValue() const = 0;
481 virtual _CookieValue_seq & CookieValue() = 0;
482
483
484 public:
485 CORBA::ValueBase * _copy_value ();
486 CORBA::ValueDef_ptr get_value_def ();
487 virtual void * _narrow_helper (const char *);
488 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
489 void _marshal_members (CORBA::DataEncoder &);
490 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
491
492 protected:
493 Cookie ();
494 virtual ~Cookie ();
495 void _copy_members (const Cookie&);
496
497 private:
498 Cookie (const Cookie &);
499 void operator= (const Cookie &);
500 };
501
502 class EventBase;
503 typedef EventBase *EventBase_ptr;
504 typedef EventBase_ptr EventBaseRef;
505 typedef ValueVar< EventBase > EventBase_var;
506 typedef ValueOut< EventBase > EventBase_out;
507
508
509
510 class EventBase :
511 virtual public CORBA::ValueBase
512 {
513 public:
514 static EventBase* _downcast (CORBA::ValueBase *);
515 static EventBase* _downcast (CORBA::AbstractBase *);
516
517 public:
518 CORBA::ValueDef_ptr get_value_def ();
519 virtual void * _narrow_helper (const char *);
520 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
521 void _marshal_members (CORBA::DataEncoder &);
522 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
523
524 protected:
525 EventBase ();
526 virtual ~EventBase ();
527
528 private:
529 EventBase (const EventBase &);
530 void operator= (const EventBase &);
531 };
532
533 class FacetDescription;
534 typedef FacetDescription *FacetDescription_ptr;
535 typedef FacetDescription_ptr FacetDescriptionRef;
536 typedef ValueVar< FacetDescription > FacetDescription_var;
537 typedef ValueOut< FacetDescription > FacetDescription_out;
538
539
540
541 class FacetDescription :
542 virtual public ::Components::PortDescription
543 {
544 public:
545 static FacetDescription* _downcast (CORBA::ValueBase *);
546 static FacetDescription* _downcast (CORBA::AbstractBase *);
547
548 virtual void facet_ref( CORBA::Object_ptr _p ) = 0;
549 virtual CORBA::Object_ptr facet_ref() const = 0;
550
551
552 public:
553 CORBA::ValueBase * _copy_value ();
554 CORBA::ValueDef_ptr get_value_def ();
555 virtual void * _narrow_helper (const char *);
556 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
557 void _marshal_members (CORBA::DataEncoder &);
558 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
559
560 protected:
561 FacetDescription ();
562 virtual ~FacetDescription ();
563 void _copy_members (const FacetDescription&);
564
565 private:
566 FacetDescription (const FacetDescription &);
567 void operator= (const FacetDescription &);
568 };
569
570 typedef SequenceTmpl< FacetDescription_var,MICO_TID_DEF> FacetDescriptions;
571 typedef TSeqVar< SequenceTmpl< FacetDescription_var,MICO_TID_DEF> > FacetDescriptions_var;
572 typedef TSeqOut< SequenceTmpl< FacetDescription_var,MICO_TID_DEF> > FacetDescriptions_out;
573
574
575
576
577 class Navigation :
578 virtual public CORBA::Object
579 {
580 public:
581 virtual ~Navigation();
582
583 #ifdef HAVE_TYPEDEF_OVERLOAD
584 typedef Navigation_ptr _ptr_type;
585 typedef Navigation_var _var_type;
586 #endif
587
588 static Navigation_ptr _narrow( CORBA::Object_ptr obj );
589 static Navigation_ptr _narrow( CORBA::AbstractBase_ptr obj );
590 static Navigation_ptr _duplicate( Navigation_ptr _obj )
591 {
592 CORBA::Object::_duplicate (_obj);
593 return _obj;
594 }
595
596 static Navigation_ptr _nil()
597 {
598 return 0;
599 }
600
601 virtual void *_narrow_helper( const char *repoid );
602
603 virtual CORBA::Object_ptr provide_facet( const char* name ) = 0;
604 virtual FacetDescriptions* get_all_facets() = 0;
605 virtual FacetDescriptions* get_named_facets( const NameList& names ) = 0;
606 virtual CORBA::Boolean same_component( CORBA::Object_ptr ref ) = 0;
607
608 protected:
609 Navigation() {};
610 private:
611 Navigation( const Navigation& );
612 void operator=( const Navigation& );
613 };
614
615
616 class Navigation_stub:
617 virtual public Navigation
618 {
619 public:
620 virtual ~Navigation_stub();
621 CORBA::Object_ptr provide_facet( const char* name );
622 FacetDescriptions* get_all_facets();
623 FacetDescriptions* get_named_facets( const NameList& names );
624 CORBA::Boolean same_component( CORBA::Object_ptr ref );
625
626 private:
627 void operator=( const Navigation_stub& );
628 };
629
630 #ifndef MICO_CONF_NO_POA
631
632 class Navigation_stub_clp :
633 virtual public Navigation_stub,
634 virtual public PortableServer::StubBase
635 {
636 public:
637 Navigation_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
638 virtual ~Navigation_stub_clp ();
639 CORBA::Object_ptr provide_facet( const char* name );
640 FacetDescriptions* get_all_facets();
641 FacetDescriptions* get_named_facets( const NameList& names );
642 CORBA::Boolean same_component( CORBA::Object_ptr ref );
643
644 protected:
645 Navigation_stub_clp ();
646 private:
647 void operator=( const Navigation_stub_clp & );
648 };
649
650 #endif // MICO_CONF_NO_POA
651
652 class ConnectionDescription;
653 typedef ConnectionDescription *ConnectionDescription_ptr;
654 typedef ConnectionDescription_ptr ConnectionDescriptionRef;
655 typedef ValueVar< ConnectionDescription > ConnectionDescription_var;
656 typedef ValueOut< ConnectionDescription > ConnectionDescription_out;
657
658
659
660 class ConnectionDescription :
661 virtual public CORBA::ValueBase
662 {
663 public:
664 static ConnectionDescription* _downcast (CORBA::ValueBase *);
665 static ConnectionDescription* _downcast (CORBA::AbstractBase *);
666
667 virtual void ck( Cookie* _p ) = 0;
668 virtual Cookie* ck() const = 0;
669
670 virtual void objref( CORBA::Object_ptr _p ) = 0;
671 virtual CORBA::Object_ptr objref() const = 0;
672
673
674 public:
675 CORBA::ValueBase * _copy_value ();
676 CORBA::ValueDef_ptr get_value_def ();
677 virtual void * _narrow_helper (const char *);
678 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
679 void _marshal_members (CORBA::DataEncoder &);
680 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
681
682 protected:
683 ConnectionDescription ();
684 virtual ~ConnectionDescription ();
685 void _copy_members (const ConnectionDescription&);
686
687 private:
688 ConnectionDescription (const ConnectionDescription &);
689 void operator= (const ConnectionDescription &);
690 };
691
692 typedef SequenceTmpl< ConnectionDescription_var,MICO_TID_DEF> ConnectionDescriptions;
693 typedef TSeqVar< SequenceTmpl< ConnectionDescription_var,MICO_TID_DEF> > ConnectionDescriptions_var;
694 typedef TSeqOut< SequenceTmpl< ConnectionDescription_var,MICO_TID_DEF> > ConnectionDescriptions_out;
695
696 class ReceptacleDescription;
697 typedef ReceptacleDescription *ReceptacleDescription_ptr;
698 typedef ReceptacleDescription_ptr ReceptacleDescriptionRef;
699 typedef ValueVar< ReceptacleDescription > ReceptacleDescription_var;
700 typedef ValueOut< ReceptacleDescription > ReceptacleDescription_out;
701
702
703
704 class ReceptacleDescription :
705 virtual public ::Components::PortDescription
706 {
707 public:
708 static ReceptacleDescription* _downcast (CORBA::ValueBase *);
709 static ReceptacleDescription* _downcast (CORBA::AbstractBase *);
710
711 virtual void is_multiplex( CORBA::Boolean _p ) = 0;
712 virtual CORBA::Boolean is_multiplex() const = 0;
713
714 virtual void connections( const ConnectionDescriptions& _p ) = 0;
715 virtual const ConnectionDescriptions& connections() const = 0;
716 virtual ConnectionDescriptions& connections() = 0;
717
718
719 public:
720 CORBA::ValueBase * _copy_value ();
721 CORBA::ValueDef_ptr get_value_def ();
722 virtual void * _narrow_helper (const char *);
723 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
724 void _marshal_members (CORBA::DataEncoder &);
725 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
726
727 protected:
728 ReceptacleDescription ();
729 virtual ~ReceptacleDescription ();
730 void _copy_members (const ReceptacleDescription&);
731
732 private:
733 ReceptacleDescription (const ReceptacleDescription &);
734 void operator= (const ReceptacleDescription &);
735 };
736
737 typedef SequenceTmpl< ReceptacleDescription_var,MICO_TID_DEF> ReceptacleDescriptions;
738 typedef TSeqVar< SequenceTmpl< ReceptacleDescription_var,MICO_TID_DEF> > ReceptacleDescriptions_var;
739 typedef TSeqOut< SequenceTmpl< ReceptacleDescription_var,MICO_TID_DEF> > ReceptacleDescriptions_out;
740
741
742
743
744 class Receptacles :
745 virtual public CORBA::Object
746 {
747 public:
748 virtual ~Receptacles();
749
750 #ifdef HAVE_TYPEDEF_OVERLOAD
751 typedef Receptacles_ptr _ptr_type;
752 typedef Receptacles_var _var_type;
753 #endif
754
755 static Receptacles_ptr _narrow( CORBA::Object_ptr obj );
756 static Receptacles_ptr _narrow( CORBA::AbstractBase_ptr obj );
757 static Receptacles_ptr _duplicate( Receptacles_ptr _obj )
758 {
759 CORBA::Object::_duplicate (_obj);
760 return _obj;
761 }
762
763 static Receptacles_ptr _nil()
764 {
765 return 0;
766 }
767
768 virtual void *_narrow_helper( const char *repoid );
769
770 virtual Cookie* connect( const char* name, CORBA::Object_ptr connection ) = 0;
771 virtual void disconnect( const char* name, Cookie* ck ) = 0;
772 virtual ConnectionDescriptions* get_connections( const char* name ) = 0;
773 virtual ReceptacleDescriptions* get_all_receptacles() = 0;
774 virtual ReceptacleDescriptions* get_named_receptacles( const NameList& names ) = 0;
775
776 protected:
777 Receptacles() {};
778 private:
779 Receptacles( const Receptacles& );
780 void operator=( const Receptacles& );
781 };
782
783
784 class Receptacles_stub:
785 virtual public Receptacles
786 {
787 public:
788 virtual ~Receptacles_stub();
789 Cookie* connect( const char* name, CORBA::Object_ptr connection );
790 void disconnect( const char* name, Cookie* ck );
791 ConnectionDescriptions* get_connections( const char* name );
792 ReceptacleDescriptions* get_all_receptacles();
793 ReceptacleDescriptions* get_named_receptacles( const NameList& names );
794
795 private:
796 void operator=( const Receptacles_stub& );
797 };
798
799 #ifndef MICO_CONF_NO_POA
800
801 class Receptacles_stub_clp :
802 virtual public Receptacles_stub,
803 virtual public PortableServer::StubBase
804 {
805 public:
806 Receptacles_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
807 virtual ~Receptacles_stub_clp ();
808 Cookie* connect( const char* name, CORBA::Object_ptr connection );
809 void disconnect( const char* name, Cookie* ck );
810 ConnectionDescriptions* get_connections( const char* name );
811 ReceptacleDescriptions* get_all_receptacles();
812 ReceptacleDescriptions* get_named_receptacles( const NameList& names );
813
814 protected:
815 Receptacles_stub_clp ();
816 private:
817 void operator=( const Receptacles_stub_clp & );
818 };
819
820 #endif // MICO_CONF_NO_POA
821
822 struct BadEventType : public CORBA::UserException {
823 #ifdef HAVE_EXPLICIT_STRUCT_OPS
824 BadEventType();
825 ~BadEventType();
826 BadEventType( const BadEventType& s );
827 BadEventType& operator=( const BadEventType& s );
828 #endif //HAVE_EXPLICIT_STRUCT_OPS
829
830 #ifndef HAVE_EXPLICIT_STRUCT_OPS
831 BadEventType();
832 #endif //HAVE_EXPLICIT_STRUCT_OPS
833 BadEventType( const char* _m0 );
834
835 #ifdef HAVE_STD_EH
836 BadEventType *operator->() { return this; }
837 BadEventType& operator*() { return *this; }
838 operator BadEventType*() { return this; }
839 #endif // HAVE_STD_EH
840
841 void _throwit() const;
842 const char *_repoid() const;
843 void _encode( CORBA::DataEncoder &en ) const;
844 void _encode_any( CORBA::Any &a ) const;
845 CORBA::Exception *_clone() const;
846 static BadEventType *_downcast( CORBA::Exception *ex );
847 static const BadEventType *_downcast( const CORBA::Exception *ex );
848 CORBA::String_var expected_event_type;
849 };
850
851 #ifdef HAVE_STD_EH
852 typedef BadEventType BadEventType_catch;
853 #else
854 typedef ExceptVar< BadEventType > BadEventType_var;
855 typedef TVarOut< BadEventType > BadEventType_out;
856 typedef BadEventType_var BadEventType_catch;
857 #endif // HAVE_STD_EH
858
859
860
861
862 class EventConsumerBase :
863 virtual public CORBA::Object
864 {
865 public:
866 virtual ~EventConsumerBase();
867
868 #ifdef HAVE_TYPEDEF_OVERLOAD
869 typedef EventConsumerBase_ptr _ptr_type;
870 typedef EventConsumerBase_var _var_type;
871 #endif
872
873 static EventConsumerBase_ptr _narrow( CORBA::Object_ptr obj );
874 static EventConsumerBase_ptr _narrow( CORBA::AbstractBase_ptr obj );
875 static EventConsumerBase_ptr _duplicate( EventConsumerBase_ptr _obj )
876 {
877 CORBA::Object::_duplicate (_obj);
878 return _obj;
879 }
880
881 static EventConsumerBase_ptr _nil()
882 {
883 return 0;
884 }
885
886 virtual void *_narrow_helper( const char *repoid );
887
888 virtual void push_event( EventBase* evt ) = 0;
889
890 protected:
891 EventConsumerBase() {};
892 private:
893 EventConsumerBase( const EventConsumerBase& );
894 void operator=( const EventConsumerBase& );
895 };
896
897
898 class EventConsumerBase_stub:
899 virtual public EventConsumerBase
900 {
901 public:
902 virtual ~EventConsumerBase_stub();
903 void push_event( EventBase* evt );
904
905 private:
906 void operator=( const EventConsumerBase_stub& );
907 };
908
909 #ifndef MICO_CONF_NO_POA
910
911 class EventConsumerBase_stub_clp :
912 virtual public EventConsumerBase_stub,
913 virtual public PortableServer::StubBase
914 {
915 public:
916 EventConsumerBase_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
917 virtual ~EventConsumerBase_stub_clp ();
918 void push_event( EventBase* evt );
919
920 protected:
921 EventConsumerBase_stub_clp ();
922 private:
923 void operator=( const EventConsumerBase_stub_clp & );
924 };
925
926 #endif // MICO_CONF_NO_POA
927
928 class ConsumerDescription;
929 typedef ConsumerDescription *ConsumerDescription_ptr;
930 typedef ConsumerDescription_ptr ConsumerDescriptionRef;
931 typedef ValueVar< ConsumerDescription > ConsumerDescription_var;
932 typedef ValueOut< ConsumerDescription > ConsumerDescription_out;
933
934
935
936 class ConsumerDescription :
937 virtual public ::Components::PortDescription
938 {
939 public:
940 static ConsumerDescription* _downcast (CORBA::ValueBase *);
941 static ConsumerDescription* _downcast (CORBA::AbstractBase *);
942
943 virtual void consumer( EventConsumerBase_ptr _p ) = 0;
944 virtual EventConsumerBase_ptr consumer() const = 0;
945
946
947 public:
948 CORBA::ValueBase * _copy_value ();
949 CORBA::ValueDef_ptr get_value_def ();
950 virtual void * _narrow_helper (const char *);
951 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
952 void _marshal_members (CORBA::DataEncoder &);
953 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
954
955 protected:
956 ConsumerDescription ();
957 virtual ~ConsumerDescription ();
958 void _copy_members (const ConsumerDescription&);
959
960 private:
961 ConsumerDescription (const ConsumerDescription &);
962 void operator= (const ConsumerDescription &);
963 };
964
965 typedef SequenceTmpl< ConsumerDescription_var,MICO_TID_DEF> ConsumerDescriptions;
966 typedef TSeqVar< SequenceTmpl< ConsumerDescription_var,MICO_TID_DEF> > ConsumerDescriptions_var;
967 typedef TSeqOut< SequenceTmpl< ConsumerDescription_var,MICO_TID_DEF> > ConsumerDescriptions_out;
968
969 class EmitterDescription;
970 typedef EmitterDescription *EmitterDescription_ptr;
971 typedef EmitterDescription_ptr EmitterDescriptionRef;
972 typedef ValueVar< EmitterDescription > EmitterDescription_var;
973 typedef ValueOut< EmitterDescription > EmitterDescription_out;
974
975
976
977 class EmitterDescription :
978 virtual public ::Components::PortDescription
979 {
980 public:
981 static EmitterDescription* _downcast (CORBA::ValueBase *);
982 static EmitterDescription* _downcast (CORBA::AbstractBase *);
983
984 virtual void consumer( EventConsumerBase_ptr _p ) = 0;
985 virtual EventConsumerBase_ptr consumer() const = 0;
986
987
988 public:
989 CORBA::ValueBase * _copy_value ();
990 CORBA::ValueDef_ptr get_value_def ();
991 virtual void * _narrow_helper (const char *);
992 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
993 void _marshal_members (CORBA::DataEncoder &);
994 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
995
996 protected:
997 EmitterDescription ();
998 virtual ~EmitterDescription ();
999 void _copy_members (const EmitterDescription&);
1000
1001 private:
1002 EmitterDescription (const EmitterDescription &);
1003 void operator= (const EmitterDescription &);
1004 };
1005
1006 typedef SequenceTmpl< EmitterDescription_var,MICO_TID_DEF> EmitterDescriptions;
1007 typedef TSeqVar< SequenceTmpl< EmitterDescription_var,MICO_TID_DEF> > EmitterDescriptions_var;
1008 typedef TSeqOut< SequenceTmpl< EmitterDescription_var,MICO_TID_DEF> > EmitterDescriptions_out;
1009
1010 class SubscriberDescription;
1011 typedef SubscriberDescription *SubscriberDescription_ptr;
1012 typedef SubscriberDescription_ptr SubscriberDescriptionRef;
1013 typedef ValueVar< SubscriberDescription > SubscriberDescription_var;
1014 typedef ValueOut< SubscriberDescription > SubscriberDescription_out;
1015
1016
1017
1018 class SubscriberDescription :
1019 virtual public CORBA::ValueBase
1020 {
1021 public:
1022 static SubscriberDescription* _downcast (CORBA::ValueBase *);
1023 static SubscriberDescription* _downcast (CORBA::AbstractBase *);
1024
1025 virtual void ck( Cookie* _p ) = 0;
1026 virtual Cookie* ck() const = 0;
1027
1028 virtual void consumer( EventConsumerBase_ptr _p ) = 0;
1029 virtual EventConsumerBase_ptr consumer() const = 0;
1030
1031
1032 public:
1033 CORBA::ValueBase * _copy_value ();
1034 CORBA::ValueDef_ptr get_value_def ();
1035 virtual void * _narrow_helper (const char *);
1036 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
1037 void _marshal_members (CORBA::DataEncoder &);
1038 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
1039
1040 protected:
1041 SubscriberDescription ();
1042 virtual ~SubscriberDescription ();
1043 void _copy_members (const SubscriberDescription&);
1044
1045 private:
1046 SubscriberDescription (const SubscriberDescription &);
1047 void operator= (const SubscriberDescription &);
1048 };
1049
1050 typedef SequenceTmpl< SubscriberDescription_var,MICO_TID_DEF> SubscriberDescriptions;
1051 typedef TSeqVar< SequenceTmpl< SubscriberDescription_var,MICO_TID_DEF> > SubscriberDescriptions_var;
1052 typedef TSeqOut< SequenceTmpl< SubscriberDescription_var,MICO_TID_DEF> > SubscriberDescriptions_out;
1053
1054 class PublisherDescription;
1055 typedef PublisherDescription *PublisherDescription_ptr;
1056 typedef PublisherDescription_ptr PublisherDescriptionRef;
1057 typedef ValueVar< PublisherDescription > PublisherDescription_var;
1058 typedef ValueOut< PublisherDescription > PublisherDescription_out;
1059
1060
1061
1062 class PublisherDescription :
1063 virtual public ::Components::PortDescription
1064 {
1065 public:
1066 static PublisherDescription* _downcast (CORBA::ValueBase *);
1067 static PublisherDescription* _downcast (CORBA::AbstractBase *);
1068
1069 virtual void consumers( const SubscriberDescriptions& _p ) = 0;
1070 virtual const SubscriberDescriptions& consumers() const = 0;
1071 virtual SubscriberDescriptions& consumers() = 0;
1072
1073
1074 public:
1075 CORBA::ValueBase * _copy_value ();
1076 CORBA::ValueDef_ptr get_value_def ();
1077 virtual void * _narrow_helper (const char *);
1078 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
1079 void _marshal_members (CORBA::DataEncoder &);
1080 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
1081
1082 protected:
1083 PublisherDescription ();
1084 virtual ~PublisherDescription ();
1085 void _copy_members (const PublisherDescription&);
1086
1087 private:
1088 PublisherDescription (const PublisherDescription &);
1089 void operator= (const PublisherDescription &);
1090 };
1091
1092 typedef SequenceTmpl< PublisherDescription_var,MICO_TID_DEF> PublisherDescriptions;
1093 typedef TSeqVar< SequenceTmpl< PublisherDescription_var,MICO_TID_DEF> > PublisherDescriptions_var;
1094 typedef TSeqOut< SequenceTmpl< PublisherDescription_var,MICO_TID_DEF> > PublisherDescriptions_out;
1095
1096
1097
1098
1099 class Events :
1100 virtual public CORBA::Object
1101 {
1102 public:
1103 virtual ~Events();
1104
1105 #ifdef HAVE_TYPEDEF_OVERLOAD
1106 typedef Events_ptr _ptr_type;
1107 typedef Events_var _var_type;
1108 #endif
1109
1110 static Events_ptr _narrow( CORBA::Object_ptr obj );
1111 static Events_ptr _narrow( CORBA::AbstractBase_ptr obj );
1112 static Events_ptr _duplicate( Events_ptr _obj )
1113 {
1114 CORBA::Object::_duplicate (_obj);
1115 return _obj;
1116 }
1117
1118 static Events_ptr _nil()
1119 {
1120 return 0;
1121 }
1122
1123 virtual void *_narrow_helper( const char *repoid );
1124
1125 virtual EventConsumerBase_ptr get_consumer( const char* sink_name ) = 0;
1126 virtual ConsumerDescriptions* get_all_consumers() = 0;
1127 virtual ConsumerDescriptions* get_named_consumers( const NameList& names ) = 0;
1128 virtual Cookie* subscribe( const char* publisher_name, EventConsumerBase_ptr subscriber ) = 0;
1129 virtual void unsubscribe( const char* publisher_name, Cookie* ck ) = 0;
1130 virtual PublisherDescriptions* get_all_publishers() = 0;
1131 virtual PublisherDescriptions* get_named_publishers( const NameList& names ) = 0;
1132 virtual void connect_consumer( const char* emitter_name, EventConsumerBase_ptr consumer ) = 0;
1133 virtual EventConsumerBase_ptr disconnect_consumer( const char* source_name ) = 0;
1134 virtual EmitterDescriptions* get_all_emitters() = 0;
1135 virtual EmitterDescriptions* get_named_emitters( const NameList& names ) = 0;
1136
1137 protected:
1138 Events() {};
1139 private:
1140 Events( const Events& );
1141 void operator=( const Events& );
1142 };
1143
1144
1145 class Events_stub:
1146 virtual public Events
1147 {
1148 public:
1149 virtual ~Events_stub();
1150 EventConsumerBase_ptr get_consumer( const char* sink_name );
1151 ConsumerDescriptions* get_all_consumers();
1152 ConsumerDescriptions* get_named_consumers( const NameList& names );
1153 Cookie* subscribe( const char* publisher_name, EventConsumerBase_ptr subscriber );
1154 void unsubscribe( const char* publisher_name, Cookie* ck );
1155 PublisherDescriptions* get_all_publishers();
1156 PublisherDescriptions* get_named_publishers( const NameList& names );
1157 void connect_consumer( const char* emitter_name, EventConsumerBase_ptr consumer );
1158 EventConsumerBase_ptr disconnect_consumer( const char* source_name );
1159 EmitterDescriptions* get_all_emitters();
1160 EmitterDescriptions* get_named_emitters( const NameList& names );
1161
1162 private:
1163 void operator=( const Events_stub& );
1164 };
1165
1166 #ifndef MICO_CONF_NO_POA
1167
1168 class Events_stub_clp :
1169 virtual public Events_stub,
1170 virtual public PortableServer::StubBase
1171 {
1172 public:
1173 Events_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1174 virtual ~Events_stub_clp ();
1175 EventConsumerBase_ptr get_consumer( const char* sink_name );
1176 ConsumerDescriptions* get_all_consumers();
1177 ConsumerDescriptions* get_named_consumers( const NameList& names );
1178 Cookie* subscribe( const char* publisher_name, EventConsumerBase_ptr subscriber );
1179 void unsubscribe( const char* publisher_name, Cookie* ck );
1180 PublisherDescriptions* get_all_publishers();
1181 PublisherDescriptions* get_named_publishers( const NameList& names );
1182 void connect_consumer( const char* emitter_name, EventConsumerBase_ptr consumer );
1183 EventConsumerBase_ptr disconnect_consumer( const char* source_name );
1184 EmitterDescriptions* get_all_emitters();
1185 EmitterDescriptions* get_named_emitters( const NameList& names );
1186
1187 protected:
1188 Events_stub_clp ();
1189 private:
1190 void operator=( const Events_stub_clp & );
1191 };
1192
1193 #endif // MICO_CONF_NO_POA
1194
1195
1196
1197
1198 class CCMHome :
1199 virtual public CORBA::Object
1200 {
1201 public:
1202 virtual ~CCMHome();
1203
1204 #ifdef HAVE_TYPEDEF_OVERLOAD
1205 typedef CCMHome_ptr _ptr_type;
1206 typedef CCMHome_var _var_type;
1207 #endif
1208
1209 static CCMHome_ptr _narrow( CORBA::Object_ptr obj );
1210 static CCMHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
1211 static CCMHome_ptr _duplicate( CCMHome_ptr _obj )
1212 {
1213 CORBA::Object::_duplicate (_obj);
1214 return _obj;
1215 }
1216
1217 static CCMHome_ptr _nil()
1218 {
1219 return 0;
1220 }
1221
1222 virtual void *_narrow_helper( const char *repoid );
1223
1224 virtual CORBA::Object_ptr get_component_def() = 0;
1225 virtual CORBA::Object_ptr get_home_def() = 0;
1226 virtual void remove_component( CCMObject_ptr comp ) = 0;
1227
1228 protected:
1229 CCMHome() {};
1230 private:
1231 CCMHome( const CCMHome& );
1232 void operator=( const CCMHome& );
1233 };
1234
1235
1236 class CCMHome_stub:
1237 virtual public CCMHome
1238 {
1239 public:
1240 virtual ~CCMHome_stub();
1241 CORBA::Object_ptr get_component_def();
1242 CORBA::Object_ptr get_home_def();
1243 void remove_component( CCMObject_ptr comp );
1244
1245 private:
1246 void operator=( const CCMHome_stub& );
1247 };
1248
1249 #ifndef MICO_CONF_NO_POA
1250
1251 class CCMHome_stub_clp :
1252 virtual public CCMHome_stub,
1253 virtual public PortableServer::StubBase
1254 {
1255 public:
1256 CCMHome_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1257 virtual ~CCMHome_stub_clp ();
1258 CORBA::Object_ptr get_component_def();
1259 CORBA::Object_ptr get_home_def();
1260 void remove_component( CCMObject_ptr comp );
1261
1262 protected:
1263 CCMHome_stub_clp ();
1264 private:
1265 void operator=( const CCMHome_stub_clp & );
1266 };
1267
1268 #endif // MICO_CONF_NO_POA
1269
1270 class ComponentPortDescription;
1271 typedef ComponentPortDescription *ComponentPortDescription_ptr;
1272 typedef ComponentPortDescription_ptr ComponentPortDescriptionRef;
1273 typedef ValueVar< ComponentPortDescription > ComponentPortDescription_var;
1274 typedef ValueOut< ComponentPortDescription > ComponentPortDescription_out;
1275
1276
1277
1278 class ComponentPortDescription :
1279 virtual public CORBA::ValueBase
1280 {
1281 public:
1282 static ComponentPortDescription* _downcast (CORBA::ValueBase *);
1283 static ComponentPortDescription* _downcast (CORBA::AbstractBase *);
1284
1285 virtual void facets( const FacetDescriptions& _p ) = 0;
1286 virtual const FacetDescriptions& facets() const = 0;
1287 virtual FacetDescriptions& facets() = 0;
1288
1289 virtual void receptacles( const ReceptacleDescriptions& _p ) = 0;
1290 virtual const ReceptacleDescriptions& receptacles() const = 0;
1291 virtual ReceptacleDescriptions& receptacles() = 0;
1292
1293 virtual void consumers( const ConsumerDescriptions& _p ) = 0;
1294 virtual const ConsumerDescriptions& consumers() const = 0;
1295 virtual ConsumerDescriptions& consumers() = 0;
1296
1297 virtual void emitters( const EmitterDescriptions& _p ) = 0;
1298 virtual const EmitterDescriptions& emitters() const = 0;
1299 virtual EmitterDescriptions& emitters() = 0;
1300
1301 virtual void publishers( const PublisherDescriptions& _p ) = 0;
1302 virtual const PublisherDescriptions& publishers() const = 0;
1303 virtual PublisherDescriptions& publishers() = 0;
1304
1305
1306 public:
1307 CORBA::ValueBase * _copy_value ();
1308 CORBA::ValueDef_ptr get_value_def ();
1309 virtual void * _narrow_helper (const char *);
1310 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
1311 void _marshal_members (CORBA::DataEncoder &);
1312 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
1313
1314 protected:
1315 ComponentPortDescription ();
1316 virtual ~ComponentPortDescription ();
1317 void _copy_members (const ComponentPortDescription&);
1318
1319 private:
1320 ComponentPortDescription (const ComponentPortDescription &);
1321 void operator= (const ComponentPortDescription &);
1322 };
1323
1324
1325
1326
1327 class CCMObject :
1328 virtual public ::Components::Navigation,
1329 virtual public ::Components::Receptacles,
1330 virtual public ::Components::Events
1331 {
1332 public:
1333 virtual ~CCMObject();
1334
1335 #ifdef HAVE_TYPEDEF_OVERLOAD
1336 typedef CCMObject_ptr _ptr_type;
1337 typedef CCMObject_var _var_type;
1338 #endif
1339
1340 static CCMObject_ptr _narrow( CORBA::Object_ptr obj );
1341 static CCMObject_ptr _narrow( CORBA::AbstractBase_ptr obj );
1342 static CCMObject_ptr _duplicate( CCMObject_ptr _obj )
1343 {
1344 CORBA::Object::_duplicate (_obj);
1345 return _obj;
1346 }
1347
1348 static CCMObject_ptr _nil()
1349 {
1350 return 0;
1351 }
1352
1353 virtual void *_narrow_helper( const char *repoid );
1354
1355 virtual CORBA::Object_ptr get_component_def() = 0;
1356 virtual CCMHome_ptr get_ccm_home() = 0;
1357 virtual void configuration_complete() = 0;
1358 virtual void remove() = 0;
1359 virtual ComponentPortDescription* get_all_ports() = 0;
1360
1361 protected:
1362 CCMObject() {};
1363 private:
1364 CCMObject( const CCMObject& );
1365 void operator=( const CCMObject& );
1366 };
1367
1368
1369 class CCMObject_stub:
1370 virtual public CCMObject,
1371 virtual public ::Components::Navigation_stub,
1372 virtual public ::Components::Receptacles_stub,
1373 virtual public ::Components::Events_stub
1374 {
1375 public:
1376 virtual ~CCMObject_stub();
1377 CORBA::Object_ptr get_component_def();
1378 CCMHome_ptr get_ccm_home();
1379 void configuration_complete();
1380 void remove();
1381 ComponentPortDescription* get_all_ports();
1382
1383 private:
1384 void operator=( const CCMObject_stub& );
1385 };
1386
1387 #ifndef MICO_CONF_NO_POA
1388
1389 class CCMObject_stub_clp :
1390 virtual public CCMObject_stub,
1391 virtual public ::Components::Navigation_stub_clp,
1392 virtual public ::Components::Receptacles_stub_clp,
1393 virtual public ::Components::Events_stub_clp
1394 {
1395 public:
1396 CCMObject_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1397 virtual ~CCMObject_stub_clp ();
1398 CORBA::Object_ptr get_component_def();
1399 CCMHome_ptr get_ccm_home();
1400 void configuration_complete();
1401 void remove();
1402 ComponentPortDescription* get_all_ports();
1403
1404 protected:
1405 CCMObject_stub_clp ();
1406 private:
1407 void operator=( const CCMObject_stub_clp & );
1408 };
1409
1410 #endif // MICO_CONF_NO_POA
1411
1412 struct DuplicateKeyValue : public CORBA::UserException {
1413 #ifdef HAVE_EXPLICIT_STRUCT_OPS
1414 DuplicateKeyValue();
1415 ~DuplicateKeyValue();
1416 DuplicateKeyValue( const DuplicateKeyValue& s );
1417 DuplicateKeyValue& operator=( const DuplicateKeyValue& s );
1418 #endif //HAVE_EXPLICIT_STRUCT_OPS
1419
1420
1421 #ifdef HAVE_STD_EH
1422 DuplicateKeyValue *operator->() { return this; }
1423 DuplicateKeyValue& operator*() { return *this; }
1424 operator DuplicateKeyValue*() { return this; }
1425 #endif // HAVE_STD_EH
1426
1427 void _throwit() const;
1428 const char *_repoid() const;
1429 void _encode( CORBA::DataEncoder &en ) const;
1430 void _encode_any( CORBA::Any &a ) const;
1431 CORBA::Exception *_clone() const;
1432 static DuplicateKeyValue *_downcast( CORBA::Exception *ex );
1433 static const DuplicateKeyValue *_downcast( const CORBA::Exception *ex );
1434 };
1435
1436 #ifdef HAVE_STD_EH
1437 typedef DuplicateKeyValue DuplicateKeyValue_catch;
1438 #else
1439 typedef ExceptVar< DuplicateKeyValue > DuplicateKeyValue_var;
1440 typedef TVarOut< DuplicateKeyValue > DuplicateKeyValue_out;
1441 typedef DuplicateKeyValue_var DuplicateKeyValue_catch;
1442 #endif // HAVE_STD_EH
1443
1444 struct UnknownKeyValue : public CORBA::UserException {
1445 #ifdef HAVE_EXPLICIT_STRUCT_OPS
1446 UnknownKeyValue();
1447 ~UnknownKeyValue();
1448 UnknownKeyValue( const UnknownKeyValue& s );
1449 UnknownKeyValue& operator=( const UnknownKeyValue& s );
1450 #endif //HAVE_EXPLICIT_STRUCT_OPS
1451
1452
1453 #ifdef HAVE_STD_EH
1454 UnknownKeyValue *operator->() { return this; }
1455 UnknownKeyValue& operator*() { return *this; }
1456 operator UnknownKeyValue*() { return this; }
1457 #endif // HAVE_STD_EH
1458
1459 void _throwit() const;
1460 const char *_repoid() const;
1461 void _encode( CORBA::DataEncoder &en ) const;
1462 void _encode_any( CORBA::Any &a ) const;
1463 CORBA::Exception *_clone() const;
1464 static UnknownKeyValue *_downcast( CORBA::Exception *ex );
1465 static const UnknownKeyValue *_downcast( const CORBA::Exception *ex );
1466 };
1467
1468 #ifdef HAVE_STD_EH
1469 typedef UnknownKeyValue UnknownKeyValue_catch;
1470 #else
1471 typedef ExceptVar< UnknownKeyValue > UnknownKeyValue_var;
1472 typedef TVarOut< UnknownKeyValue > UnknownKeyValue_out;
1473 typedef UnknownKeyValue_var UnknownKeyValue_catch;
1474 #endif // HAVE_STD_EH
1475
1476 struct InvalidKey : public CORBA::UserException {
1477 #ifdef HAVE_EXPLICIT_STRUCT_OPS
1478 InvalidKey();
1479 ~InvalidKey();
1480 InvalidKey( const InvalidKey& s );
1481 InvalidKey& operator=( const InvalidKey& s );
1482 #endif //HAVE_EXPLICIT_STRUCT_OPS
1483
1484
1485 #ifdef HAVE_STD_EH
1486 InvalidKey *operator->() { return this; }
1487 InvalidKey& operator*() { return *this; }
1488 operator InvalidKey*() { return this; }
1489 #endif // HAVE_STD_EH
1490
1491 void _throwit() const;
1492 const char *_repoid() const;
1493 void _encode( CORBA::DataEncoder &en ) const;
1494 void _encode_any( CORBA::Any &a ) const;
1495 CORBA::Exception *_clone() const;
1496 static InvalidKey *_downcast( CORBA::Exception *ex );
1497 static const InvalidKey *_downcast( const CORBA::Exception *ex );
1498 };
1499
1500 #ifdef HAVE_STD_EH
1501 typedef InvalidKey InvalidKey_catch;
1502 #else
1503 typedef ExceptVar< InvalidKey > InvalidKey_var;
1504 typedef TVarOut< InvalidKey > InvalidKey_out;
1505 typedef InvalidKey_var InvalidKey_catch;
1506 #endif // HAVE_STD_EH
1507
1508 typedef IfaceSequenceTmpl< CCMHome_var,CCMHome_ptr> CCMHomes;
1509 typedef TSeqVar< IfaceSequenceTmpl< CCMHome_var,CCMHome_ptr> > CCMHomes_var;
1510 typedef TSeqOut< IfaceSequenceTmpl< CCMHome_var,CCMHome_ptr> > CCMHomes_out;
1511
1512
1513
1514
1515 class KeylessCCMHome :
1516 virtual public CORBA::Object
1517 {
1518 public:
1519 virtual ~KeylessCCMHome();
1520
1521 #ifdef HAVE_TYPEDEF_OVERLOAD
1522 typedef KeylessCCMHome_ptr _ptr_type;
1523 typedef KeylessCCMHome_var _var_type;
1524 #endif
1525
1526 static KeylessCCMHome_ptr _narrow( CORBA::Object_ptr obj );
1527 static KeylessCCMHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
1528 static KeylessCCMHome_ptr _duplicate( KeylessCCMHome_ptr _obj )
1529 {
1530 CORBA::Object::_duplicate (_obj);
1531 return _obj;
1532 }
1533
1534 static KeylessCCMHome_ptr _nil()
1535 {
1536 return 0;
1537 }
1538
1539 virtual void *_narrow_helper( const char *repoid );
1540
1541 virtual CCMObject_ptr create_component() = 0;
1542
1543 protected:
1544 KeylessCCMHome() {};
1545 private:
1546 KeylessCCMHome( const KeylessCCMHome& );
1547 void operator=( const KeylessCCMHome& );
1548 };
1549
1550
1551 class KeylessCCMHome_stub:
1552 virtual public KeylessCCMHome
1553 {
1554 public:
1555 virtual ~KeylessCCMHome_stub();
1556 CCMObject_ptr create_component();
1557
1558 private:
1559 void operator=( const KeylessCCMHome_stub& );
1560 };
1561
1562 #ifndef MICO_CONF_NO_POA
1563
1564 class KeylessCCMHome_stub_clp :
1565 virtual public KeylessCCMHome_stub,
1566 virtual public PortableServer::StubBase
1567 {
1568 public:
1569 KeylessCCMHome_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1570 virtual ~KeylessCCMHome_stub_clp ();
1571 CCMObject_ptr create_component();
1572
1573 protected:
1574 KeylessCCMHome_stub_clp ();
1575 private:
1576 void operator=( const KeylessCCMHome_stub_clp & );
1577 };
1578
1579 #endif // MICO_CONF_NO_POA
1580
1581 struct HomeNotFound : public CORBA::UserException {
1582 #ifdef HAVE_EXPLICIT_STRUCT_OPS
1583 HomeNotFound();
1584 ~HomeNotFound();
1585 HomeNotFound( const HomeNotFound& s );
1586 HomeNotFound& operator=( const HomeNotFound& s );
1587 #endif //HAVE_EXPLICIT_STRUCT_OPS
1588
1589
1590 #ifdef HAVE_STD_EH
1591 HomeNotFound *operator->() { return this; }
1592 HomeNotFound& operator*() { return *this; }
1593 operator HomeNotFound*() { return this; }
1594 #endif // HAVE_STD_EH
1595
1596 void _throwit() const;
1597 const char *_repoid() const;
1598 void _encode( CORBA::DataEncoder &en ) const;
1599 void _encode_any( CORBA::Any &a ) const;
1600 CORBA::Exception *_clone() const;
1601 static HomeNotFound *_downcast( CORBA::Exception *ex );
1602 static const HomeNotFound *_downcast( const CORBA::Exception *ex );
1603 };
1604
1605 #ifdef HAVE_STD_EH
1606 typedef HomeNotFound HomeNotFound_catch;
1607 #else
1608 typedef ExceptVar< HomeNotFound > HomeNotFound_var;
1609 typedef TVarOut< HomeNotFound > HomeNotFound_out;
1610 typedef HomeNotFound_var HomeNotFound_catch;
1611 #endif // HAVE_STD_EH
1612
1613
1614
1615
1616 class HomeFinder :
1617 virtual public CORBA::Object
1618 {
1619 public:
1620 virtual ~HomeFinder();
1621
1622 #ifdef HAVE_TYPEDEF_OVERLOAD
1623 typedef HomeFinder_ptr _ptr_type;
1624 typedef HomeFinder_var _var_type;
1625 #endif
1626
1627 static HomeFinder_ptr _narrow( CORBA::Object_ptr obj );
1628 static HomeFinder_ptr _narrow( CORBA::AbstractBase_ptr obj );
1629 static HomeFinder_ptr _duplicate( HomeFinder_ptr _obj )
1630 {
1631 CORBA::Object::_duplicate (_obj);
1632 return _obj;
1633 }
1634
1635 static HomeFinder_ptr _nil()
1636 {
1637 return 0;
1638 }
1639
1640 virtual void *_narrow_helper( const char *repoid );
1641
1642 virtual CCMHome_ptr find_home_by_component_type( const char* comp_repid ) = 0;
1643 virtual CCMHome_ptr find_home_by_home_type( const char* home_repid ) = 0;
1644 virtual CCMHome_ptr find_home_by_name( const char* home_name ) = 0;
1645
1646 protected:
1647 HomeFinder() {};
1648 private:
1649 HomeFinder( const HomeFinder& );
1650 void operator=( const HomeFinder& );
1651 };
1652
1653
1654 class HomeFinder_stub:
1655 virtual public HomeFinder
1656 {
1657 public:
1658 virtual ~HomeFinder_stub();
1659 CCMHome_ptr find_home_by_component_type( const char* comp_repid );
1660 CCMHome_ptr find_home_by_home_type( const char* home_repid );
1661 CCMHome_ptr find_home_by_name( const char* home_name );
1662
1663 private:
1664 void operator=( const HomeFinder_stub& );
1665 };
1666
1667 #ifndef MICO_CONF_NO_POA
1668
1669 class HomeFinder_stub_clp :
1670 virtual public HomeFinder_stub,
1671 virtual public PortableServer::StubBase
1672 {
1673 public:
1674 HomeFinder_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1675 virtual ~HomeFinder_stub_clp ();
1676 CCMHome_ptr find_home_by_component_type( const char* comp_repid );
1677 CCMHome_ptr find_home_by_home_type( const char* home_repid );
1678 CCMHome_ptr find_home_by_name( const char* home_name );
1679
1680 protected:
1681 HomeFinder_stub_clp ();
1682 private:
1683 void operator=( const HomeFinder_stub_clp & );
1684 };
1685
1686 #endif // MICO_CONF_NO_POA
1687
1688 struct WrongComponentType : public CORBA::UserException {
1689 #ifdef HAVE_EXPLICIT_STRUCT_OPS
1690 WrongComponentType();
1691 ~WrongComponentType();
1692 WrongComponentType( const WrongComponentType& s );
1693 WrongComponentType& operator=( const WrongComponentType& s );
1694 #endif //HAVE_EXPLICIT_STRUCT_OPS
1695
1696
1697 #ifdef HAVE_STD_EH
1698 WrongComponentType *operator->() { return this; }
1699 WrongComponentType& operator*() { return *this; }
1700 operator WrongComponentType*() { return this; }
1701 #endif // HAVE_STD_EH
1702
1703 void _throwit() const;
1704 const char *_repoid() const;
1705 void _encode( CORBA::DataEncoder &en ) const;
1706 void _encode_any( CORBA::Any &a ) const;
1707 CORBA::Exception *_clone() const;
1708 static WrongComponentType *_downcast( CORBA::Exception *ex );
1709 static const WrongComponentType *_downcast( const CORBA::Exception *ex );
1710 };
1711
1712 #ifdef HAVE_STD_EH
1713 typedef WrongComponentType WrongComponentType_catch;
1714 #else
1715 typedef ExceptVar< WrongComponentType > WrongComponentType_var;
1716 typedef TVarOut< WrongComponentType > WrongComponentType_out;
1717 typedef WrongComponentType_var WrongComponentType_catch;
1718 #endif // HAVE_STD_EH
1719
1720
1721
1722
1723 class Configurator :
1724 virtual public CORBA::Object
1725 {
1726 public:
1727 virtual ~Configurator();
1728
1729 #ifdef HAVE_TYPEDEF_OVERLOAD
1730 typedef Configurator_ptr _ptr_type;
1731 typedef Configurator_var _var_type;
1732 #endif
1733
1734 static Configurator_ptr _narrow( CORBA::Object_ptr obj );
1735 static Configurator_ptr _narrow( CORBA::AbstractBase_ptr obj );
1736 static Configurator_ptr _duplicate( Configurator_ptr _obj )
1737 {
1738 CORBA::Object::_duplicate (_obj);
1739 return _obj;
1740 }
1741
1742 static Configurator_ptr _nil()
1743 {
1744 return 0;
1745 }
1746
1747 virtual void *_narrow_helper( const char *repoid );
1748
1749 virtual void configure( CCMObject_ptr comp ) = 0;
1750
1751 protected:
1752 Configurator() {};
1753 private:
1754 Configurator( const Configurator& );
1755 void operator=( const Configurator& );
1756 };
1757
1758
1759 class Configurator_stub:
1760 virtual public Configurator
1761 {
1762 public:
1763 virtual ~Configurator_stub();
1764 void configure( CCMObject_ptr comp );
1765
1766 private:
1767 void operator=( const Configurator_stub& );
1768 };
1769
1770 #ifndef MICO_CONF_NO_POA
1771
1772 class Configurator_stub_clp :
1773 virtual public Configurator_stub,
1774 virtual public PortableServer::StubBase
1775 {
1776 public:
1777 Configurator_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1778 virtual ~Configurator_stub_clp ();
1779 void configure( CCMObject_ptr comp );
1780
1781 protected:
1782 Configurator_stub_clp ();
1783 private:
1784 void operator=( const Configurator_stub_clp & );
1785 };
1786
1787 #endif // MICO_CONF_NO_POA
1788
1789 class ConfigValue;
1790 typedef ConfigValue *ConfigValue_ptr;
1791 typedef ConfigValue_ptr ConfigValueRef;
1792 typedef ValueVar< ConfigValue > ConfigValue_var;
1793 typedef ValueOut< ConfigValue > ConfigValue_out;
1794
1795
1796
1797 class ConfigValue :
1798 virtual public CORBA::ValueBase
1799 {
1800 public:
1801 static ConfigValue* _downcast (CORBA::ValueBase *);
1802 static ConfigValue* _downcast (CORBA::AbstractBase *);
1803
1804 virtual void name( char *_p ) = 0;
1805 virtual void name( const char *_p ) = 0;
1806 virtual void name( const CORBA::String_var &_p ) = 0;
1807 virtual const char *name() const = 0;
1808
1809 virtual void value( const CORBA::Any& _p ) = 0;
1810 virtual const CORBA::Any& value() const = 0;
1811 virtual CORBA::Any& value() = 0;
1812
1813
1814 public:
1815 CORBA::ValueBase * _copy_value ();
1816 CORBA::ValueDef_ptr get_value_def ();
1817 virtual void * _narrow_helper (const char *);
1818 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
1819 void _marshal_members (CORBA::DataEncoder &);
1820 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
1821
1822 protected:
1823 ConfigValue ();
1824 virtual ~ConfigValue ();
1825 void _copy_members (const ConfigValue&);
1826
1827 private:
1828 ConfigValue (const ConfigValue &);
1829 void operator= (const ConfigValue &);
1830 };
1831
1832 typedef SequenceTmpl< ConfigValue_var,MICO_TID_DEF> ConfigValues;
1833 typedef TSeqVar< SequenceTmpl< ConfigValue_var,MICO_TID_DEF> > ConfigValues_var;
1834 typedef TSeqOut< SequenceTmpl< ConfigValue_var,MICO_TID_DEF> > ConfigValues_out;
1835
1836
1837
1838
1839 class StandardConfigurator :
1840 virtual public ::Components::Configurator
1841 {
1842 public:
1843 virtual ~StandardConfigurator();
1844
1845 #ifdef HAVE_TYPEDEF_OVERLOAD
1846 typedef StandardConfigurator_ptr _ptr_type;
1847 typedef StandardConfigurator_var _var_type;
1848 #endif
1849
1850 static StandardConfigurator_ptr _narrow( CORBA::Object_ptr obj );
1851 static StandardConfigurator_ptr _narrow( CORBA::AbstractBase_ptr obj );
1852 static StandardConfigurator_ptr _duplicate( StandardConfigurator_ptr _obj )
1853 {
1854 CORBA::Object::_duplicate (_obj);
1855 return _obj;
1856 }
1857
1858 static StandardConfigurator_ptr _nil()
1859 {
1860 return 0;
1861 }
1862
1863 virtual void *_narrow_helper( const char *repoid );
1864
1865 virtual void set_configuration( const ConfigValues& descr ) = 0;
1866
1867 protected:
1868 StandardConfigurator() {};
1869 private:
1870 StandardConfigurator( const StandardConfigurator& );
1871 void operator=( const StandardConfigurator& );
1872 };
1873
1874
1875 class StandardConfigurator_stub:
1876 virtual public StandardConfigurator,
1877 virtual public ::Components::Configurator_stub
1878 {
1879 public:
1880 virtual ~StandardConfigurator_stub();
1881 void set_configuration( const ConfigValues& descr );
1882
1883 private:
1884 void operator=( const StandardConfigurator_stub& );
1885 };
1886
1887 #ifndef MICO_CONF_NO_POA
1888
1889 class StandardConfigurator_stub_clp :
1890 virtual public StandardConfigurator_stub,
1891 virtual public ::Components::Configurator_stub_clp
1892 {
1893 public:
1894 StandardConfigurator_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1895 virtual ~StandardConfigurator_stub_clp ();
1896 void set_configuration( const ConfigValues& descr );
1897
1898 protected:
1899 StandardConfigurator_stub_clp ();
1900 private:
1901 void operator=( const StandardConfigurator_stub_clp & );
1902 };
1903
1904 #endif // MICO_CONF_NO_POA
1905
1906 struct IllegalState : public CORBA::UserException {
1907 #ifdef HAVE_EXPLICIT_STRUCT_OPS
1908 IllegalState();
1909 ~IllegalState();
1910 IllegalState( const IllegalState& s );
1911 IllegalState& operator=( const IllegalState& s );
1912 #endif //HAVE_EXPLICIT_STRUCT_OPS
1913
1914
1915 #ifdef HAVE_STD_EH
1916 IllegalState *operator->() { return this; }
1917 IllegalState& operator*() { return *this; }
1918 operator IllegalState*() { return this; }
1919 #endif // HAVE_STD_EH
1920
1921 void _throwit() const;
1922 const char *_repoid() const;
1923 void _encode( CORBA::DataEncoder &en ) const;
1924 void _encode_any( CORBA::Any &a ) const;
1925 CORBA::Exception *_clone() const;
1926 static IllegalState *_downcast( CORBA::Exception *ex );
1927 static const IllegalState *_downcast( const CORBA::Exception *ex );
1928 };
1929
1930 #ifdef HAVE_STD_EH
1931 typedef IllegalState IllegalState_catch;
1932 #else
1933 typedef ExceptVar< IllegalState > IllegalState_var;
1934 typedef TVarOut< IllegalState > IllegalState_out;
1935 typedef IllegalState_var IllegalState_catch;
1936 #endif // HAVE_STD_EH
1937
1938
1939
1940
1941 class CCMContext :
1942 virtual public CORBA::LocalObject
1943 {
1944 public:
1945 virtual ~CCMContext();
1946
1947 #ifdef HAVE_TYPEDEF_OVERLOAD
1948 typedef CCMContext_ptr _ptr_type;
1949 typedef CCMContext_var _var_type;
1950 #endif
1951
1952 static CCMContext_ptr _narrow( CORBA::Object_ptr obj );
1953 static CCMContext_ptr _narrow( CORBA::AbstractBase_ptr obj );
1954 static CCMContext_ptr _duplicate( CCMContext_ptr _obj )
1955 {
1956 CORBA::Object::_duplicate (_obj);
1957 return _obj;
1958 }
1959
1960 static CCMContext_ptr _nil()
1961 {
1962 return 0;
1963 }
1964
1965 virtual void *_narrow_helper( const char *repoid );
1966
1967 virtual CCMHome_ptr get_CCM_home() = 0;
1968
1969 protected:
1970 CCMContext() {};
1971 private:
1972 CCMContext( const CCMContext& );
1973 void operator=( const CCMContext& );
1974 };
1975
1976
1977
1978
1979
1980 class SessionContext :
1981 virtual public ::Components::CCMContext
1982 {
1983 public:
1984 virtual ~SessionContext();
1985
1986 #ifdef HAVE_TYPEDEF_OVERLOAD
1987 typedef SessionContext_ptr _ptr_type;
1988 typedef SessionContext_var _var_type;
1989 #endif
1990
1991 static SessionContext_ptr _narrow( CORBA::Object_ptr obj );
1992 static SessionContext_ptr _narrow( CORBA::AbstractBase_ptr obj );
1993 static SessionContext_ptr _duplicate( SessionContext_ptr _obj )
1994 {
1995 CORBA::Object::_duplicate (_obj);
1996 return _obj;
1997 }
1998
1999 static SessionContext_ptr _nil()
2000 {
2001 return 0;
2002 }
2003
2004 virtual void *_narrow_helper( const char *repoid );
2005
2006 virtual CORBA::Object_ptr get_CCM_object() = 0;
2007
2008 protected:
2009 SessionContext() {};
2010 private:
2011 SessionContext( const SessionContext& );
2012 void operator=( const SessionContext& );
2013 };
2014
2015
2016 enum CCMExceptionReason {
2017 SYSTEM_ERROR = 0,
2018 CREATE_ERROR,
2019 REMOVE_ERROR,
2020 DUPLICATE_KEY,
2021 FIND_ERROR,
2022 OBJECT_NOT_FOUND,
2023 NO_SUCH_ENTITY
2024 };
2025
2026 typedef CCMExceptionReason& CCMExceptionReason_out;
2027
2028 struct CCMException : public CORBA::UserException {
2029 #ifdef HAVE_EXPLICIT_STRUCT_OPS
2030 CCMException();
2031 ~CCMException();
2032 CCMException( const CCMException& s );
2033 CCMException& operator=( const CCMException& s );
2034 #endif //HAVE_EXPLICIT_STRUCT_OPS
2035
2036 #ifndef HAVE_EXPLICIT_STRUCT_OPS
2037 CCMException();
2038 #endif //HAVE_EXPLICIT_STRUCT_OPS
2039 CCMException( ::Components::CCMExceptionReason _m0 );
2040
2041 #ifdef HAVE_STD_EH
2042 CCMException *operator->() { return this; }
2043 CCMException& operator*() { return *this; }
2044 operator CCMException*() { return this; }
2045 #endif // HAVE_STD_EH
2046
2047 void _throwit() const;
2048 const char *_repoid() const;
2049 void _encode( CORBA::DataEncoder &en ) const;
2050 void _encode_any( CORBA::Any &a ) const;
2051 CORBA::Exception *_clone() const;
2052 static CCMException *_downcast( CORBA::Exception *ex );
2053 static const CCMException *_downcast( const CORBA::Exception *ex );
2054 CCMExceptionReason reason;
2055 };
2056
2057 #ifdef HAVE_STD_EH
2058 typedef CCMException CCMException_catch;
2059 #else
2060 typedef ExceptVar< CCMException > CCMException_var;
2061 typedef TVarOut< CCMException > CCMException_out;
2062 typedef CCMException_var CCMException_catch;
2063 #endif // HAVE_STD_EH
2064
2065
2066
2067
2068 class EnterpriseComponent :
2069 virtual public CORBA::LocalObject
2070 {
2071 public:
2072 virtual ~EnterpriseComponent();
2073
2074 #ifdef HAVE_TYPEDEF_OVERLOAD
2075 typedef EnterpriseComponent_ptr _ptr_type;
2076 typedef EnterpriseComponent_var _var_type;
2077 #endif
2078
2079 static EnterpriseComponent_ptr _narrow( CORBA::Object_ptr obj );
2080 static EnterpriseComponent_ptr _narrow( CORBA::AbstractBase_ptr obj );
2081 static EnterpriseComponent_ptr _duplicate( EnterpriseComponent_ptr _obj )
2082 {
2083 CORBA::Object::_duplicate (_obj);
2084 return _obj;
2085 }
2086
2087 static EnterpriseComponent_ptr _nil()
2088 {
2089 return 0;
2090 }
2091
2092 virtual void *_narrow_helper( const char *repoid );
2093
2094 protected:
2095 EnterpriseComponent() {};
2096 private:
2097 EnterpriseComponent( const EnterpriseComponent& );
2098 void operator=( const EnterpriseComponent& );
2099 };
2100
2101
2102
2103
2104
2105 class SessionComponent :
2106 virtual public ::Components::EnterpriseComponent
2107 {
2108 public:
2109 virtual ~SessionComponent();
2110
2111 #ifdef HAVE_TYPEDEF_OVERLOAD
2112 typedef SessionComponent_ptr _ptr_type;
2113 typedef SessionComponent_var _var_type;
2114 #endif
2115
2116 static SessionComponent_ptr _narrow( CORBA::Object_ptr obj );
2117 static SessionComponent_ptr _narrow( CORBA::AbstractBase_ptr obj );
2118 static SessionComponent_ptr _duplicate( SessionComponent_ptr _obj )
2119 {
2120 CORBA::Object::_duplicate (_obj);
2121 return _obj;
2122 }
2123
2124 static SessionComponent_ptr _nil()
2125 {
2126 return 0;
2127 }
2128
2129 virtual void *_narrow_helper( const char *repoid );
2130
2131 virtual void set_session_context( SessionContext_ptr ctx ) = 0;
2132 virtual void ccm_activate() = 0;
2133 virtual void ccm_passivate() = 0;
2134 virtual void ccm_remove() = 0;
2135
2136 protected:
2137 SessionComponent() {};
2138 private:
2139 SessionComponent( const SessionComponent& );
2140 void operator=( const SessionComponent& );
2141 };
2142
2143
2144
2145
2146
2147 class HomeExecutorBase :
2148 virtual public CORBA::LocalObject
2149 {
2150 public:
2151 virtual ~HomeExecutorBase();
2152
2153 #ifdef HAVE_TYPEDEF_OVERLOAD
2154 typedef HomeExecutorBase_ptr _ptr_type;
2155 typedef HomeExecutorBase_var _var_type;
2156 #endif
2157
2158 static HomeExecutorBase_ptr _narrow( CORBA::Object_ptr obj );
2159 static HomeExecutorBase_ptr _narrow( CORBA::AbstractBase_ptr obj );
2160 static HomeExecutorBase_ptr _duplicate( HomeExecutorBase_ptr _obj )
2161 {
2162 CORBA::Object::_duplicate (_obj);
2163 return _obj;
2164 }
2165
2166 static HomeExecutorBase_ptr _nil()
2167 {
2168 return 0;
2169 }
2170
2171 virtual void *_narrow_helper( const char *repoid );
2172
2173 protected:
2174 HomeExecutorBase() {};
2175 private:
2176 HomeExecutorBase( const HomeExecutorBase& );
2177 void operator=( const HomeExecutorBase& );
2178 };
2179
2180
2181
2182
2183
2184 class ExecutorLocator :
2185 virtual public ::Components::EnterpriseComponent
2186 {
2187 public:
2188 virtual ~ExecutorLocator();
2189
2190 #ifdef HAVE_TYPEDEF_OVERLOAD
2191 typedef ExecutorLocator_ptr _ptr_type;
2192 typedef ExecutorLocator_var _var_type;
2193 #endif
2194
2195 static ExecutorLocator_ptr _narrow( CORBA::Object_ptr obj );
2196 static ExecutorLocator_ptr _narrow( CORBA::AbstractBase_ptr obj );
2197 static ExecutorLocator_ptr _duplicate( ExecutorLocator_ptr _obj )
2198 {
2199 CORBA::Object::_duplicate (_obj);
2200 return _obj;
2201 }
2202
2203 static ExecutorLocator_ptr _nil()
2204 {
2205 return 0;
2206 }
2207
2208 virtual void *_narrow_helper( const char *repoid );
2209
2210 virtual CORBA::Object_ptr obtain_executor( const char* name ) = 0;
2211 virtual void release_executor( CORBA::Object_ptr exc ) = 0;
2212 virtual void configurationComplete() = 0;
2213
2214 protected:
2215 ExecutorLocator() {};
2216 private:
2217 ExecutorLocator( const ExecutorLocator& );
2218 void operator=( const ExecutorLocator& );
2219 };
2220
2221
2222 struct UnknownImplId : public CORBA::UserException {
2223 #ifdef HAVE_EXPLICIT_STRUCT_OPS
2224 UnknownImplId();
2225 ~UnknownImplId();
2226 UnknownImplId( const UnknownImplId& s );
2227 UnknownImplId& operator=( const UnknownImplId& s );
2228 #endif //HAVE_EXPLICIT_STRUCT_OPS
2229
2230
2231 #ifdef HAVE_STD_EH
2232 UnknownImplId *operator->() { return this; }
2233 UnknownImplId& operator*() { return *this; }
2234 operator UnknownImplId*() { return this; }
2235 #endif // HAVE_STD_EH
2236
2237 void _throwit() const;
2238 const char *_repoid() const;
2239 void _encode( CORBA::DataEncoder &en ) const;
2240 void _encode_any( CORBA::Any &a ) const;
2241 CORBA::Exception *_clone() const;
2242 static UnknownImplId *_downcast( CORBA::Exception *ex );
2243 static const UnknownImplId *_downcast( const CORBA::Exception *ex );
2244 };
2245
2246 #ifdef HAVE_STD_EH
2247 typedef UnknownImplId UnknownImplId_catch;
2248 #else
2249 typedef ExceptVar< UnknownImplId > UnknownImplId_var;
2250 typedef TVarOut< UnknownImplId > UnknownImplId_out;
2251 typedef UnknownImplId_var UnknownImplId_catch;
2252 #endif // HAVE_STD_EH
2253
2254 struct InvalidLocation : public CORBA::UserException {
2255 #ifdef HAVE_EXPLICIT_STRUCT_OPS
2256 InvalidLocation();
2257 ~InvalidLocation();
2258 InvalidLocation( const InvalidLocation& s );
2259 InvalidLocation& operator=( const InvalidLocation& s );
2260 #endif //HAVE_EXPLICIT_STRUCT_OPS
2261
2262
2263 #ifdef HAVE_STD_EH
2264 InvalidLocation *operator->() { return this; }
2265 InvalidLocation& operator*() { return *this; }
2266 operator InvalidLocation*() { return this; }
2267 #endif // HAVE_STD_EH
2268
2269 void _throwit() const;
2270 const char *_repoid() const;
2271 void _encode( CORBA::DataEncoder &en ) const;
2272 void _encode_any( CORBA::Any &a ) const;
2273 CORBA::Exception *_clone() const;
2274 static InvalidLocation *_downcast( CORBA::Exception *ex );
2275 static const InvalidLocation *_downcast( const CORBA::Exception *ex );
2276 };
2277
2278 #ifdef HAVE_STD_EH
2279 typedef InvalidLocation InvalidLocation_catch;
2280 #else
2281 typedef ExceptVar< InvalidLocation > InvalidLocation_var;
2282 typedef TVarOut< InvalidLocation > InvalidLocation_out;
2283 typedef InvalidLocation_var InvalidLocation_catch;
2284 #endif // HAVE_STD_EH
2285
2286 struct CreateFailure : public CORBA::UserException {
2287 #ifdef HAVE_EXPLICIT_STRUCT_OPS
2288 CreateFailure();
2289 ~CreateFailure();
2290 CreateFailure( const CreateFailure& s );
2291 CreateFailure& operator=( const CreateFailure& s );
2292 #endif //HAVE_EXPLICIT_STRUCT_OPS
2293
2294
2295 #ifdef HAVE_STD_EH
2296 CreateFailure *operator->() { return this; }
2297 CreateFailure& operator*() { return *this; }
2298 operator CreateFailure*() { return this; }
2299 #endif // HAVE_STD_EH
2300
2301 void _throwit() const;
2302 const char *_repoid() const;
2303 void _encode( CORBA::DataEncoder &en ) const;
2304 void _encode_any( CORBA::Any &a ) const;
2305 CORBA::Exception *_clone() const;
2306 static CreateFailure *_downcast( CORBA::Exception *ex );
2307 static const CreateFailure *_downcast( const CORBA::Exception *ex );
2308 };
2309
2310 #ifdef HAVE_STD_EH
2311 typedef CreateFailure CreateFailure_catch;
2312 #else
2313 typedef ExceptVar< CreateFailure > CreateFailure_var;
2314 typedef TVarOut< CreateFailure > CreateFailure_out;
2315 typedef CreateFailure_var CreateFailure_catch;
2316 #endif // HAVE_STD_EH
2317
2318 struct RemoveFailure : public CORBA::UserException {
2319 #ifdef HAVE_EXPLICIT_STRUCT_OPS
2320 RemoveFailure();
2321 ~RemoveFailure();
2322 RemoveFailure( const RemoveFailure& s );
2323 RemoveFailure& operator=( const RemoveFailure& s );
2324 #endif //HAVE_EXPLICIT_STRUCT_OPS
2325
2326
2327 #ifdef HAVE_STD_EH
2328 RemoveFailure *operator->() { return this; }
2329 RemoveFailure& operator*() { return *this; }
2330 operator RemoveFailure*() { return this; }
2331 #endif // HAVE_STD_EH
2332
2333 void _throwit() const;
2334 const char *_repoid() const;
2335 void _encode( CORBA::DataEncoder &en ) const;
2336 void _encode_any( CORBA::Any &a ) const;
2337 CORBA::Exception *_clone() const;
2338 static RemoveFailure *_downcast( CORBA::Exception *ex );
2339 static const RemoveFailure *_downcast( const CORBA::Exception *ex );
2340 };
2341
2342 #ifdef HAVE_STD_EH
2343 typedef RemoveFailure RemoveFailure_catch;
2344 #else
2345 typedef ExceptVar< RemoveFailure > RemoveFailure_var;
2346 typedef TVarOut< RemoveFailure > RemoveFailure_out;
2347 typedef RemoveFailure_var RemoveFailure_catch;
2348 #endif // HAVE_STD_EH
2349
2350 struct InstallationFailure : public CORBA::UserException {
2351 #ifdef HAVE_EXPLICIT_STRUCT_OPS
2352 InstallationFailure();
2353 ~InstallationFailure();
2354 InstallationFailure( const InstallationFailure& s );
2355 InstallationFailure& operator=( const InstallationFailure& s );
2356 #endif //HAVE_EXPLICIT_STRUCT_OPS
2357
2358
2359 #ifdef HAVE_STD_EH
2360 InstallationFailure *operator->() { return this; }
2361 InstallationFailure& operator*() { return *this; }
2362 operator InstallationFailure*() { return this; }
2363 #endif // HAVE_STD_EH
2364
2365 void _throwit() const;
2366 const char *_repoid() const;
2367 void _encode( CORBA::DataEncoder &en ) const;
2368 void _encode_any( CORBA::Any &a ) const;
2369 CORBA::Exception *_clone() const;
2370 static InstallationFailure *_downcast( CORBA::Exception *ex );
2371 static const InstallationFailure *_downcast( const CORBA::Exception *ex );
2372 };
2373
2374 #ifdef HAVE_STD_EH
2375 typedef InstallationFailure InstallationFailure_catch;
2376 #else
2377 typedef ExceptVar< InstallationFailure > InstallationFailure_var;
2378 typedef TVarOut< InstallationFailure > InstallationFailure_out;
2379 typedef InstallationFailure_var InstallationFailure_catch;
2380 #endif // HAVE_STD_EH
2381
2382 struct InvalidAssembly : public CORBA::UserException {
2383 #ifdef HAVE_EXPLICIT_STRUCT_OPS
2384 InvalidAssembly();
2385 ~InvalidAssembly();
2386 InvalidAssembly( const InvalidAssembly& s );
2387 InvalidAssembly& operator=( const InvalidAssembly& s );
2388 #endif //HAVE_EXPLICIT_STRUCT_OPS
2389
2390
2391 #ifdef HAVE_STD_EH
2392 InvalidAssembly *operator->() { return this; }
2393 InvalidAssembly& operator*() { return *this; }
2394 operator InvalidAssembly*() { return this; }
2395 #endif // HAVE_STD_EH
2396
2397 void _throwit() const;
2398 const char *_repoid() const;
2399 void _encode( CORBA::DataEncoder &en ) const;
2400 void _encode_any( CORBA::Any &a ) const;
2401 CORBA::Exception *_clone() const;
2402 static InvalidAssembly *_downcast( CORBA::Exception *ex );
2403 static const InvalidAssembly *_downcast( const CORBA::Exception *ex );
2404 };
2405
2406 #ifdef HAVE_STD_EH
2407 typedef InvalidAssembly InvalidAssembly_catch;
2408 #else
2409 typedef ExceptVar< InvalidAssembly > InvalidAssembly_var;
2410 typedef TVarOut< InvalidAssembly > InvalidAssembly_out;
2411 typedef InvalidAssembly_var InvalidAssembly_catch;
2412 #endif // HAVE_STD_EH
2413
2414
2415
2416
2417 class Container :
2418 virtual public CORBA::Object
2419 {
2420 public:
2421 virtual ~Container();
2422
2423 #ifdef HAVE_TYPEDEF_OVERLOAD
2424 typedef Container_ptr _ptr_type;
2425 typedef Container_var _var_type;
2426 #endif
2427
2428 static Container_ptr _narrow( CORBA::Object_ptr obj );
2429 static Container_ptr _narrow( CORBA::AbstractBase_ptr obj );
2430 static Container_ptr _duplicate( Container_ptr _obj )
2431 {
2432 CORBA::Object::_duplicate (_obj);
2433 return _obj;
2434 }
2435
2436 static Container_ptr _nil()
2437 {
2438 return 0;
2439 }
2440
2441 virtual void *_narrow_helper( const char *repoid );
2442
2443 virtual ::Components::ConfigValues* configuration() = 0;
2444
2445 virtual ComponentServer_ptr get_component_server() = 0;
2446 virtual CCMHome_ptr install_home( const char* id, const char* entrypt, const ConfigValues& config ) = 0;
2447 virtual void remove_home( CCMHome_ptr href ) = 0;
2448 virtual CCMHomes* get_homes() = 0;
2449 virtual void remove() = 0;
2450
2451 protected:
2452 Container() {};
2453 private:
2454 Container( const Container& );
2455 void operator=( const Container& );
2456 };
2457
2458
2459 class Container_stub:
2460 virtual public Container
2461 {
2462 public:
2463 virtual ~Container_stub();
2464 ::Components::ConfigValues* configuration();
2465
2466 ComponentServer_ptr get_component_server();
2467 CCMHome_ptr install_home( const char* id, const char* entrypt, const ConfigValues& config );
2468 void remove_home( CCMHome_ptr href );
2469 CCMHomes* get_homes();
2470 void remove();
2471
2472 private:
2473 void operator=( const Container_stub& );
2474 };
2475
2476 #ifndef MICO_CONF_NO_POA
2477
2478 class Container_stub_clp :
2479 virtual public Container_stub,
2480 virtual public PortableServer::StubBase
2481 {
2482 public:
2483 Container_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2484 virtual ~Container_stub_clp ();
2485 ::Components::ConfigValues* configuration();
2486
2487 ComponentServer_ptr get_component_server();
2488 CCMHome_ptr install_home( const char* id, const char* entrypt, const ConfigValues& config );
2489 void remove_home( CCMHome_ptr href );
2490 CCMHomes* get_homes();
2491 void remove();
2492
2493 protected:
2494 Container_stub_clp ();
2495 private:
2496 void operator=( const Container_stub_clp & );
2497 };
2498
2499 #endif // MICO_CONF_NO_POA
2500
2501 typedef IfaceSequenceTmpl< Container_var,Container_ptr> Containers;
2502 typedef TSeqVar< IfaceSequenceTmpl< Container_var,Container_ptr> > Containers_var;
2503 typedef TSeqOut< IfaceSequenceTmpl< Container_var,Container_ptr> > Containers_out;
2504
2505
2506
2507
2508 class ComponentServer :
2509 virtual public CORBA::Object
2510 {
2511 public:
2512 virtual ~ComponentServer();
2513
2514 #ifdef HAVE_TYPEDEF_OVERLOAD
2515 typedef ComponentServer_ptr _ptr_type;
2516 typedef ComponentServer_var _var_type;
2517 #endif
2518
2519 static ComponentServer_ptr _narrow( CORBA::Object_ptr obj );
2520 static ComponentServer_ptr _narrow( CORBA::AbstractBase_ptr obj );
2521 static ComponentServer_ptr _duplicate( ComponentServer_ptr _obj )
2522 {
2523 CORBA::Object::_duplicate (_obj);
2524 return _obj;
2525 }
2526
2527 static ComponentServer_ptr _nil()
2528 {
2529 return 0;
2530 }
2531
2532 virtual void *_narrow_helper( const char *repoid );
2533
2534 virtual ::Components::ConfigValues* configuration() = 0;
2535
2536 virtual ServerActivator_ptr get_server_activator() = 0;
2537 virtual Container_ptr create_container( const ConfigValues& config ) = 0;
2538 virtual void remove_container( Container_ptr cref ) = 0;
2539 virtual Containers* get_containers() = 0;
2540 virtual void remove() = 0;
2541
2542 protected:
2543 ComponentServer() {};
2544 private:
2545 ComponentServer( const ComponentServer& );
2546 void operator=( const ComponentServer& );
2547 };
2548
2549
2550 class ComponentServer_stub:
2551 virtual public ComponentServer
2552 {
2553 public:
2554 virtual ~ComponentServer_stub();
2555 ::Components::ConfigValues* configuration();
2556
2557 ServerActivator_ptr get_server_activator();
2558 Container_ptr create_container( const ConfigValues& config );
2559 void remove_container( Container_ptr cref );
2560 Containers* get_containers();
2561 void remove();
2562
2563 private:
2564 void operator=( const ComponentServer_stub& );
2565 };
2566
2567 #ifndef MICO_CONF_NO_POA
2568
2569 class ComponentServer_stub_clp :
2570 virtual public ComponentServer_stub,
2571 virtual public PortableServer::StubBase
2572 {
2573 public:
2574 ComponentServer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2575 virtual ~ComponentServer_stub_clp ();
2576 ::Components::ConfigValues* configuration();
2577
2578 ServerActivator_ptr get_server_activator();
2579 Container_ptr create_container( const ConfigValues& config );
2580 void remove_container( Container_ptr cref );
2581 Containers* get_containers();
2582 void remove();
2583
2584 protected:
2585 ComponentServer_stub_clp ();
2586 private:
2587 void operator=( const ComponentServer_stub_clp & );
2588 };
2589
2590 #endif // MICO_CONF_NO_POA
2591
2592 typedef IfaceSequenceTmpl< ComponentServer_var,ComponentServer_ptr> ComponentServers;
2593 typedef TSeqVar< IfaceSequenceTmpl< ComponentServer_var,ComponentServer_ptr> > ComponentServers_var;
2594 typedef TSeqOut< IfaceSequenceTmpl< ComponentServer_var,ComponentServer_ptr> > ComponentServers_out;
2595
2596 typedef char* UUID;
2597 typedef CORBA::String_var UUID_var;
2598 typedef CORBA::String_out UUID_out;
2599
2600 typedef char* Location;
2601 typedef CORBA::String_var Location_var;
2602 typedef CORBA::String_out Location_out;
2603
2604
2605
2606
2607 class ComponentInstallation :
2608 virtual public CORBA::Object
2609 {
2610 public:
2611 virtual ~ComponentInstallation();
2612
2613 #ifdef HAVE_TYPEDEF_OVERLOAD
2614 typedef ComponentInstallation_ptr _ptr_type;
2615 typedef ComponentInstallation_var _var_type;
2616 #endif
2617
2618 static ComponentInstallation_ptr _narrow( CORBA::Object_ptr obj );
2619 static ComponentInstallation_ptr _narrow( CORBA::AbstractBase_ptr obj );
2620 static ComponentInstallation_ptr _duplicate( ComponentInstallation_ptr _obj )
2621 {
2622 CORBA::Object::_duplicate (_obj);
2623 return _obj;
2624 }
2625
2626 static ComponentInstallation_ptr _nil()
2627 {
2628 return 0;
2629 }
2630
2631 virtual void *_narrow_helper( const char *repoid );
2632
2633 virtual void install( const char* implUUID, const char* component_loc ) = 0;
2634 virtual void replace( const char* implUUID, const char* component_loc ) = 0;
2635 virtual void remove( const char* implUUID ) = 0;
2636 virtual char* get_implementation( const char* implUUID ) = 0;
2637
2638 protected:
2639 ComponentInstallation() {};
2640 private:
2641 ComponentInstallation( const ComponentInstallation& );
2642 void operator=( const ComponentInstallation& );
2643 };
2644
2645
2646 class ComponentInstallation_stub:
2647 virtual public ComponentInstallation
2648 {
2649 public:
2650 virtual ~ComponentInstallation_stub();
2651 void install( const char* implUUID, const char* component_loc );
2652 void replace( const char* implUUID, const char* component_loc );
2653 void remove( const char* implUUID );
2654 char* get_implementation( const char* implUUID );
2655
2656 private:
2657 void operator=( const ComponentInstallation_stub& );
2658 };
2659
2660 #ifndef MICO_CONF_NO_POA
2661
2662 class ComponentInstallation_stub_clp :
2663 virtual public ComponentInstallation_stub,
2664 virtual public PortableServer::StubBase
2665 {
2666 public:
2667 ComponentInstallation_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2668 virtual ~ComponentInstallation_stub_clp ();
2669 void install( const char* implUUID, const char* component_loc );
2670 void replace( const char* implUUID, const char* component_loc );
2671 void remove( const char* implUUID );
2672 char* get_implementation( const char* implUUID );
2673
2674 protected:
2675 ComponentInstallation_stub_clp ();
2676 private:
2677 void operator=( const ComponentInstallation_stub_clp & );
2678 };
2679
2680 #endif // MICO_CONF_NO_POA
2681
2682 enum AssemblyState {
2683 INACTIVE = 0,
2684 INSERVICE
2685 };
2686
2687 typedef AssemblyState& AssemblyState_out;
2688
2689
2690
2691
2692 class Assembly :
2693 virtual public CORBA::Object
2694 {
2695 public:
2696 virtual ~Assembly();
2697
2698 #ifdef HAVE_TYPEDEF_OVERLOAD
2699 typedef Assembly_ptr _ptr_type;
2700 typedef Assembly_var _var_type;
2701 #endif
2702
2703 static Assembly_ptr _narrow( CORBA::Object_ptr obj );
2704 static Assembly_ptr _narrow( CORBA::AbstractBase_ptr obj );
2705 static Assembly_ptr _duplicate( Assembly_ptr _obj )
2706 {
2707 CORBA::Object::_duplicate (_obj);
2708 return _obj;
2709 }
2710
2711 static Assembly_ptr _nil()
2712 {
2713 return 0;
2714 }
2715
2716 virtual void *_narrow_helper( const char *repoid );
2717
2718 virtual void build() = 0;
2719 virtual void tear_down() = 0;
2720 virtual AssemblyState get_state() = 0;
2721
2722 protected:
2723 Assembly() {};
2724 private:
2725 Assembly( const Assembly& );
2726 void operator=( const Assembly& );
2727 };
2728
2729
2730 class Assembly_stub:
2731 virtual public Assembly
2732 {
2733 public:
2734 virtual ~Assembly_stub();
2735 void build();
2736 void tear_down();
2737 AssemblyState get_state();
2738
2739 private:
2740 void operator=( const Assembly_stub& );
2741 };
2742
2743 #ifndef MICO_CONF_NO_POA
2744
2745 class Assembly_stub_clp :
2746 virtual public Assembly_stub,
2747 virtual public PortableServer::StubBase
2748 {
2749 public:
2750 Assembly_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2751 virtual ~Assembly_stub_clp ();
2752 void build();
2753 void tear_down();
2754 AssemblyState get_state();
2755
2756 protected:
2757 Assembly_stub_clp ();
2758 private:
2759 void operator=( const Assembly_stub_clp & );
2760 };
2761
2762 #endif // MICO_CONF_NO_POA
2763
2764
2765
2766
2767 class AssemblyFactory :
2768 virtual public CORBA::Object
2769 {
2770 public:
2771 virtual ~AssemblyFactory();
2772
2773 #ifdef HAVE_TYPEDEF_OVERLOAD
2774 typedef AssemblyFactory_ptr _ptr_type;
2775 typedef AssemblyFactory_var _var_type;
2776 #endif
2777
2778 static AssemblyFactory_ptr _narrow( CORBA::Object_ptr obj );
2779 static AssemblyFactory_ptr _narrow( CORBA::AbstractBase_ptr obj );
2780 static AssemblyFactory_ptr _duplicate( AssemblyFactory_ptr _obj )
2781 {
2782 CORBA::Object::_duplicate (_obj);
2783 return _obj;
2784 }
2785
2786 static AssemblyFactory_ptr _nil()
2787 {
2788 return 0;
2789 }
2790
2791 virtual void *_narrow_helper( const char *repoid );
2792
2793 virtual Cookie* create( const char* assembly_loc ) = 0;
2794 virtual Assembly_ptr lookup( Cookie* c ) = 0;
2795 virtual void destroy( Cookie* c ) = 0;
2796
2797 protected:
2798 AssemblyFactory() {};
2799 private:
2800 AssemblyFactory( const AssemblyFactory& );
2801 void operator=( const AssemblyFactory& );
2802 };
2803
2804
2805 class AssemblyFactory_stub:
2806 virtual public AssemblyFactory
2807 {
2808 public:
2809 virtual ~AssemblyFactory_stub();
2810 Cookie* create( const char* assembly_loc );
2811 Assembly_ptr lookup( Cookie* c );
2812 void destroy( Cookie* c );
2813
2814 private:
2815 void operator=( const AssemblyFactory_stub& );
2816 };
2817
2818 #ifndef MICO_CONF_NO_POA
2819
2820 class AssemblyFactory_stub_clp :
2821 virtual public AssemblyFactory_stub,
2822 virtual public PortableServer::StubBase
2823 {
2824 public:
2825 AssemblyFactory_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2826 virtual ~AssemblyFactory_stub_clp ();
2827 Cookie* create( const char* assembly_loc );
2828 Assembly_ptr lookup( Cookie* c );
2829 void destroy( Cookie* c );
2830
2831 protected:
2832 AssemblyFactory_stub_clp ();
2833 private:
2834 void operator=( const AssemblyFactory_stub_clp & );
2835 };
2836
2837 #endif // MICO_CONF_NO_POA
2838
2839
2840
2841
2842 class ServerActivator :
2843 virtual public CORBA::Object
2844 {
2845 public:
2846 virtual ~ServerActivator();
2847
2848 #ifdef HAVE_TYPEDEF_OVERLOAD
2849 typedef ServerActivator_ptr _ptr_type;
2850 typedef ServerActivator_var _var_type;
2851 #endif
2852
2853 static ServerActivator_ptr _narrow( CORBA::Object_ptr obj );
2854 static ServerActivator_ptr _narrow( CORBA::AbstractBase_ptr obj );
2855 static ServerActivator_ptr _duplicate( ServerActivator_ptr _obj )
2856 {
2857 CORBA::Object::_duplicate (_obj);
2858 return _obj;
2859 }
2860
2861 static ServerActivator_ptr _nil()
2862 {
2863 return 0;
2864 }
2865
2866 virtual void *_narrow_helper( const char *repoid );
2867
2868 virtual ComponentServer_ptr create_component_server( const ConfigValues& config ) = 0;
2869 virtual void remove_component_server( ComponentServer_ptr server ) = 0;
2870 virtual ComponentServers* get_component_servers() = 0;
2871
2872 protected:
2873 ServerActivator() {};
2874 private:
2875 ServerActivator( const ServerActivator& );
2876 void operator=( const ServerActivator& );
2877 };
2878
2879
2880 class ServerActivator_stub:
2881 virtual public ServerActivator
2882 {
2883 public:
2884 virtual ~ServerActivator_stub();
2885 ComponentServer_ptr create_component_server( const ConfigValues& config );
2886 void remove_component_server( ComponentServer_ptr server );
2887 ComponentServers* get_component_servers();
2888
2889 private:
2890 void operator=( const ServerActivator_stub& );
2891 };
2892
2893 #ifndef MICO_CONF_NO_POA
2894
2895 class ServerActivator_stub_clp :
2896 virtual public ServerActivator_stub,
2897 virtual public PortableServer::StubBase
2898 {
2899 public:
2900 ServerActivator_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2901 virtual ~ServerActivator_stub_clp ();
2902 ComponentServer_ptr create_component_server( const ConfigValues& config );
2903 void remove_component_server( ComponentServer_ptr server );
2904 ComponentServers* get_component_servers();
2905
2906 protected:
2907 ServerActivator_stub_clp ();
2908 private:
2909 void operator=( const ServerActivator_stub_clp & );
2910 };
2911
2912 #endif // MICO_CONF_NO_POA
2913
2914 }
2915
2916
2917 namespace MICOCCM
2918 {
2919
2920
2921
2922
2923 class MicoCCMD :
2924 virtual public ::Components::ServerActivator,
2925 virtual public ::Components::ComponentInstallation,
2926 virtual public ::Components::AssemblyFactory
2927 {
2928 public:
2929 virtual ~MicoCCMD();
2930
2931 #ifdef HAVE_TYPEDEF_OVERLOAD
2932 typedef MicoCCMD_ptr _ptr_type;
2933 typedef MicoCCMD_var _var_type;
2934 #endif
2935
2936 static MicoCCMD_ptr _narrow( CORBA::Object_ptr obj );
2937 static MicoCCMD_ptr _narrow( CORBA::AbstractBase_ptr obj );
2938 static MicoCCMD_ptr _duplicate( MicoCCMD_ptr _obj )
2939 {
2940 CORBA::Object::_duplicate (_obj);
2941 return _obj;
2942 }
2943
2944 static MicoCCMD_ptr _nil()
2945 {
2946 return 0;
2947 }
2948
2949 virtual void *_narrow_helper( const char *repoid );
2950
2951 virtual CORBA::Object_ptr exec( const char* prog, const ::Components::NameList& args, const char* iorfile ) = 0;
2952 virtual void callback( const char* token, CORBA::Object_ptr csref ) = 0;
2953
2954 protected:
2955 MicoCCMD() {};
2956 private:
2957 MicoCCMD( const MicoCCMD& );
2958 void operator=( const MicoCCMD& );
2959 };
2960
2961
2962 class MicoCCMD_stub:
2963 virtual public MicoCCMD,
2964 virtual public ::Components::ServerActivator_stub,
2965 virtual public ::Components::ComponentInstallation_stub,
2966 virtual public ::Components::AssemblyFactory_stub
2967 {
2968 public:
2969 virtual ~MicoCCMD_stub();
2970 CORBA::Object_ptr exec( const char* prog, const ::Components::NameList& args, const char* iorfile );
2971 void callback( const char* token, CORBA::Object_ptr csref );
2972
2973 private:
2974 void operator=( const MicoCCMD_stub& );
2975 };
2976
2977 #ifndef MICO_CONF_NO_POA
2978
2979 class MicoCCMD_stub_clp :
2980 virtual public MicoCCMD_stub,
2981 virtual public ::Components::ServerActivator_stub_clp,
2982 virtual public ::Components::ComponentInstallation_stub_clp,
2983 virtual public ::Components::AssemblyFactory_stub_clp
2984 {
2985 public:
2986 MicoCCMD_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2987 virtual ~MicoCCMD_stub_clp ();
2988 CORBA::Object_ptr exec( const char* prog, const ::Components::NameList& args, const char* iorfile );
2989 void callback( const char* token, CORBA::Object_ptr csref );
2990
2991 protected:
2992 MicoCCMD_stub_clp ();
2993 private:
2994 void operator=( const MicoCCMD_stub_clp & );
2995 };
2996
2997 #endif // MICO_CONF_NO_POA
2998
2999
3000
3001
3002 class ComponentServer :
3003 virtual public ::Components::ComponentServer
3004 {
3005 public:
3006 virtual ~ComponentServer();
3007
3008 #ifdef HAVE_TYPEDEF_OVERLOAD
3009 typedef ComponentServer_ptr _ptr_type;
3010 typedef ComponentServer_var _var_type;
3011 #endif
3012
3013 static ComponentServer_ptr _narrow( CORBA::Object_ptr obj );
3014 static ComponentServer_ptr _narrow( CORBA::AbstractBase_ptr obj );
3015 static ComponentServer_ptr _duplicate( ComponentServer_ptr _obj )
3016 {
3017 CORBA::Object::_duplicate (_obj);
3018 return _obj;
3019 }
3020
3021 static ComponentServer_ptr _nil()
3022 {
3023 return 0;
3024 }
3025
3026 virtual void *_narrow_helper( const char *repoid );
3027
3028 virtual void set_config_values( const ::Components::ConfigValues& config ) = 0;
3029
3030 protected:
3031 ComponentServer() {};
3032 private:
3033 ComponentServer( const ComponentServer& );
3034 void operator=( const ComponentServer& );
3035 };
3036
3037
3038 class ComponentServer_stub:
3039 virtual public ComponentServer,
3040 virtual public ::Components::ComponentServer_stub
3041 {
3042 public:
3043 virtual ~ComponentServer_stub();
3044 void set_config_values( const ::Components::ConfigValues& config );
3045
3046 private:
3047 void operator=( const ComponentServer_stub& );
3048 };
3049
3050 #ifndef MICO_CONF_NO_POA
3051
3052 class ComponentServer_stub_clp :
3053 virtual public ComponentServer_stub,
3054 virtual public ::Components::ComponentServer_stub_clp
3055 {
3056 public:
3057 ComponentServer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
3058 virtual ~ComponentServer_stub_clp ();
3059 void set_config_values( const ::Components::ConfigValues& config );
3060
3061 protected:
3062 ComponentServer_stub_clp ();
3063 private:
3064 void operator=( const ComponentServer_stub_clp & );
3065 };
3066
3067 #endif // MICO_CONF_NO_POA
3068
3069 }
3070
3071
3072 namespace HPI
3073 {
3074
3075
3076
3077
3078 class HomeFinder :
3079 virtual public ::Components::HomeFinder
3080 {
3081 public:
3082 virtual ~HomeFinder();
3083
3084 #ifdef HAVE_TYPEDEF_OVERLOAD
3085 typedef HomeFinder_ptr _ptr_type;
3086 typedef HomeFinder_var _var_type;
3087 #endif
3088
3089 static HomeFinder_ptr _narrow( CORBA::Object_ptr obj );
3090 static HomeFinder_ptr _narrow( CORBA::AbstractBase_ptr obj );
3091 static HomeFinder_ptr _duplicate( HomeFinder_ptr _obj )
3092 {
3093 CORBA::Object::_duplicate (_obj);
3094 return _obj;
3095 }
3096
3097 static HomeFinder_ptr _nil()
3098 {
3099 return 0;
3100 }
3101
3102 virtual void *_narrow_helper( const char *repoid );
3103
3104 virtual CORBA::Long _cxx_register( const char* comp_repid, const char* home_repid, ::Components::CCMHome_ptr the_home ) = 0;
3105 virtual void unregister( CORBA::Long cookie ) = 0;
3106
3107 protected:
3108 HomeFinder() {};
3109 private:
3110 HomeFinder( const HomeFinder& );
3111 void operator=( const HomeFinder& );
3112 };
3113
3114
3115 class HomeFinder_stub:
3116 virtual public HomeFinder,
3117 virtual public ::Components::HomeFinder_stub
3118 {
3119 public:
3120 virtual ~HomeFinder_stub();
3121 CORBA::Long _cxx_register( const char* comp_repid, const char* home_repid, ::Components::CCMHome_ptr the_home );
3122 void unregister( CORBA::Long cookie );
3123
3124 private:
3125 void operator=( const HomeFinder_stub& );
3126 };
3127
3128 #ifndef MICO_CONF_NO_POA
3129
3130 class HomeFinder_stub_clp :
3131 virtual public HomeFinder_stub,
3132 virtual public ::Components::HomeFinder_stub_clp
3133 {
3134 public:
3135 HomeFinder_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
3136 virtual ~HomeFinder_stub_clp ();
3137 CORBA::Long _cxx_register( const char* comp_repid, const char* home_repid, ::Components::CCMHome_ptr the_home );
3138 void unregister( CORBA::Long cookie );
3139
3140 protected:
3141 HomeFinder_stub_clp ();
3142 private:
3143 void operator=( const HomeFinder_stub_clp & );
3144 };
3145
3146 #endif // MICO_CONF_NO_POA
3147
3148 }
3149
3150
3151 #ifndef MICO_CONF_NO_POA
3152
3153
3154
3155 namespace POA_Components
3156 {
3157
3158 class Navigation : virtual public PortableServer::StaticImplementation
3159 {
3160 public:
3161 virtual ~Navigation ();
3162 Components::Navigation_ptr _this ();
3163 bool dispatch (CORBA::StaticServerRequest_ptr);
3164 virtual void invoke (CORBA::StaticServerRequest_ptr);
3165 virtual CORBA::Boolean _is_a (const char *);
3166 virtual CORBA::InterfaceDef_ptr _get_interface ();
3167 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3168
3169 virtual void * _narrow_helper (const char *);
3170 static Navigation * _narrow (PortableServer::Servant);
3171 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3172
3173 virtual CORBA::Object_ptr provide_facet( const char* name ) = 0;
3174 virtual ::Components::FacetDescriptions* get_all_facets() = 0;
3175 virtual ::Components::FacetDescriptions* get_named_facets( const ::Components::NameList& names ) = 0;
3176 virtual CORBA::Boolean same_component( CORBA::Object_ptr ref ) = 0;
3177
3178 protected:
3179 Navigation () {};
3180
3181 private:
3182 Navigation (const Navigation &);
3183 void operator= (const Navigation &);
3184 };
3185
3186 class Receptacles : virtual public PortableServer::StaticImplementation
3187 {
3188 public:
3189 virtual ~Receptacles ();
3190 Components::Receptacles_ptr _this ();
3191 bool dispatch (CORBA::StaticServerRequest_ptr);
3192 virtual void invoke (CORBA::StaticServerRequest_ptr);
3193 virtual CORBA::Boolean _is_a (const char *);
3194 virtual CORBA::InterfaceDef_ptr _get_interface ();
3195 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3196
3197 virtual void * _narrow_helper (const char *);
3198 static Receptacles * _narrow (PortableServer::Servant);
3199 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3200
3201 virtual ::Components::Cookie* connect( const char* name, CORBA::Object_ptr connection ) = 0;
3202 virtual void disconnect( const char* name, ::Components::Cookie* ck ) = 0;
3203 virtual ::Components::ConnectionDescriptions* get_connections( const char* name ) = 0;
3204 virtual ::Components::ReceptacleDescriptions* get_all_receptacles() = 0;
3205 virtual ::Components::ReceptacleDescriptions* get_named_receptacles( const ::Components::NameList& names ) = 0;
3206
3207 protected:
3208 Receptacles () {};
3209
3210 private:
3211 Receptacles (const Receptacles &);
3212 void operator= (const Receptacles &);
3213 };
3214
3215 class EventConsumerBase : virtual public PortableServer::StaticImplementation
3216 {
3217 public:
3218 virtual ~EventConsumerBase ();
3219 Components::EventConsumerBase_ptr _this ();
3220 bool dispatch (CORBA::StaticServerRequest_ptr);
3221 virtual void invoke (CORBA::StaticServerRequest_ptr);
3222 virtual CORBA::Boolean _is_a (const char *);
3223 virtual CORBA::InterfaceDef_ptr _get_interface ();
3224 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3225
3226 virtual void * _narrow_helper (const char *);
3227 static EventConsumerBase * _narrow (PortableServer::Servant);
3228 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3229
3230 virtual void push_event( ::Components::EventBase* evt ) = 0;
3231
3232 protected:
3233 EventConsumerBase () {};
3234
3235 private:
3236 EventConsumerBase (const EventConsumerBase &);
3237 void operator= (const EventConsumerBase &);
3238 };
3239
3240 class Events : virtual public PortableServer::StaticImplementation
3241 {
3242 public:
3243 virtual ~Events ();
3244 Components::Events_ptr _this ();
3245 bool dispatch (CORBA::StaticServerRequest_ptr);
3246 virtual void invoke (CORBA::StaticServerRequest_ptr);
3247 virtual CORBA::Boolean _is_a (const char *);
3248 virtual CORBA::InterfaceDef_ptr _get_interface ();
3249 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3250
3251 virtual void * _narrow_helper (const char *);
3252 static Events * _narrow (PortableServer::Servant);
3253 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3254
3255 virtual ::Components::EventConsumerBase_ptr get_consumer( const char* sink_name ) = 0;
3256 virtual ::Components::ConsumerDescriptions* get_all_consumers() = 0;
3257 virtual ::Components::ConsumerDescriptions* get_named_consumers( const ::Components::NameList& names ) = 0;
3258 virtual ::Components::Cookie* subscribe( const char* publisher_name, ::Components::EventConsumerBase_ptr subscriber ) = 0;
3259 virtual void unsubscribe( const char* publisher_name, ::Components::Cookie* ck ) = 0;
3260 virtual ::Components::PublisherDescriptions* get_all_publishers() = 0;
3261 virtual ::Components::PublisherDescriptions* get_named_publishers( const ::Components::NameList& names ) = 0;
3262 virtual void connect_consumer( const char* emitter_name, ::Components::EventConsumerBase_ptr consumer ) = 0;
3263 virtual ::Components::EventConsumerBase_ptr disconnect_consumer( const char* source_name ) = 0;
3264 virtual ::Components::EmitterDescriptions* get_all_emitters() = 0;
3265 virtual ::Components::EmitterDescriptions* get_named_emitters( const ::Components::NameList& names ) = 0;
3266
3267 protected:
3268 Events () {};
3269
3270 private:
3271 Events (const Events &);
3272 void operator= (const Events &);
3273 };
3274
3275 class CCMHome : virtual public PortableServer::StaticImplementation
3276 {
3277 public:
3278 virtual ~CCMHome ();
3279 Components::CCMHome_ptr _this ();
3280 bool dispatch (CORBA::StaticServerRequest_ptr);
3281 virtual void invoke (CORBA::StaticServerRequest_ptr);
3282 virtual CORBA::Boolean _is_a (const char *);
3283 virtual CORBA::InterfaceDef_ptr _get_interface ();
3284 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3285
3286 virtual void * _narrow_helper (const char *);
3287 static CCMHome * _narrow (PortableServer::Servant);
3288 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3289
3290 virtual CORBA::Object_ptr get_component_def() = 0;
3291 virtual CORBA::Object_ptr get_home_def() = 0;
3292 virtual void remove_component( ::Components::CCMObject_ptr comp ) = 0;
3293
3294 protected:
3295 CCMHome () {};
3296
3297 private:
3298 CCMHome (const CCMHome &);
3299 void operator= (const CCMHome &);
3300 };
3301
3302 class CCMObject :
3303 virtual public POA_Components::Navigation,
3304 virtual public POA_Components::Receptacles,
3305 virtual public POA_Components::Events
3306 {
3307 public:
3308 virtual ~CCMObject ();
3309 Components::CCMObject_ptr _this ();
3310 bool dispatch (CORBA::StaticServerRequest_ptr);
3311 virtual void invoke (CORBA::StaticServerRequest_ptr);
3312 virtual CORBA::Boolean _is_a (const char *);
3313 virtual CORBA::InterfaceDef_ptr _get_interface ();
3314 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3315
3316 virtual void * _narrow_helper (const char *);
3317 static CCMObject * _narrow (PortableServer::Servant);
3318 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3319
3320 virtual CORBA::Object_ptr get_component_def() = 0;
3321 virtual ::Components::CCMHome_ptr get_ccm_home() = 0;
3322 virtual void configuration_complete() = 0;
3323 virtual void remove() = 0;
3324 virtual ::Components::ComponentPortDescription* get_all_ports() = 0;
3325
3326 protected:
3327 CCMObject () {};
3328
3329 private:
3330 CCMObject (const CCMObject &);
3331 void operator= (const CCMObject &);
3332 };
3333
3334 class KeylessCCMHome : virtual public PortableServer::StaticImplementation
3335 {
3336 public:
3337 virtual ~KeylessCCMHome ();
3338 Components::KeylessCCMHome_ptr _this ();
3339 bool dispatch (CORBA::StaticServerRequest_ptr);
3340 virtual void invoke (CORBA::StaticServerRequest_ptr);
3341 virtual CORBA::Boolean _is_a (const char *);
3342 virtual CORBA::InterfaceDef_ptr _get_interface ();
3343 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3344
3345 virtual void * _narrow_helper (const char *);
3346 static KeylessCCMHome * _narrow (PortableServer::Servant);
3347 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3348
3349 virtual ::Components::CCMObject_ptr create_component() = 0;
3350
3351 protected:
3352 KeylessCCMHome () {};
3353
3354 private:
3355 KeylessCCMHome (const KeylessCCMHome &);
3356 void operator= (const KeylessCCMHome &);
3357 };
3358
3359 class HomeFinder : virtual public PortableServer::StaticImplementation
3360 {
3361 public:
3362 virtual ~HomeFinder ();
3363 Components::HomeFinder_ptr _this ();
3364 bool dispatch (CORBA::StaticServerRequest_ptr);
3365 virtual void invoke (CORBA::StaticServerRequest_ptr);
3366 virtual CORBA::Boolean _is_a (const char *);
3367 virtual CORBA::InterfaceDef_ptr _get_interface ();
3368 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3369
3370 virtual void * _narrow_helper (const char *);
3371 static HomeFinder * _narrow (PortableServer::Servant);
3372 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3373
3374 virtual ::Components::CCMHome_ptr find_home_by_component_type( const char* comp_repid ) = 0;
3375 virtual ::Components::CCMHome_ptr find_home_by_home_type( const char* home_repid ) = 0;
3376 virtual ::Components::CCMHome_ptr find_home_by_name( const char* home_name ) = 0;
3377
3378 protected:
3379 HomeFinder () {};
3380
3381 private:
3382 HomeFinder (const HomeFinder &);
3383 void operator= (const HomeFinder &);
3384 };
3385
3386 class Configurator : virtual public PortableServer::StaticImplementation
3387 {
3388 public:
3389 virtual ~Configurator ();
3390 Components::Configurator_ptr _this ();
3391 bool dispatch (CORBA::StaticServerRequest_ptr);
3392 virtual void invoke (CORBA::StaticServerRequest_ptr);
3393 virtual CORBA::Boolean _is_a (const char *);
3394 virtual CORBA::InterfaceDef_ptr _get_interface ();
3395 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3396
3397 virtual void * _narrow_helper (const char *);
3398 static Configurator * _narrow (PortableServer::Servant);
3399 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3400
3401 virtual void configure( ::Components::CCMObject_ptr comp ) = 0;
3402
3403 protected:
3404 Configurator () {};
3405
3406 private:
3407 Configurator (const Configurator &);
3408 void operator= (const Configurator &);
3409 };
3410
3411 class StandardConfigurator :
3412 virtual public POA_Components::Configurator
3413 {
3414 public:
3415 virtual ~StandardConfigurator ();
3416 Components::StandardConfigurator_ptr _this ();
3417 bool dispatch (CORBA::StaticServerRequest_ptr);
3418 virtual void invoke (CORBA::StaticServerRequest_ptr);
3419 virtual CORBA::Boolean _is_a (const char *);
3420 virtual CORBA::InterfaceDef_ptr _get_interface ();
3421 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3422
3423 virtual void * _narrow_helper (const char *);
3424 static StandardConfigurator * _narrow (PortableServer::Servant);
3425 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3426
3427 virtual void set_configuration( const ::Components::ConfigValues& descr ) = 0;
3428
3429 protected:
3430 StandardConfigurator () {};
3431
3432 private:
3433 StandardConfigurator (const StandardConfigurator &);
3434 void operator= (const StandardConfigurator &);
3435 };
3436
3437 class Container : virtual public PortableServer::StaticImplementation
3438 {
3439 public:
3440 virtual ~Container ();
3441 Components::Container_ptr _this ();
3442 bool dispatch (CORBA::StaticServerRequest_ptr);
3443 virtual void invoke (CORBA::StaticServerRequest_ptr);
3444 virtual CORBA::Boolean _is_a (const char *);
3445 virtual CORBA::InterfaceDef_ptr _get_interface ();
3446 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3447
3448 virtual void * _narrow_helper (const char *);
3449 static Container * _narrow (PortableServer::Servant);
3450 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3451
3452 virtual ::Components::ConfigValues* configuration() = 0;
3453
3454 virtual ::Components::ComponentServer_ptr get_component_server() = 0;
3455 virtual ::Components::CCMHome_ptr install_home( const char* id, const char* entrypt, const ::Components::ConfigValues& config ) = 0;
3456 virtual void remove_home( ::Components::CCMHome_ptr href ) = 0;
3457 virtual ::Components::CCMHomes* get_homes() = 0;
3458 virtual void remove() = 0;
3459
3460 protected:
3461 Container () {};
3462
3463 private:
3464 Container (const Container &);
3465 void operator= (const Container &);
3466 };
3467
3468 class ComponentServer : virtual public PortableServer::StaticImplementation
3469 {
3470 public:
3471 virtual ~ComponentServer ();
3472 Components::ComponentServer_ptr _this ();
3473 bool dispatch (CORBA::StaticServerRequest_ptr);
3474 virtual void invoke (CORBA::StaticServerRequest_ptr);
3475 virtual CORBA::Boolean _is_a (const char *);
3476 virtual CORBA::InterfaceDef_ptr _get_interface ();
3477 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3478
3479 virtual void * _narrow_helper (const char *);
3480 static ComponentServer * _narrow (PortableServer::Servant);
3481 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3482
3483 virtual ::Components::ConfigValues* configuration() = 0;
3484
3485 virtual ::Components::ServerActivator_ptr get_server_activator() = 0;
3486 virtual ::Components::Container_ptr create_container( const ::Components::ConfigValues& config ) = 0;
3487 virtual void remove_container( ::Components::Container_ptr cref ) = 0;
3488 virtual ::Components::Containers* get_containers() = 0;
3489 virtual void remove() = 0;
3490
3491 protected:
3492 ComponentServer () {};
3493
3494 private:
3495 ComponentServer (const ComponentServer &);
3496 void operator= (const ComponentServer &);
3497 };
3498
3499 class ComponentInstallation : virtual public PortableServer::StaticImplementation
3500 {
3501 public:
3502 virtual ~ComponentInstallation ();
3503 Components::ComponentInstallation_ptr _this ();
3504 bool dispatch (CORBA::StaticServerRequest_ptr);
3505 virtual void invoke (CORBA::StaticServerRequest_ptr);
3506 virtual CORBA::Boolean _is_a (const char *);
3507 virtual CORBA::InterfaceDef_ptr _get_interface ();
3508 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3509
3510 virtual void * _narrow_helper (const char *);
3511 static ComponentInstallation * _narrow (PortableServer::Servant);
3512 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3513
3514 virtual void install( const char* implUUID, const char* component_loc ) = 0;
3515 virtual void replace( const char* implUUID, const char* component_loc ) = 0;
3516 virtual void remove( const char* implUUID ) = 0;
3517 virtual char* get_implementation( const char* implUUID ) = 0;
3518
3519 protected:
3520 ComponentInstallation () {};
3521
3522 private:
3523 ComponentInstallation (const ComponentInstallation &);
3524 void operator= (const ComponentInstallation &);
3525 };
3526
3527 class Assembly : virtual public PortableServer::StaticImplementation
3528 {
3529 public:
3530 virtual ~Assembly ();
3531 Components::Assembly_ptr _this ();
3532 bool dispatch (CORBA::StaticServerRequest_ptr);
3533 virtual void invoke (CORBA::StaticServerRequest_ptr);
3534 virtual CORBA::Boolean _is_a (const char *);
3535 virtual CORBA::InterfaceDef_ptr _get_interface ();
3536 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3537
3538 virtual void * _narrow_helper (const char *);
3539 static Assembly * _narrow (PortableServer::Servant);
3540 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3541
3542 virtual void build() = 0;
3543 virtual void tear_down() = 0;
3544 virtual ::Components::AssemblyState get_state() = 0;
3545
3546 protected:
3547 Assembly () {};
3548
3549 private:
3550 Assembly (const Assembly &);
3551 void operator= (const Assembly &);
3552 };
3553
3554 class AssemblyFactory : virtual public PortableServer::StaticImplementation
3555 {
3556 public:
3557 virtual ~AssemblyFactory ();
3558 Components::AssemblyFactory_ptr _this ();
3559 bool dispatch (CORBA::StaticServerRequest_ptr);
3560 virtual void invoke (CORBA::StaticServerRequest_ptr);
3561 virtual CORBA::Boolean _is_a (const char *);
3562 virtual CORBA::InterfaceDef_ptr _get_interface ();
3563 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3564
3565 virtual void * _narrow_helper (const char *);
3566 static AssemblyFactory * _narrow (PortableServer::Servant);
3567 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3568
3569 virtual ::Components::Cookie* create( const char* assembly_loc ) = 0;
3570 virtual ::Components::Assembly_ptr lookup( ::Components::Cookie* c ) = 0;
3571 virtual void destroy( ::Components::Cookie* c ) = 0;
3572
3573 protected:
3574 AssemblyFactory () {};
3575
3576 private:
3577 AssemblyFactory (const AssemblyFactory &);
3578 void operator= (const AssemblyFactory &);
3579 };
3580
3581 class ServerActivator : virtual public PortableServer::StaticImplementation
3582 {
3583 public:
3584 virtual ~ServerActivator ();
3585 Components::ServerActivator_ptr _this ();
3586 bool dispatch (CORBA::StaticServerRequest_ptr);
3587 virtual void invoke (CORBA::StaticServerRequest_ptr);
3588 virtual CORBA::Boolean _is_a (const char *);
3589 virtual CORBA::InterfaceDef_ptr _get_interface ();
3590 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3591
3592 virtual void * _narrow_helper (const char *);
3593 static ServerActivator * _narrow (PortableServer::Servant);
3594 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3595
3596 virtual ::Components::ComponentServer_ptr create_component_server( const ::Components::ConfigValues& config ) = 0;
3597 virtual void remove_component_server( ::Components::ComponentServer_ptr server ) = 0;
3598 virtual ::Components::ComponentServers* get_component_servers() = 0;
3599
3600 protected:
3601 ServerActivator () {};
3602
3603 private:
3604 ServerActivator (const ServerActivator &);
3605 void operator= (const ServerActivator &);
3606 };
3607
3608 }
3609
3610
3611 namespace POA_MICOCCM
3612 {
3613
3614 class MicoCCMD :
3615 virtual public POA_Components::ServerActivator,
3616 virtual public POA_Components::ComponentInstallation,
3617 virtual public POA_Components::AssemblyFactory
3618 {
3619 public:
3620 virtual ~MicoCCMD ();
3621 MICOCCM::MicoCCMD_ptr _this ();
3622 bool dispatch (CORBA::StaticServerRequest_ptr);
3623 virtual void invoke (CORBA::StaticServerRequest_ptr);
3624 virtual CORBA::Boolean _is_a (const char *);
3625 virtual CORBA::InterfaceDef_ptr _get_interface ();
3626 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3627
3628 virtual void * _narrow_helper (const char *);
3629 static MicoCCMD * _narrow (PortableServer::Servant);
3630 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3631
3632 virtual CORBA::Object_ptr exec( const char* prog, const ::Components::NameList& args, const char* iorfile ) = 0;
3633 virtual void callback( const char* token, CORBA::Object_ptr csref ) = 0;
3634
3635 protected:
3636 MicoCCMD () {};
3637
3638 private:
3639 MicoCCMD (const MicoCCMD &);
3640 void operator= (const MicoCCMD &);
3641 };
3642
3643 class ComponentServer :
3644 virtual public POA_Components::ComponentServer
3645 {
3646 public:
3647 virtual ~ComponentServer ();
3648 MICOCCM::ComponentServer_ptr _this ();
3649 bool dispatch (CORBA::StaticServerRequest_ptr);
3650 virtual void invoke (CORBA::StaticServerRequest_ptr);
3651 virtual CORBA::Boolean _is_a (const char *);
3652 virtual CORBA::InterfaceDef_ptr _get_interface ();
3653 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3654
3655 virtual void * _narrow_helper (const char *);
3656 static ComponentServer * _narrow (PortableServer::Servant);
3657 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3658
3659 virtual void set_config_values( const ::Components::ConfigValues& config ) = 0;
3660
3661 protected:
3662 ComponentServer () {};
3663
3664 private:
3665 ComponentServer (const ComponentServer &);
3666 void operator= (const ComponentServer &);
3667 };
3668
3669 }
3670
3671
3672 namespace POA_HPI
3673 {
3674
3675 class HomeFinder :
3676 virtual public POA_Components::HomeFinder
3677 {
3678 public:
3679 virtual ~HomeFinder ();
3680 HPI::HomeFinder_ptr _this ();
3681 bool dispatch (CORBA::StaticServerRequest_ptr);
3682 virtual void invoke (CORBA::StaticServerRequest_ptr);
3683 virtual CORBA::Boolean _is_a (const char *);
3684 virtual CORBA::InterfaceDef_ptr _get_interface ();
3685 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3686
3687 virtual void * _narrow_helper (const char *);
3688 static HomeFinder * _narrow (PortableServer::Servant);
3689 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3690
3691 virtual CORBA::Long _cxx_register( const char* comp_repid, const char* home_repid, ::Components::CCMHome_ptr the_home ) = 0;
3692 virtual void unregister( CORBA::Long cookie ) = 0;
3693
3694 protected:
3695 HomeFinder () {};
3696
3697 private:
3698 HomeFinder (const HomeFinder &);
3699 void operator= (const HomeFinder &);
3700 };
3701
3702 }
3703
3704
3705 #endif // MICO_CONF_NO_POA
3706
3707
3708
3709 namespace OBV_Components
3710 {
3711
3712
3713
3714 class PortDescription : virtual public Components::PortDescription
3715 {
3716 protected:
3717 PortDescription ();
3718 PortDescription (const char* _name, const char* _type_id);
3719 virtual ~PortDescription();
3720
3721 public:
3722 void name( char *_p );
3723 void name( const char *_p );
3724 void name( const CORBA::String_var &_p );
3725 const char *name() const;
3726
3727 void type_id( char *_p );
3728 void type_id( const char *_p );
3729 void type_id( const CORBA::String_var &_p );
3730 const char *type_id() const;
3731
3732
3733 private:
3734 struct _M {
3735 ::Components::FeatureName_var name;
3736 CORBA::String_var type_id;
3737 } _m;
3738 };
3739
3740
3741
3742 class Cookie : virtual public Components::Cookie
3743 {
3744 protected:
3745 Cookie ();
3746 Cookie (const SequenceTmpl< CORBA::Octet,MICO_TID_OCTET>& _CookieValue);
3747 virtual ~Cookie();
3748
3749 public:
3750 typedef SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> _CookieValue_seq;
3751 void CookieValue( const _CookieValue_seq & _p);
3752 const _CookieValue_seq & CookieValue() const;
3753 _CookieValue_seq & CookieValue();
3754
3755
3756 private:
3757 struct _M {
3758 SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> CookieValue;
3759 } _m;
3760 };
3761
3762
3763
3764 class FacetDescription :
3765 virtual public Components::FacetDescription,
3766 virtual public OBV_Components::PortDescription
3767 {
3768 protected:
3769 FacetDescription ();
3770 FacetDescription (CORBA::Object_ptr _facet_ref);
3771 virtual ~FacetDescription();
3772
3773 public:
3774 void facet_ref( CORBA::Object_ptr _p );
3775 CORBA::Object_ptr facet_ref() const;
3776
3777
3778 private:
3779 struct _M {
3780 CORBA::Object_var facet_ref;
3781 } _m;
3782 };
3783
3784
3785
3786 class ConnectionDescription : virtual public Components::ConnectionDescription
3787 {
3788 protected:
3789 ConnectionDescription ();
3790 ConnectionDescription (::Components::Cookie* _ck, CORBA::Object_ptr _objref);
3791 virtual ~ConnectionDescription();
3792
3793 public:
3794 void ck( ::Components::Cookie* _p );
3795 ::Components::Cookie* ck() const;
3796
3797 void objref( CORBA::Object_ptr _p );
3798 CORBA::Object_ptr objref() const;
3799
3800
3801 private:
3802 struct _M {
3803 ::Components::Cookie_var ck;
3804 CORBA::Object_var objref;
3805 } _m;
3806 };
3807
3808
3809
3810 class ReceptacleDescription :
3811 virtual public Components::ReceptacleDescription,
3812 virtual public OBV_Components::PortDescription
3813 {
3814 protected:
3815 ReceptacleDescription ();
3816 ReceptacleDescription (CORBA::Boolean _is_multiplex, const ::Components::ConnectionDescriptions& _connections);
3817 virtual ~ReceptacleDescription();
3818
3819 public:
3820 void is_multiplex( CORBA::Boolean _p );
3821 CORBA::Boolean is_multiplex() const;
3822
3823 void connections( const ::Components::ConnectionDescriptions& _p );
3824 const ::Components::ConnectionDescriptions& connections() const;
3825 ::Components::ConnectionDescriptions& connections();
3826
3827
3828 private:
3829 struct _M {
3830 CORBA::Boolean is_multiplex;
3831 ::Components::ConnectionDescriptions connections;
3832 } _m;
3833 };
3834
3835
3836
3837 class ConsumerDescription :
3838 virtual public Components::ConsumerDescription,
3839 virtual public OBV_Components::PortDescription
3840 {
3841 protected:
3842 ConsumerDescription ();
3843 ConsumerDescription (::Components::EventConsumerBase_ptr _consumer);
3844 virtual ~ConsumerDescription();
3845
3846 public:
3847 void consumer( ::Components::EventConsumerBase_ptr _p );
3848 ::Components::EventConsumerBase_ptr consumer() const;
3849
3850
3851 private:
3852 struct _M {
3853 ::Components::EventConsumerBase_var consumer;
3854 } _m;
3855 };
3856
3857
3858
3859 class EmitterDescription :
3860 virtual public Components::EmitterDescription,
3861 virtual public OBV_Components::PortDescription
3862 {
3863 protected:
3864 EmitterDescription ();
3865 EmitterDescription (::Components::EventConsumerBase_ptr _consumer);
3866 virtual ~EmitterDescription();
3867
3868 public:
3869 void consumer( ::Components::EventConsumerBase_ptr _p );
3870 ::Components::EventConsumerBase_ptr consumer() const;
3871
3872
3873 private:
3874 struct _M {
3875 ::Components::EventConsumerBase_var consumer;
3876 } _m;
3877 };
3878
3879
3880
3881 class SubscriberDescription : virtual public Components::SubscriberDescription
3882 {
3883 protected:
3884 SubscriberDescription ();
3885 SubscriberDescription (::Components::Cookie* _ck, ::Components::EventConsumerBase_ptr _consumer);
3886 virtual ~SubscriberDescription();
3887
3888 public:
3889 void ck( ::Components::Cookie* _p );
3890 ::Components::Cookie* ck() const;
3891
3892 void consumer( ::Components::EventConsumerBase_ptr _p );
3893 ::Components::EventConsumerBase_ptr consumer() const;
3894
3895
3896 private:
3897 struct _M {
3898 ::Components::Cookie_var ck;
3899 ::Components::EventConsumerBase_var consumer;
3900 } _m;
3901 };
3902
3903
3904
3905 class PublisherDescription :
3906 virtual public Components::PublisherDescription,
3907 virtual public OBV_Components::PortDescription
3908 {
3909 protected:
3910 PublisherDescription ();
3911 PublisherDescription (const ::Components::SubscriberDescriptions& _consumers);
3912 virtual ~PublisherDescription();
3913
3914 public:
3915 void consumers( const ::Components::SubscriberDescriptions& _p );
3916 const ::Components::SubscriberDescriptions& consumers() const;
3917 ::Components::SubscriberDescriptions& consumers();
3918
3919
3920 private:
3921 struct _M {
3922 ::Components::SubscriberDescriptions consumers;
3923 } _m;
3924 };
3925
3926
3927
3928 class ComponentPortDescription : virtual public Components::ComponentPortDescription
3929 {
3930 protected:
3931 ComponentPortDescription ();
3932 ComponentPortDescription (const ::Components::FacetDescriptions& _facets, const ::Components::ReceptacleDescriptions& _receptacles, const ::Components::ConsumerDescriptions& _consumers, const ::Components::EmitterDescriptions& _emitters, const ::Components::PublisherDescriptions& _publishers);
3933 virtual ~ComponentPortDescription();
3934
3935 public:
3936 void facets( const ::Components::FacetDescriptions& _p );
3937 const ::Components::FacetDescriptions& facets() const;
3938 ::Components::FacetDescriptions& facets();
3939
3940 void receptacles( const ::Components::ReceptacleDescriptions& _p );
3941 const ::Components::ReceptacleDescriptions& receptacles() const;
3942 ::Components::ReceptacleDescriptions& receptacles();
3943
3944 void consumers( const ::Components::ConsumerDescriptions& _p );
3945 const ::Components::ConsumerDescriptions& consumers() const;
3946 ::Components::ConsumerDescriptions& consumers();
3947
3948 void emitters( const ::Components::EmitterDescriptions& _p );
3949 const ::Components::EmitterDescriptions& emitters() const;
3950 ::Components::EmitterDescriptions& emitters();
3951
3952 void publishers( const ::Components::PublisherDescriptions& _p );
3953 const ::Components::PublisherDescriptions& publishers() const;
3954 ::Components::PublisherDescriptions& publishers();
3955
3956
3957 private:
3958 struct _M {
3959 ::Components::FacetDescriptions facets;
3960 ::Components::ReceptacleDescriptions receptacles;
3961 ::Components::ConsumerDescriptions consumers;
3962 ::Components::EmitterDescriptions emitters;
3963 ::Components::PublisherDescriptions publishers;
3964 } _m;
3965 };
3966
3967
3968
3969 class ConfigValue : virtual public Components::ConfigValue
3970 {
3971 protected:
3972 ConfigValue ();
3973 ConfigValue (const char* _name, const CORBA::Any& _value);
3974 virtual ~ConfigValue();
3975
3976 public:
3977 void name( char *_p );
3978 void name( const char *_p );
3979 void name( const CORBA::String_var &_p );
3980 const char *name() const;
3981
3982 void value( const CORBA::Any& _p );
3983 const CORBA::Any& value() const;
3984 CORBA::Any& value();
3985
3986
3987 private:
3988 struct _M {
3989 ::Components::FeatureName_var name;
3990 CORBA::Any value;
3991 } _m;
3992 };
3993
3994 }
3995
3996
3997 extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidName;
3998
3999 extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidConfiguration;
4000
4001 extern CORBA::StaticTypeInfo *_marshaller_Components_AlreadyConnected;
4002
4003 extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidConnection;
4004
4005 extern CORBA::StaticTypeInfo *_marshaller_Components_NoConnection;
4006
4007 extern CORBA::StaticTypeInfo *_marshaller_Components_ExceededConnectionLimit;
4008
4009 extern CORBA::StaticTypeInfo *_marshaller_Components_CookieRequired;
4010
4011 extern CORBA::StaticTypeInfo *_marshaller_Components_PortDescription;
4012
4013 extern CORBA::StaticTypeInfo *_marshaller_Components_Cookie;
4014
4015 extern CORBA::StaticTypeInfo *_marshaller_Components_EventBase;
4016
4017 extern CORBA::StaticTypeInfo *_marshaller_Components_FacetDescription;
4018
4019 extern CORBA::StaticTypeInfo *_marshaller_Components_Navigation;
4020
4021 extern CORBA::StaticTypeInfo *_marshaller_Components_ConnectionDescription;
4022
4023 extern CORBA::StaticTypeInfo *_marshaller_Components_ReceptacleDescription;
4024
4025 extern CORBA::StaticTypeInfo *_marshaller_Components_Receptacles;
4026
4027 extern CORBA::StaticTypeInfo *_marshaller_Components_BadEventType;
4028
4029 extern CORBA::StaticTypeInfo *_marshaller_Components_EventConsumerBase;
4030
4031 extern CORBA::StaticTypeInfo *_marshaller_Components_ConsumerDescription;
4032
4033 extern CORBA::StaticTypeInfo *_marshaller_Components_EmitterDescription;
4034
4035 extern CORBA::StaticTypeInfo *_marshaller_Components_SubscriberDescription;
4036
4037 extern CORBA::StaticTypeInfo *_marshaller_Components_PublisherDescription;
4038
4039 extern CORBA::StaticTypeInfo *_marshaller_Components_Events;
4040
4041 extern CORBA::StaticTypeInfo *_marshaller_Components_CCMHome;
4042
4043 extern CORBA::StaticTypeInfo *_marshaller_Components_ComponentPortDescription;
4044
4045 extern CORBA::StaticTypeInfo *_marshaller_Components_CCMObject;
4046
4047 extern CORBA::StaticTypeInfo *_marshaller_Components_DuplicateKeyValue;
4048
4049 extern CORBA::StaticTypeInfo *_marshaller_Components_UnknownKeyValue;
4050
4051 extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidKey;
4052
4053 extern CORBA::StaticTypeInfo *_marshaller_Components_KeylessCCMHome;
4054
4055 extern CORBA::StaticTypeInfo *_marshaller_Components_HomeNotFound;
4056
4057 extern CORBA::StaticTypeInfo *_marshaller_Components_HomeFinder;
4058
4059 extern CORBA::StaticTypeInfo *_marshaller_Components_WrongComponentType;
4060
4061 extern CORBA::StaticTypeInfo *_marshaller_Components_Configurator;
4062
4063 extern CORBA::StaticTypeInfo *_marshaller_Components_ConfigValue;
4064
4065 extern CORBA::StaticTypeInfo *_marshaller_Components_StandardConfigurator;
4066
4067 extern CORBA::StaticTypeInfo *_marshaller_Components_IllegalState;
4068
4069 extern CORBA::StaticTypeInfo *_marshaller_Components_CCMExceptionReason;
4070
4071 extern CORBA::StaticTypeInfo *_marshaller_Components_CCMException;
4072
4073 extern CORBA::StaticTypeInfo *_marshaller_Components_UnknownImplId;
4074
4075 extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidLocation;
4076
4077 extern CORBA::StaticTypeInfo *_marshaller_Components_CreateFailure;
4078
4079 extern CORBA::StaticTypeInfo *_marshaller_Components_RemoveFailure;
4080
4081 extern CORBA::StaticTypeInfo *_marshaller_Components_InstallationFailure;
4082
4083 extern CORBA::StaticTypeInfo *_marshaller_Components_InvalidAssembly;
4084
4085 extern CORBA::StaticTypeInfo *_marshaller_Components_Container;
4086
4087 extern CORBA::StaticTypeInfo *_marshaller_Components_ComponentServer;
4088
4089 extern CORBA::StaticTypeInfo *_marshaller_Components_ComponentInstallation;
4090
4091 extern CORBA::StaticTypeInfo *_marshaller_Components_AssemblyState;
4092
4093 extern CORBA::StaticTypeInfo *_marshaller_Components_Assembly;
4094
4095 extern CORBA::StaticTypeInfo *_marshaller_Components_AssemblyFactory;
4096
4097 extern CORBA::StaticTypeInfo *_marshaller_Components_ServerActivator;
4098
4099 extern CORBA::StaticTypeInfo *_marshaller_MICOCCM_MicoCCMD;
4100
4101 extern CORBA::StaticTypeInfo *_marshaller_MICOCCM_ComponentServer;
4102
4103 extern CORBA::StaticTypeInfo *_marshaller_HPI_HomeFinder;
4104
4105 extern CORBA::StaticTypeInfo *_marshaller__seq_Components_FacetDescription;
4106
4107 extern CORBA::StaticTypeInfo *_marshaller__seq_Components_ConnectionDescription;
4108
4109 extern CORBA::StaticTypeInfo *_marshaller__seq_Components_ReceptacleDescription;
4110
4111 extern CORBA::StaticTypeInfo *_marshaller__seq_Components_ConsumerDescription;
4112
4113 extern CORBA::StaticTypeInfo *_marshaller__seq_Components_EmitterDescription;
4114
4115 extern CORBA::StaticTypeInfo *_marshaller__seq_Components_SubscriberDescription;
4116
4117 extern CORBA::StaticTypeInfo *_marshaller__seq_Components_PublisherDescription;
4118
4119 extern CORBA::StaticTypeInfo *_marshaller__seq_Components_CCMHome;
4120
4121 extern CORBA::StaticTypeInfo *_marshaller__seq_Components_ConfigValue;
4122
4123 extern CORBA::StaticTypeInfo *_marshaller__seq_Components_Container;
4124
4125 extern CORBA::StaticTypeInfo *_marshaller__seq_Components_ComponentServer;
4126
4127 #endif
4128
