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