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