src/idl/RequestResponseBus.hh

   1 // This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
   2 #ifndef __RequestResponseBus_hh__
   3 #define __RequestResponseBus_hh__
   4
   5 #ifndef __CORBA_H_EXTERNAL_GUARD__
   6 #include <omniORB4/CORBA.h>
   7 #endif
   8
   9 #ifndef  USE_stub_in_nt_dll
  10 # define USE_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus
  11 #endif
  12 #ifndef  USE_core_stub_in_nt_dll
  13 # define USE_core_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus
  14 #endif
  15 #ifndef  USE_dyn_stub_in_nt_dll
  16 # define USE_dyn_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus
  17 #endif
  18
  19
  20
  21
  22
  23
  24 #ifdef USE_stub_in_nt_dll
  25 # ifndef USE_core_stub_in_nt_dll
  26 #  define USE_core_stub_in_nt_dll
  27 # endif
  28 # ifndef USE_dyn_stub_in_nt_dll
  29 #  define USE_dyn_stub_in_nt_dll
  30 # endif
  31 #endif
  32
  33 #ifdef _core_attr
  34 # error "A local CPP macro _core_attr has already been defined."
  35 #else
  36 # ifdef  USE_core_stub_in_nt_dll
  37 #  define _core_attr _OMNIORB_NTDLL_IMPORT
  38 # else
  39 #  define _core_attr
  40 # endif
  41 #endif
  42
  43 #ifdef _dyn_attr
  44 # error "A local CPP macro _dyn_attr has already been defined."
  45 #else
  46 # ifdef  USE_dyn_stub_in_nt_dll
  47 #  define _dyn_attr _OMNIORB_NTDLL_IMPORT
  48 # else
  49 #  define _dyn_attr
  50 # endif
  51 #endif
  52
  53
  54
  55
  56
  57 _CORBA_MODULE plpbus_orb
  58
  59 _CORBA_MODULE_BEG
  60
  61   struct DataItem {
  62     typedef _CORBA_ConstrType_Variable_Var<DataItem> _var_type;
  63
  64
  65     ::CORBA::String_member name;
  66
  67     ::CORBA::Any value;
  68
  69     ::CORBA::String_member str_value;
  70
  71
  72
  73     void operator>>= (cdrStream &) const;
  74     void operator<<= (cdrStream &);
  75   };
  76
  77   typedef DataItem::_var_type DataItem_var;
  78
  79   typedef _CORBA_ConstrType_Variable_OUT_arg< DataItem,DataItem_var > DataItem_out;
  80
  81   _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DataItem;
  82
  83   _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DataItemSequence;
  84
  85   class DataItemSequence_var;
  86
  87   class DataItemSequence : public _CORBA_Unbounded_Sequence< DataItem >  {
  88   public:
  89     typedef DataItemSequence_var _var_type;
  90     inline DataItemSequence() {}
  91     inline DataItemSequence(const DataItemSequence& _s)
  92       : _CORBA_Unbounded_Sequence< DataItem > (_s) {}
  93
  94     inline DataItemSequence(_CORBA_ULong _max)
  95       : _CORBA_Unbounded_Sequence< DataItem > (_max) {}
  96     inline DataItemSequence(_CORBA_ULong _max, _CORBA_ULong _len, DataItem* _val, _CORBA_Boolean _rel=0)
  97       : _CORBA_Unbounded_Sequence< DataItem > (_max, _len, _val, _rel) {}
  98
  99
 100
 101     inline DataItemSequence& operator = (const DataItemSequence& _s) {
 102       _CORBA_Unbounded_Sequence< DataItem > ::operator=(_s);
 103       return *this;
 104     }
 105   };
 106
 107   class DataItemSequence_out;
 108
 109   class DataItemSequence_var {
 110   public:
 111     inline DataItemSequence_var() : _pd_seq(0) {}
 112     inline DataItemSequence_var(DataItemSequence* _s) : _pd_seq(_s) {}
 113     inline DataItemSequence_var(const DataItemSequence_var& _s) {
 114       if( _s._pd_seq )  _pd_seq = new DataItemSequence(*_s._pd_seq);
 115       else              _pd_seq = 0;
 116     }
 117     inline ~DataItemSequence_var() { if( _pd_seq )  delete _pd_seq; }
 118
 119     inline DataItemSequence_var& operator = (DataItemSequence* _s) {
 120       if( _pd_seq )  delete _pd_seq;
 121       _pd_seq = _s;
 122       return *this;
 123     }
 124     inline DataItemSequence_var& operator = (const DataItemSequence_var& _s) {
 125       if( _s._pd_seq ) {
 126         if( !_pd_seq )  _pd_seq = new DataItemSequence;
 127         *_pd_seq = *_s._pd_seq;
 128       } else if( _pd_seq ) {
 129         delete _pd_seq;
 130         _pd_seq = 0;
 131       }
 132       return *this;
 133     }
 134     inline DataItem& operator [] (_CORBA_ULong _s) {
 135       return (*_pd_seq)[_s];
 136     }
 137
 138
 139
 140     inline DataItemSequence* operator -> () { return _pd_seq; }
 141     inline const DataItemSequence* operator -> () const { return _pd_seq; }
 142 #if defined(__GNUG__)
 143     inline operator DataItemSequence& () const { return *_pd_seq; }
 144 #else
 145     inline operator const DataItemSequence& () const { return *_pd_seq; }
 146     inline operator DataItemSequence& () { return *_pd_seq; }
 147 #endif
 148
 149     inline const DataItemSequence& in() const { return *_pd_seq; }
 150     inline DataItemSequence&       inout()    { return *_pd_seq; }
 151     inline DataItemSequence*&      out() {
 152       if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
 153       return _pd_seq;
 154     }
 155     inline DataItemSequence* _retn() { DataItemSequence* tmp = _pd_seq; _pd_seq = 0; return tmp; }
 156
 157     friend class DataItemSequence_out;
 158
 159   private:
 160     DataItemSequence* _pd_seq;
 161   };
 162
 163   class DataItemSequence_out {
 164   public:
 165     inline DataItemSequence_out(DataItemSequence*& _s) : _data(_s) { _data = 0; }
 166     inline DataItemSequence_out(DataItemSequence_var& _s)
 167       : _data(_s._pd_seq) { _s = (DataItemSequence*) 0; }
 168     inline DataItemSequence_out(const DataItemSequence_out& _s) : _data(_s._data) {}
 169     inline DataItemSequence_out& operator = (const DataItemSequence_out& _s) {
 170       _data = _s._data;
 171       return *this;
 172     }
 173     inline DataItemSequence_out& operator = (DataItemSequence* _s) {
 174       _data = _s;
 175       return *this;
 176     }
 177     inline operator DataItemSequence*&()  { return _data; }
 178     inline DataItemSequence*& ptr()       { return _data; }
 179     inline DataItemSequence* operator->() { return _data; }
 180
 181     inline DataItem& operator [] (_CORBA_ULong _i) {
 182       return (*_data)[_i];
 183     }
 184
 185
 186
 187     DataItemSequence*& _data;
 188
 189   private:
 190     DataItemSequence_out();
 191     DataItemSequence_out& operator=(const DataItemSequence_var&);
 192   };
 193
 194 #ifndef __plpbus__orb_mOrbClient__
 195 #define __plpbus__orb_mOrbClient__
 196
 197   class OrbClient;
 198   class _objref_OrbClient;
 199   class _impl_OrbClient;
 200
 201   typedef _objref_OrbClient* OrbClient_ptr;
 202   typedef OrbClient_ptr OrbClientRef;
 203
 204   class OrbClient_Helper {
 205   public:
 206     typedef OrbClient_ptr _ptr_type;
 207
 208     static _ptr_type _nil();
 209     static _CORBA_Boolean is_nil(_ptr_type);
 210     static void release(_ptr_type);
 211     static void duplicate(_ptr_type);
 212     static void marshalObjRef(_ptr_type, cdrStream&);
 213     static _ptr_type unmarshalObjRef(cdrStream&);
 214   };
 215
 216   typedef _CORBA_ObjRef_Var<_objref_OrbClient, OrbClient_Helper> OrbClient_var;
 217   typedef _CORBA_ObjRef_OUT_arg<_objref_OrbClient,OrbClient_Helper > OrbClient_out;
 218
 219 #endif
 220
 221   // interface OrbClient
 222   class OrbClient {
 223   public:
 224     // Declarations for this interface type.
 225     typedef OrbClient_ptr _ptr_type;
 226     typedef OrbClient_var _var_type;
 227
 228     static _ptr_type _duplicate(_ptr_type);
 229     static _ptr_type _narrow(::CORBA::Object_ptr);
 230     static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
 231
 232     static _ptr_type _nil();
 233
 234     static inline void _marshalObjRef(_ptr_type, cdrStream&);
 235
 236     static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
 237       omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
 238       if (o)
 239         return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
 240       else
 241         return _nil();
 242     }
 243
 244     static _core_attr const char* _PD_repoId;
 245
 246     // Other IDL defined within this scope.
 247
 248   };
 249
 250   class _objref_OrbClient :
 251     public virtual ::CORBA::Object,
 252     public virtual omniObjRef
 253   {
 254   public:
 255     void receive_event_message(const char* event_param);
 256     void receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param);
 257     void receive_response_message(const char* msg_rsp_param);
 258     void receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param);
 259
 260     inline _objref_OrbClient()  { _PR_setobj(0); }  // nil
 261     _objref_OrbClient(omniIOR*, omniIdentity*);
 262
 263   protected:
 264     virtual ~_objref_OrbClient();
 265
 266
 267   private:
 268     virtual void* _ptrToObjRef(const char*);
 269
 270     _objref_OrbClient(const _objref_OrbClient&);
 271     _objref_OrbClient& operator = (const _objref_OrbClient&);
 272     // not implemented
 273
 274     friend class OrbClient;
 275   };
 276
 277   class _pof_OrbClient : public _OMNI_NS(proxyObjectFactory) {
 278   public:
 279     inline _pof_OrbClient() : _OMNI_NS(proxyObjectFactory)(OrbClient::_PD_repoId) {}
 280     virtual ~_pof_OrbClient();
 281
 282     virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
 283     virtual _CORBA_Boolean is_a(const char*) const;
 284   };
 285
 286   class _impl_OrbClient :
 287     public virtual omniServant
 288   {
 289   public:
 290     virtual ~_impl_OrbClient();
 291
 292     virtual void receive_event_message(const char* event_param) = 0;
 293     virtual void receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param) = 0;
 294     virtual void receive_response_message(const char* msg_rsp_param) = 0;
 295     virtual void receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param) = 0;
 296
 297   public:  // Really protected, workaround for xlC
 298     virtual _CORBA_Boolean _dispatch(omniCallHandle&);
 299
 300   private:
 301     virtual void* _ptrToInterface(const char*);
 302     virtual const char* _mostDerivedRepoId();
 303
 304   };
 305
 306
 307   _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_OrbClient;
 308
 309 #ifndef __plpbus__orb_mOrbServer__
 310 #define __plpbus__orb_mOrbServer__
 311
 312   class OrbServer;
 313   class _objref_OrbServer;
 314   class _impl_OrbServer;
 315
 316   typedef _objref_OrbServer* OrbServer_ptr;
 317   typedef OrbServer_ptr OrbServerRef;
 318
 319   class OrbServer_Helper {
 320   public:
 321     typedef OrbServer_ptr _ptr_type;
 322
 323     static _ptr_type _nil();
 324     static _CORBA_Boolean is_nil(_ptr_type);
 325     static void release(_ptr_type);
 326     static void duplicate(_ptr_type);
 327     static void marshalObjRef(_ptr_type, cdrStream&);
 328     static _ptr_type unmarshalObjRef(cdrStream&);
 329   };
 330
 331   typedef _CORBA_ObjRef_Var<_objref_OrbServer, OrbServer_Helper> OrbServer_var;
 332   typedef _CORBA_ObjRef_OUT_arg<_objref_OrbServer,OrbServer_Helper > OrbServer_out;
 333
 334 #endif
 335
 336   // interface OrbServer
 337   class OrbServer {
 338   public:
 339     // Declarations for this interface type.
 340     typedef OrbServer_ptr _ptr_type;
 341     typedef OrbServer_var _var_type;
 342
 343     static _ptr_type _duplicate(_ptr_type);
 344     static _ptr_type _narrow(::CORBA::Object_ptr);
 345     static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
 346
 347     static _ptr_type _nil();
 348
 349     static inline void _marshalObjRef(_ptr_type, cdrStream&);
 350
 351     static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
 352       omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
 353       if (o)
 354         return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
 355       else
 356         return _nil();
 357     }
 358
 359     static _core_attr const char* _PD_repoId;
 360
 361     // Other IDL defined within this scope.
 362
 363   };
 364
 365   class _objref_OrbServer :
 366     public virtual ::CORBA::Object,
 367     public virtual omniObjRef
 368   {
 369   public:
 370     void send_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param);
 371     void send_dataitem_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const ::plpbus_orb::DataItemSequence& req_seq_param);
 372     char* send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg);
 373     ::CORBA::Long send_dataitem_message_and_wait_response(const ::plpbus_orb::DataItemSequence& req_seq_param, ::plpbus_orb::DataItemSequence_out rsp_seq_param);
 374     void add_event_listener(::plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs);
 375     void shutdown();
 376
 377     inline _objref_OrbServer()  { _PR_setobj(0); }  // nil
 378     _objref_OrbServer(omniIOR*, omniIdentity*);
 379
 380   protected:
 381     virtual ~_objref_OrbServer();
 382
 383
 384   private:
 385     virtual void* _ptrToObjRef(const char*);
 386
 387     _objref_OrbServer(const _objref_OrbServer&);
 388     _objref_OrbServer& operator = (const _objref_OrbServer&);
 389     // not implemented
 390
 391     friend class OrbServer;
 392   };
 393
 394   class _pof_OrbServer : public _OMNI_NS(proxyObjectFactory) {
 395   public:
 396     inline _pof_OrbServer() : _OMNI_NS(proxyObjectFactory)(OrbServer::_PD_repoId) {}
 397     virtual ~_pof_OrbServer();
 398
 399     virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
 400     virtual _CORBA_Boolean is_a(const char*) const;
 401   };
 402
 403   class _impl_OrbServer :
 404     public virtual omniServant
 405   {
 406   public:
 407     virtual ~_impl_OrbServer();
 408
 409     virtual void send_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param) = 0;
 410     virtual void send_dataitem_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const ::plpbus_orb::DataItemSequence& req_seq_param) = 0;
 411     virtual char* send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg) = 0;
 412     virtual ::CORBA::Long send_dataitem_message_and_wait_response(const ::plpbus_orb::DataItemSequence& req_seq_param, ::plpbus_orb::DataItemSequence_out rsp_seq_param) = 0;
 413     virtual void add_event_listener(::plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs) = 0;
 414     virtual void shutdown() = 0;
 415
 416   public:  // Really protected, workaround for xlC
 417     virtual _CORBA_Boolean _dispatch(omniCallHandle&);
 418
 419   private:
 420     virtual void* _ptrToInterface(const char*);
 421     virtual const char* _mostDerivedRepoId();
 422
 423   };
 424
 425
 426   _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_OrbServer;
 427
 428 _CORBA_MODULE_END
 429
 430
 431
 432 _CORBA_MODULE POA_plpbus_orb
 433 _CORBA_MODULE_BEG
 434
 435   class OrbClient :
 436     public virtual plpbus_orb::_impl_OrbClient,
 437     public virtual ::PortableServer::ServantBase
 438   {
 439   public:
 440     virtual ~OrbClient();
 441
 442     inline ::plpbus_orb::OrbClient_ptr _this() {
 443       return (::plpbus_orb::OrbClient_ptr) _do_this(::plpbus_orb::OrbClient::_PD_repoId);
 444     }
 445   };
 446
 447   template <class _omniT>
 448   class OrbClient_tie : public virtual OrbClient
 449   {
 450   public:
 451     OrbClient_tie(_omniT& t)
 452       : pd_obj(&t), pd_poa(0), pd_rel(0) {}
 453     OrbClient_tie(_omniT& t, ::PortableServer::POA_ptr p)
 454       : pd_obj(&t), pd_poa(p), pd_rel(0) {}
 455     OrbClient_tie(_omniT* t, _CORBA_Boolean r=1)
 456       : pd_obj(t), pd_poa(0), pd_rel(r) {}
 457     OrbClient_tie(_omniT* t, ::PortableServer::POA_ptr p,_CORBA_Boolean r=1)
 458       : pd_obj(t), pd_poa(p), pd_rel(r) {}
 459     ~OrbClient_tie() {
 460       if( pd_poa )  ::CORBA::release(pd_poa);
 461       if( pd_rel )  delete pd_obj;
 462     }
 463
 464     _omniT* _tied_object() { return pd_obj; }
 465
 466     void _tied_object(_omniT& t) {
 467       if( pd_rel )  delete pd_obj;
 468       pd_obj = &t;
 469       pd_rel = 0;
 470     }
 471
 472     void _tied_object(_omniT* t, _CORBA_Boolean r=1) {
 473       if( pd_rel )  delete pd_obj;
 474       pd_obj = t;
 475       pd_rel = r;
 476     }
 477
 478     _CORBA_Boolean _is_owner()        { return pd_rel; }
 479     void _is_owner(_CORBA_Boolean io) { pd_rel = io;   }
 480
 481     ::PortableServer::POA_ptr _default_POA() {
 482       if( !pd_poa )  return ::PortableServer::POA::_the_root_poa();
 483       else           return ::PortableServer::POA::_duplicate(pd_poa);
 484     }
 485
 486     void receive_event_message(const char* event_param) { pd_obj->receive_event_message(event_param); }
 487     void receive_event_dataitem_sequence(const plpbus_orb::DataItemSequence& event_param) { pd_obj->receive_event_dataitem_sequence(event_param); }
 488     void receive_response_message(const char* msg_rsp_param) { pd_obj->receive_response_message(msg_rsp_param); }
 489     void receive_response_dataitem_sequence(const plpbus_orb::DataItemSequence& msg_rsp_param) { pd_obj->receive_response_dataitem_sequence(msg_rsp_param); }
 490
 491
 492   private:
 493     _omniT*                   pd_obj;
 494     ::PortableServer::POA_ptr pd_poa;
 495     _CORBA_Boolean            pd_rel;
 496   };
 497
 498   class OrbServer :
 499     public virtual plpbus_orb::_impl_OrbServer,
 500     public virtual ::PortableServer::ServantBase
 501   {
 502   public:
 503     virtual ~OrbServer();
 504
 505     inline ::plpbus_orb::OrbServer_ptr _this() {
 506       return (::plpbus_orb::OrbServer_ptr) _do_this(::plpbus_orb::OrbServer::_PD_repoId);
 507     }
 508   };
 509
 510   template <class _omniT>
 511   class OrbServer_tie : public virtual OrbServer
 512   {
 513   public:
 514     OrbServer_tie(_omniT& t)
 515       : pd_obj(&t), pd_poa(0), pd_rel(0) {}
 516     OrbServer_tie(_omniT& t, ::PortableServer::POA_ptr p)
 517       : pd_obj(&t), pd_poa(p), pd_rel(0) {}
 518     OrbServer_tie(_omniT* t, _CORBA_Boolean r=1)
 519       : pd_obj(t), pd_poa(0), pd_rel(r) {}
 520     OrbServer_tie(_omniT* t, ::PortableServer::POA_ptr p,_CORBA_Boolean r=1)
 521       : pd_obj(t), pd_poa(p), pd_rel(r) {}
 522     ~OrbServer_tie() {
 523       if( pd_poa )  ::CORBA::release(pd_poa);
 524       if( pd_rel )  delete pd_obj;
 525     }
 526
 527     _omniT* _tied_object() { return pd_obj; }
 528
 529     void _tied_object(_omniT& t) {
 530       if( pd_rel )  delete pd_obj;
 531       pd_obj = &t;
 532       pd_rel = 0;
 533     }
 534
 535     void _tied_object(_omniT* t, _CORBA_Boolean r=1) {
 536       if( pd_rel )  delete pd_obj;
 537       pd_obj = t;
 538       pd_rel = r;
 539     }
 540
 541     _CORBA_Boolean _is_owner()        { return pd_rel; }
 542     void _is_owner(_CORBA_Boolean io) { pd_rel = io;   }
 543
 544     ::PortableServer::POA_ptr _default_POA() {
 545       if( !pd_poa )  return ::PortableServer::POA::_the_root_poa();
 546       else           return ::PortableServer::POA::_duplicate(pd_poa);
 547     }
 548
 549     void send_message_and_request_response(plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param) { pd_obj->send_message_and_request_response(response_listener_param, msg_param); }
 550     void send_dataitem_message_and_request_response(plpbus_orb::OrbClient_ptr response_listener_param, const plpbus_orb::DataItemSequence& req_seq_param) { pd_obj->send_dataitem_message_and_request_response(response_listener_param, req_seq_param); }
 551     char* send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg) { return pd_obj->send_message_and_wait_response(msg_req_param, err_flg); }
 552     ::CORBA::Long send_dataitem_message_and_wait_response(const plpbus_orb::DataItemSequence& req_seq_param, plpbus_orb::DataItemSequence_out rsp_seq_param) { return pd_obj->send_dataitem_message_and_wait_response(req_seq_param, rsp_seq_param); }
 553     void add_event_listener(plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs) { pd_obj->add_event_listener(callback_client_param, msg_param, period_secs); }
 554     void shutdown() { pd_obj->shutdown(); }
 555
 556
 557   private:
 558     _omniT*                   pd_obj;
 559     ::PortableServer::POA_ptr pd_poa;
 560     _CORBA_Boolean            pd_rel;
 561   };
 562
 563 _CORBA_MODULE_END
 564
 565
 566
 567 _CORBA_MODULE OBV_plpbus_orb
 568 _CORBA_MODULE_BEG
 569
 570 _CORBA_MODULE_END
 571
 572
 573
 574
 575
 576 #undef _core_attr
 577 #undef _dyn_attr
 578
 579 extern void operator<<=(::CORBA::Any& _a, const plpbus_orb::DataItem& _s);
 580 extern void operator<<=(::CORBA::Any& _a, plpbus_orb::DataItem* _sp);
 581 extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::DataItem*& _sp);
 582 extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const plpbus_orb::DataItem*& _sp);
 583
 584 void operator<<=(::CORBA::Any& _a, const plpbus_orb::DataItemSequence& _s);
 585 void operator<<=(::CORBA::Any& _a, plpbus_orb::DataItemSequence* _sp);
 586 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::DataItemSequence*& _sp);
 587 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const plpbus_orb::DataItemSequence*& _sp);
 588
 589 void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbClient_ptr _s);
 590 void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbClient_ptr* _s);
 591 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::OrbClient_ptr& _s);
 592
 593 void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbServer_ptr _s);
 594 void operator<<=(::CORBA::Any& _a, plpbus_orb::OrbServer_ptr* _s);
 595 _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, plpbus_orb::OrbServer_ptr& _s);
 596
 597
 598
 599 inline void
 600 plpbus_orb::OrbClient::_marshalObjRef(::plpbus_orb::OrbClient_ptr obj, cdrStream& s) {
 601   omniObjRef::_marshal(obj->_PR_getobj(),s);
 602 }
 603
 604
 605 inline void
 606 plpbus_orb::OrbServer::_marshalObjRef(::plpbus_orb::OrbServer_ptr obj, cdrStream& s) {
 607   omniObjRef::_marshal(obj->_PR_getobj(),s);
 608 }
 609
 610
 611
 612
 613 #ifdef   USE_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus
 614 # undef  USE_stub_in_nt_dll
 615 # undef  USE_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus
 616 #endif
 617 #ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus
 618 # undef  USE_core_stub_in_nt_dll
 619 # undef  USE_core_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus
 620 #endif
 621 #ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus
 622 # undef  USE_dyn_stub_in_nt_dll
 623 # undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_RequestResponseBus
 624 #endif
 625
 626 #endif  // __RequestResponseBus_hh__
 627