I386LINUX/util/I386LINUX/include/coss/CosEventComm.h

   1 /*
   2  *  MICO --- an Open Source CORBA implementation
   3  *  Copyright (c) 1997-2003 by The Mico Team
   4  *
   5  *  This file was automatically generated. DO NOT EDIT!
   6  */
   7
   8 #include <CORBA.h>
   9 #include <mico/throw.h>
  10
  11 #ifndef __COSEVENTCOMM_H__
  12 #define __COSEVENTCOMM_H__
  13
  14
  15
  16
  17
  18
  19 namespace CosEventComm
  20 {
  21
  22 class PushConsumer;
  23 typedef PushConsumer *PushConsumer_ptr;
  24 typedef PushConsumer_ptr PushConsumerRef;
  25 typedef ObjVar< PushConsumer > PushConsumer_var;
  26 typedef ObjOut< PushConsumer > PushConsumer_out;
  27
  28 class PushSupplier;
  29 typedef PushSupplier *PushSupplier_ptr;
  30 typedef PushSupplier_ptr PushSupplierRef;
  31 typedef ObjVar< PushSupplier > PushSupplier_var;
  32 typedef ObjOut< PushSupplier > PushSupplier_out;
  33
  34 class PullSupplier;
  35 typedef PullSupplier *PullSupplier_ptr;
  36 typedef PullSupplier_ptr PullSupplierRef;
  37 typedef ObjVar< PullSupplier > PullSupplier_var;
  38 typedef ObjOut< PullSupplier > PullSupplier_out;
  39
  40 class PullConsumer;
  41 typedef PullConsumer *PullConsumer_ptr;
  42 typedef PullConsumer_ptr PullConsumerRef;
  43 typedef ObjVar< PullConsumer > PullConsumer_var;
  44 typedef ObjOut< PullConsumer > PullConsumer_out;
  45
  46 }
  47
  48
  49
  50
  51
  52
  53 namespace CosEventComm
  54 {
  55
  56 struct Disconnected : public CORBA::UserException {
  57   #ifdef HAVE_EXPLICIT_STRUCT_OPS
  58   Disconnected();
  59   ~Disconnected();
  60   Disconnected( const Disconnected& s );
  61   Disconnected& operator=( const Disconnected& s );
  62   #endif //HAVE_EXPLICIT_STRUCT_OPS
  63
  64
  65   #ifdef HAVE_STD_EH
  66   Disconnected *operator->() { return this; }
  67   Disconnected& operator*() { return *this; }
  68   operator Disconnected*() { return this; }
  69   #endif // HAVE_STD_EH
  70
  71   void _throwit() const;
  72   const char *_repoid() const;
  73   void _encode( CORBA::DataEncoder &en ) const;
  74   void _encode_any( CORBA::Any &a ) const;
  75   CORBA::Exception *_clone() const;
  76   static Disconnected *_downcast( CORBA::Exception *ex );
  77   static const Disconnected *_downcast( const CORBA::Exception *ex );
  78 };
  79
  80 #ifdef HAVE_STD_EH
  81 typedef Disconnected Disconnected_catch;
  82 #else
  83 typedef ExceptVar< Disconnected > Disconnected_var;
  84 typedef TVarOut< Disconnected > Disconnected_out;
  85 typedef Disconnected_var Disconnected_catch;
  86 #endif // HAVE_STD_EH
  87
  88
  89 /*
  90  * Base class and common definitions for interface PushConsumer
  91  */
  92
  93 class PushConsumer :
  94   virtual public CORBA::Object
  95 {
  96   public:
  97     virtual ~PushConsumer();
  98
  99     #ifdef HAVE_TYPEDEF_OVERLOAD
 100     typedef PushConsumer_ptr _ptr_type;
 101     typedef PushConsumer_var _var_type;
 102     #endif
 103
 104     static PushConsumer_ptr _narrow( CORBA::Object_ptr obj );
 105     static PushConsumer_ptr _narrow( CORBA::AbstractBase_ptr obj );
 106     static PushConsumer_ptr _duplicate( PushConsumer_ptr _obj )
 107     {
 108       CORBA::Object::_duplicate (_obj);
 109       return _obj;
 110     }
 111
 112     static PushConsumer_ptr _nil()
 113     {
 114       return 0;
 115     }
 116
 117     virtual void *_narrow_helper( const char *repoid );
 118
 119     virtual void push( const CORBA::Any& data ) = 0;
 120     virtual void disconnect_push_consumer() = 0;
 121
 122   protected:
 123     PushConsumer() {};
 124   private:
 125     PushConsumer( const PushConsumer& );
 126     void operator=( const PushConsumer& );
 127 };
 128
 129 // Stub for interface PushConsumer
 130 class PushConsumer_stub:
 131   virtual public PushConsumer
 132 {
 133   public:
 134     virtual ~PushConsumer_stub();
 135     void push( const CORBA::Any& data );
 136     void disconnect_push_consumer();
 137
 138   private:
 139     void operator=( const PushConsumer_stub& );
 140 };
 141
 142 #ifndef MICO_CONF_NO_POA
 143
 144 class PushConsumer_stub_clp :
 145   virtual public PushConsumer_stub,
 146   virtual public PortableServer::StubBase
 147 {
 148   public:
 149     PushConsumer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
 150     virtual ~PushConsumer_stub_clp ();
 151     void push( const CORBA::Any& data );
 152     void disconnect_push_consumer();
 153
 154   protected:
 155     PushConsumer_stub_clp ();
 156   private:
 157     void operator=( const PushConsumer_stub_clp & );
 158 };
 159
 160 #endif // MICO_CONF_NO_POA
 161
 162 class PushConsumer_skel :
 163   virtual public StaticMethodDispatcher,
 164   virtual public PushConsumer
 165 {
 166   public:
 167     PushConsumer_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
 168     virtual ~PushConsumer_skel();
 169     PushConsumer_skel( CORBA::Object_ptr obj );
 170     virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
 171     PushConsumer_ptr _this();
 172
 173 };
 174
 175
 176 /*
 177  * Base class and common definitions for interface PushSupplier
 178  */
 179
 180 class PushSupplier :
 181   virtual public CORBA::Object
 182 {
 183   public:
 184     virtual ~PushSupplier();
 185
 186     #ifdef HAVE_TYPEDEF_OVERLOAD
 187     typedef PushSupplier_ptr _ptr_type;
 188     typedef PushSupplier_var _var_type;
 189     #endif
 190
 191     static PushSupplier_ptr _narrow( CORBA::Object_ptr obj );
 192     static PushSupplier_ptr _narrow( CORBA::AbstractBase_ptr obj );
 193     static PushSupplier_ptr _duplicate( PushSupplier_ptr _obj )
 194     {
 195       CORBA::Object::_duplicate (_obj);
 196       return _obj;
 197     }
 198
 199     static PushSupplier_ptr _nil()
 200     {
 201       return 0;
 202     }
 203
 204     virtual void *_narrow_helper( const char *repoid );
 205
 206     virtual void disconnect_push_supplier() = 0;
 207
 208   protected:
 209     PushSupplier() {};
 210   private:
 211     PushSupplier( const PushSupplier& );
 212     void operator=( const PushSupplier& );
 213 };
 214
 215 // Stub for interface PushSupplier
 216 class PushSupplier_stub:
 217   virtual public PushSupplier
 218 {
 219   public:
 220     virtual ~PushSupplier_stub();
 221     void disconnect_push_supplier();
 222
 223   private:
 224     void operator=( const PushSupplier_stub& );
 225 };
 226
 227 #ifndef MICO_CONF_NO_POA
 228
 229 class PushSupplier_stub_clp :
 230   virtual public PushSupplier_stub,
 231   virtual public PortableServer::StubBase
 232 {
 233   public:
 234     PushSupplier_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
 235     virtual ~PushSupplier_stub_clp ();
 236     void disconnect_push_supplier();
 237
 238   protected:
 239     PushSupplier_stub_clp ();
 240   private:
 241     void operator=( const PushSupplier_stub_clp & );
 242 };
 243
 244 #endif // MICO_CONF_NO_POA
 245
 246 class PushSupplier_skel :
 247   virtual public StaticMethodDispatcher,
 248   virtual public PushSupplier
 249 {
 250   public:
 251     PushSupplier_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
 252     virtual ~PushSupplier_skel();
 253     PushSupplier_skel( CORBA::Object_ptr obj );
 254     virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
 255     PushSupplier_ptr _this();
 256
 257 };
 258
 259
 260 /*
 261  * Base class and common definitions for interface PullSupplier
 262  */
 263
 264 class PullSupplier :
 265   virtual public CORBA::Object
 266 {
 267   public:
 268     virtual ~PullSupplier();
 269
 270     #ifdef HAVE_TYPEDEF_OVERLOAD
 271     typedef PullSupplier_ptr _ptr_type;
 272     typedef PullSupplier_var _var_type;
 273     #endif
 274
 275     static PullSupplier_ptr _narrow( CORBA::Object_ptr obj );
 276     static PullSupplier_ptr _narrow( CORBA::AbstractBase_ptr obj );
 277     static PullSupplier_ptr _duplicate( PullSupplier_ptr _obj )
 278     {
 279       CORBA::Object::_duplicate (_obj);
 280       return _obj;
 281     }
 282
 283     static PullSupplier_ptr _nil()
 284     {
 285       return 0;
 286     }
 287
 288     virtual void *_narrow_helper( const char *repoid );
 289
 290     virtual CORBA::Any* pull() = 0;
 291     virtual CORBA::Any* try_pull( CORBA::Boolean_out has_event ) = 0;
 292     virtual void disconnect_pull_supplier() = 0;
 293
 294   protected:
 295     PullSupplier() {};
 296   private:
 297     PullSupplier( const PullSupplier& );
 298     void operator=( const PullSupplier& );
 299 };
 300
 301 // Stub for interface PullSupplier
 302 class PullSupplier_stub:
 303   virtual public PullSupplier
 304 {
 305   public:
 306     virtual ~PullSupplier_stub();
 307     CORBA::Any* pull();
 308     CORBA::Any* try_pull( CORBA::Boolean_out has_event );
 309     void disconnect_pull_supplier();
 310
 311   private:
 312     void operator=( const PullSupplier_stub& );
 313 };
 314
 315 #ifndef MICO_CONF_NO_POA
 316
 317 class PullSupplier_stub_clp :
 318   virtual public PullSupplier_stub,
 319   virtual public PortableServer::StubBase
 320 {
 321   public:
 322     PullSupplier_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
 323     virtual ~PullSupplier_stub_clp ();
 324     CORBA::Any* pull();
 325     CORBA::Any* try_pull( CORBA::Boolean_out has_event );
 326     void disconnect_pull_supplier();
 327
 328   protected:
 329     PullSupplier_stub_clp ();
 330   private:
 331     void operator=( const PullSupplier_stub_clp & );
 332 };
 333
 334 #endif // MICO_CONF_NO_POA
 335
 336 class PullSupplier_skel :
 337   virtual public StaticMethodDispatcher,
 338   virtual public PullSupplier
 339 {
 340   public:
 341     PullSupplier_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
 342     virtual ~PullSupplier_skel();
 343     PullSupplier_skel( CORBA::Object_ptr obj );
 344     virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
 345     PullSupplier_ptr _this();
 346
 347 };
 348
 349
 350 /*
 351  * Base class and common definitions for interface PullConsumer
 352  */
 353
 354 class PullConsumer :
 355   virtual public CORBA::Object
 356 {
 357   public:
 358     virtual ~PullConsumer();
 359
 360     #ifdef HAVE_TYPEDEF_OVERLOAD
 361     typedef PullConsumer_ptr _ptr_type;
 362     typedef PullConsumer_var _var_type;
 363     #endif
 364
 365     static PullConsumer_ptr _narrow( CORBA::Object_ptr obj );
 366     static PullConsumer_ptr _narrow( CORBA::AbstractBase_ptr obj );
 367     static PullConsumer_ptr _duplicate( PullConsumer_ptr _obj )
 368     {
 369       CORBA::Object::_duplicate (_obj);
 370       return _obj;
 371     }
 372
 373     static PullConsumer_ptr _nil()
 374     {
 375       return 0;
 376     }
 377
 378     virtual void *_narrow_helper( const char *repoid );
 379
 380     virtual void disconnect_pull_consumer() = 0;
 381
 382   protected:
 383     PullConsumer() {};
 384   private:
 385     PullConsumer( const PullConsumer& );
 386     void operator=( const PullConsumer& );
 387 };
 388
 389 // Stub for interface PullConsumer
 390 class PullConsumer_stub:
 391   virtual public PullConsumer
 392 {
 393   public:
 394     virtual ~PullConsumer_stub();
 395     void disconnect_pull_consumer();
 396
 397   private:
 398     void operator=( const PullConsumer_stub& );
 399 };
 400
 401 #ifndef MICO_CONF_NO_POA
 402
 403 class PullConsumer_stub_clp :
 404   virtual public PullConsumer_stub,
 405   virtual public PortableServer::StubBase
 406 {
 407   public:
 408     PullConsumer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
 409     virtual ~PullConsumer_stub_clp ();
 410     void disconnect_pull_consumer();
 411
 412   protected:
 413     PullConsumer_stub_clp ();
 414   private:
 415     void operator=( const PullConsumer_stub_clp & );
 416 };
 417
 418 #endif // MICO_CONF_NO_POA
 419
 420 class PullConsumer_skel :
 421   virtual public StaticMethodDispatcher,
 422   virtual public PullConsumer
 423 {
 424   public:
 425     PullConsumer_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
 426     virtual ~PullConsumer_skel();
 427     PullConsumer_skel( CORBA::Object_ptr obj );
 428     virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
 429     PullConsumer_ptr _this();
 430
 431 };
 432
 433 }
 434
 435
 436 #ifndef MICO_CONF_NO_POA
 437
 438
 439
 440 namespace POA_CosEventComm
 441 {
 442
 443 class PushConsumer : virtual public PortableServer::StaticImplementation
 444 {
 445   public:
 446     virtual ~PushConsumer ();
 447     CosEventComm::PushConsumer_ptr _this ();
 448     bool dispatch (CORBA::StaticServerRequest_ptr);
 449     virtual void invoke (CORBA::StaticServerRequest_ptr);
 450     virtual CORBA::Boolean _is_a (const char *);
 451     virtual CORBA::InterfaceDef_ptr _get_interface ();
 452     virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
 453
 454     virtual void * _narrow_helper (const char *);
 455     static PushConsumer * _narrow (PortableServer::Servant);
 456     virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
 457
 458     virtual void push( const CORBA::Any& data ) = 0;
 459     virtual void disconnect_push_consumer() = 0;
 460
 461   protected:
 462     PushConsumer () {};
 463
 464   private:
 465     PushConsumer (const PushConsumer &);
 466     void operator= (const PushConsumer &);
 467 };
 468
 469 class PushSupplier : virtual public PortableServer::StaticImplementation
 470 {
 471   public:
 472     virtual ~PushSupplier ();
 473     CosEventComm::PushSupplier_ptr _this ();
 474     bool dispatch (CORBA::StaticServerRequest_ptr);
 475     virtual void invoke (CORBA::StaticServerRequest_ptr);
 476     virtual CORBA::Boolean _is_a (const char *);
 477     virtual CORBA::InterfaceDef_ptr _get_interface ();
 478     virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
 479
 480     virtual void * _narrow_helper (const char *);
 481     static PushSupplier * _narrow (PortableServer::Servant);
 482     virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
 483
 484     virtual void disconnect_push_supplier() = 0;
 485
 486   protected:
 487     PushSupplier () {};
 488
 489   private:
 490     PushSupplier (const PushSupplier &);
 491     void operator= (const PushSupplier &);
 492 };
 493
 494 class PullSupplier : virtual public PortableServer::StaticImplementation
 495 {
 496   public:
 497     virtual ~PullSupplier ();
 498     CosEventComm::PullSupplier_ptr _this ();
 499     bool dispatch (CORBA::StaticServerRequest_ptr);
 500     virtual void invoke (CORBA::StaticServerRequest_ptr);
 501     virtual CORBA::Boolean _is_a (const char *);
 502     virtual CORBA::InterfaceDef_ptr _get_interface ();
 503     virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
 504
 505     virtual void * _narrow_helper (const char *);
 506     static PullSupplier * _narrow (PortableServer::Servant);
 507     virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
 508
 509     virtual CORBA::Any* pull() = 0;
 510     virtual CORBA::Any* try_pull( CORBA::Boolean_out has_event ) = 0;
 511     virtual void disconnect_pull_supplier() = 0;
 512
 513   protected:
 514     PullSupplier () {};
 515
 516   private:
 517     PullSupplier (const PullSupplier &);
 518     void operator= (const PullSupplier &);
 519 };
 520
 521 class PullConsumer : virtual public PortableServer::StaticImplementation
 522 {
 523   public:
 524     virtual ~PullConsumer ();
 525     CosEventComm::PullConsumer_ptr _this ();
 526     bool dispatch (CORBA::StaticServerRequest_ptr);
 527     virtual void invoke (CORBA::StaticServerRequest_ptr);
 528     virtual CORBA::Boolean _is_a (const char *);
 529     virtual CORBA::InterfaceDef_ptr _get_interface ();
 530     virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
 531
 532     virtual void * _narrow_helper (const char *);
 533     static PullConsumer * _narrow (PortableServer::Servant);
 534     virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
 535
 536     virtual void disconnect_pull_consumer() = 0;
 537
 538   protected:
 539     PullConsumer () {};
 540
 541   private:
 542     PullConsumer (const PullConsumer &);
 543     void operator= (const PullConsumer &);
 544 };
 545
 546 }
 547
 548
 549 #endif // MICO_CONF_NO_POA
 550
 551 extern CORBA::StaticTypeInfo *_marshaller_CosEventComm_Disconnected;
 552
 553 extern CORBA::StaticTypeInfo *_marshaller_CosEventComm_PushConsumer;
 554
 555 extern CORBA::StaticTypeInfo *_marshaller_CosEventComm_PushSupplier;
 556
 557 extern CORBA::StaticTypeInfo *_marshaller_CosEventComm_PullSupplier;
 558
 559 extern CORBA::StaticTypeInfo *_marshaller_CosEventComm_PullConsumer;
 560
 561 #endif