src/idl/RequestResponseBusSK.cc

   1 // This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
   2
   3 #include "RequestResponseBus.hh"
   4 #include <omniORB4/IOP_S.h>
   5 #include <omniORB4/IOP_C.h>
   6 #include <omniORB4/callDescriptor.h>
   7 #include <omniORB4/callHandle.h>
   8 #include <omniORB4/objTracker.h>
   9
  10
  11 OMNI_USING_NAMESPACE(omni)
  12
  13 static const char* _0RL_library_version = omniORB_4_1;
  14
  15
  16
  17 void
  18 plpbus_orb::DataItem::operator>>= (cdrStream &_n) const
  19 {
  20   _n.marshalString(name,0);
  21   (const ::CORBA::Any&) value >>= _n;
  22
  23 }
  24
  25 void
  26 plpbus_orb::DataItem::operator<<= (cdrStream &_n)
  27 {
  28   name = _n.unmarshalString(0);
  29   (::CORBA::Any&)value <<= _n;
  30
  31 }
  32
  33 plpbus_orb::OrbClient_ptr plpbus_orb::OrbClient_Helper::_nil() {
  34   return ::plpbus_orb::OrbClient::_nil();
  35 }
  36
  37 ::CORBA::Boolean plpbus_orb::OrbClient_Helper::is_nil(::plpbus_orb::OrbClient_ptr p) {
  38   return ::CORBA::is_nil(p);
  39
  40 }
  41
  42 void plpbus_orb::OrbClient_Helper::release(::plpbus_orb::OrbClient_ptr p) {
  43   ::CORBA::release(p);
  44 }
  45
  46 void plpbus_orb::OrbClient_Helper::marshalObjRef(::plpbus_orb::OrbClient_ptr obj, cdrStream& s) {
  47   ::plpbus_orb::OrbClient::_marshalObjRef(obj, s);
  48 }
  49
  50 plpbus_orb::OrbClient_ptr plpbus_orb::OrbClient_Helper::unmarshalObjRef(cdrStream& s) {
  51   return ::plpbus_orb::OrbClient::_unmarshalObjRef(s);
  52 }
  53
  54 void plpbus_orb::OrbClient_Helper::duplicate(::plpbus_orb::OrbClient_ptr obj) {
  55   if( obj && !obj->_NP_is_nil() )  omni::duplicateObjRef(obj);
  56 }
  57
  58 plpbus_orb::OrbClient_ptr
  59 plpbus_orb::OrbClient::_duplicate(::plpbus_orb::OrbClient_ptr obj)
  60 {
  61   if( obj && !obj->_NP_is_nil() )  omni::duplicateObjRef(obj);
  62   return obj;
  63 }
  64
  65 plpbus_orb::OrbClient_ptr
  66 plpbus_orb::OrbClient::_narrow(::CORBA::Object_ptr obj)
  67 {
  68   if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil();
  69   _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId);
  70   return e ? e : _nil();
  71 }
  72
  73
  74 plpbus_orb::OrbClient_ptr
  75 plpbus_orb::OrbClient::_unchecked_narrow(::CORBA::Object_ptr obj)
  76 {
  77   if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil();
  78   _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId);
  79   return e ? e : _nil();
  80 }
  81
  82 plpbus_orb::OrbClient_ptr
  83 plpbus_orb::OrbClient::_nil()
  84 {
  85 #ifdef OMNI_UNLOADABLE_STUBS
  86   static _objref_OrbClient _the_nil_obj;
  87   return &_the_nil_obj;
  88 #else
  89   static _objref_OrbClient* _the_nil_ptr = 0;
  90   if( !_the_nil_ptr ) {
  91     omni::nilRefLock().lock();
  92     if( !_the_nil_ptr ) {
  93       _the_nil_ptr = new _objref_OrbClient;
  94       registerNilCorbaObject(_the_nil_ptr);
  95     }
  96     omni::nilRefLock().unlock();
  97   }
  98   return _the_nil_ptr;
  99 #endif
 100 }
 101
 102 const char* plpbus_orb::OrbClient::_PD_repoId = "IDL:plpbus_orb/OrbClient:1.0";
 103
 104
 105 plpbus_orb::_objref_OrbClient::~_objref_OrbClient() {
 106
 107 }
 108
 109
 110 plpbus_orb::_objref_OrbClient::_objref_OrbClient(omniIOR* ior, omniIdentity* id) :
 111    omniObjRef(::plpbus_orb::OrbClient::_PD_repoId, ior, id, 1)
 112
 113
 114 {
 115   _PR_setobj(this);
 116 }
 117
 118 void*
 119 plpbus_orb::_objref_OrbClient::_ptrToObjRef(const char* id)
 120 {
 121   if( id == ::plpbus_orb::OrbClient::_PD_repoId )
 122     return (::plpbus_orb::OrbClient_ptr) this;
 123
 124   if( id == ::CORBA::Object::_PD_repoId )
 125     return (::CORBA::Object_ptr) this;
 126
 127   if( omni::strMatch(id, ::plpbus_orb::OrbClient::_PD_repoId) )
 128     return (::plpbus_orb::OrbClient_ptr) this;
 129
 130   if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) )
 131     return (::CORBA::Object_ptr) this;
 132
 133   return 0;
 134 }
 135
 136 // Proxy call descriptor class. Mangled signature:
 137 //  void_i_cstring
 138 class _0RL_cd_00d6793dc2c2a80c_00000000
 139   : public omniCallDescriptor
 140 {
 141 public:
 142   inline _0RL_cd_00d6793dc2c2a80c_00000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0):
 143      omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall)
 144   {
 145
 146   }
 147
 148   void marshalArguments(cdrStream&);
 149   void unmarshalArguments(cdrStream&);
 150
 151
 152
 153   static const char* const _user_exns[];
 154
 155   ::CORBA::String_var arg_0_;
 156   const char* arg_0;
 157 };
 158
 159 void _0RL_cd_00d6793dc2c2a80c_00000000::marshalArguments(cdrStream& _n)
 160 {
 161   _n.marshalString(arg_0,0);
 162
 163 }
 164
 165 void _0RL_cd_00d6793dc2c2a80c_00000000::unmarshalArguments(cdrStream& _n)
 166 {
 167   arg_0_ = _n.unmarshalString(0);
 168   arg_0 = arg_0_.in();
 169
 170 }
 171
 172 const char* const _0RL_cd_00d6793dc2c2a80c_00000000::_user_exns[] = {
 173   0
 174 };
 175
 176 // Local call call-back function.
 177 static void
 178 _0RL_lcfn_00d6793dc2c2a80c_10000000(omniCallDescriptor* cd, omniServant* svnt)
 179 {
 180   _0RL_cd_00d6793dc2c2a80c_00000000* tcd = (_0RL_cd_00d6793dc2c2a80c_00000000*)cd;
 181   plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId);
 182   impl->receive_event_message(tcd->arg_0);
 183
 184
 185 }
 186
 187 void plpbus_orb::_objref_OrbClient::receive_event_message(const char* event_param)
 188 {
 189   _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_10000000, "receive_event_message", 22);
 190   _call_desc.arg_0 = event_param;
 191
 192   _invoke(_call_desc);
 193
 194
 195
 196 }
 197 // Proxy call descriptor class. Mangled signature:
 198 //  void_i_cplpbus__orb_mDataItemSequence
 199 class _0RL_cd_00d6793dc2c2a80c_20000000
 200   : public omniCallDescriptor
 201 {
 202 public:
 203   inline _0RL_cd_00d6793dc2c2a80c_20000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0):
 204      omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall)
 205   {
 206
 207   }
 208
 209   void marshalArguments(cdrStream&);
 210   void unmarshalArguments(cdrStream&);
 211
 212
 213
 214   static const char* const _user_exns[];
 215
 216   plpbus_orb::DataItemSequence_var arg_0_;
 217   const plpbus_orb::DataItemSequence* arg_0;
 218 };
 219
 220 void _0RL_cd_00d6793dc2c2a80c_20000000::marshalArguments(cdrStream& _n)
 221 {
 222   (const plpbus_orb::DataItemSequence&) *arg_0 >>= _n;
 223
 224 }
 225
 226 void _0RL_cd_00d6793dc2c2a80c_20000000::unmarshalArguments(cdrStream& _n)
 227 {
 228   arg_0_ = new plpbus_orb::DataItemSequence;
 229   (plpbus_orb::DataItemSequence&)arg_0_ <<= _n;
 230   arg_0 = &arg_0_.in();
 231
 232 }
 233
 234 const char* const _0RL_cd_00d6793dc2c2a80c_20000000::_user_exns[] = {
 235   0
 236 };
 237
 238 // Local call call-back function.
 239 static void
 240 _0RL_lcfn_00d6793dc2c2a80c_30000000(omniCallDescriptor* cd, omniServant* svnt)
 241 {
 242   _0RL_cd_00d6793dc2c2a80c_20000000* tcd = (_0RL_cd_00d6793dc2c2a80c_20000000*)cd;
 243   plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId);
 244   impl->receive_event_dataitem_sequence(*tcd->arg_0);
 245
 246
 247 }
 248
 249 void plpbus_orb::_objref_OrbClient::receive_event_dataitem_sequence(const ::plpbus_orb::DataItemSequence& event_param)
 250 {
 251   _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_30000000, "receive_event_dataitem_sequence", 32);
 252   _call_desc.arg_0 = &(::plpbus_orb::DataItemSequence&) event_param;
 253
 254   _invoke(_call_desc);
 255
 256
 257
 258 }
 259 // Local call call-back function.
 260 static void
 261 _0RL_lcfn_00d6793dc2c2a80c_40000000(omniCallDescriptor* cd, omniServant* svnt)
 262 {
 263   _0RL_cd_00d6793dc2c2a80c_00000000* tcd = (_0RL_cd_00d6793dc2c2a80c_00000000*)cd;
 264   plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId);
 265   impl->receive_response_message(tcd->arg_0);
 266
 267
 268 }
 269
 270 void plpbus_orb::_objref_OrbClient::receive_response_message(const char* msg_rsp_param)
 271 {
 272   _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_40000000, "receive_response_message", 25);
 273   _call_desc.arg_0 = msg_rsp_param;
 274
 275   _invoke(_call_desc);
 276
 277
 278
 279 }
 280 // Local call call-back function.
 281 static void
 282 _0RL_lcfn_00d6793dc2c2a80c_50000000(omniCallDescriptor* cd, omniServant* svnt)
 283 {
 284   _0RL_cd_00d6793dc2c2a80c_20000000* tcd = (_0RL_cd_00d6793dc2c2a80c_20000000*)cd;
 285   plpbus_orb::_impl_OrbClient* impl = (plpbus_orb::_impl_OrbClient*) svnt->_ptrToInterface(plpbus_orb::OrbClient::_PD_repoId);
 286   impl->receive_response_dataitem_sequence(*tcd->arg_0);
 287
 288
 289 }
 290
 291 void plpbus_orb::_objref_OrbClient::receive_response_dataitem_sequence(const ::plpbus_orb::DataItemSequence& msg_rsp_param)
 292 {
 293   _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_50000000, "receive_response_dataitem_sequence", 35);
 294   _call_desc.arg_0 = &(::plpbus_orb::DataItemSequence&) msg_rsp_param;
 295
 296   _invoke(_call_desc);
 297
 298
 299
 300 }
 301 plpbus_orb::_pof_OrbClient::~_pof_OrbClient() {}
 302
 303
 304 omniObjRef*
 305 plpbus_orb::_pof_OrbClient::newObjRef(omniIOR* ior, omniIdentity* id)
 306 {
 307   return new ::plpbus_orb::_objref_OrbClient(ior, id);
 308 }
 309
 310
 311 ::CORBA::Boolean
 312 plpbus_orb::_pof_OrbClient::is_a(const char* id) const
 313 {
 314   if( omni::ptrStrMatch(id, ::plpbus_orb::OrbClient::_PD_repoId) )
 315     return 1;
 316
 317   return 0;
 318 }
 319
 320 const plpbus_orb::_pof_OrbClient _the_pof_plpbus__orb_mOrbClient;
 321
 322 plpbus_orb::_impl_OrbClient::~_impl_OrbClient() {}
 323
 324
 325 ::CORBA::Boolean
 326 plpbus_orb::_impl_OrbClient::_dispatch(omniCallHandle& _handle)
 327 {
 328   const char* op = _handle.operation_name();
 329
 330   if( omni::strMatch(op, "receive_event_message") ) {
 331
 332     _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_10000000, "receive_event_message", 22, 1);
 333
 334     _handle.upcall(this,_call_desc);
 335     return 1;
 336   }
 337
 338   if( omni::strMatch(op, "receive_event_dataitem_sequence") ) {
 339
 340     _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_30000000, "receive_event_dataitem_sequence", 32, 1);
 341
 342     _handle.upcall(this,_call_desc);
 343     return 1;
 344   }
 345
 346   if( omni::strMatch(op, "receive_response_message") ) {
 347
 348     _0RL_cd_00d6793dc2c2a80c_00000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_40000000, "receive_response_message", 25, 1);
 349
 350     _handle.upcall(this,_call_desc);
 351     return 1;
 352   }
 353
 354   if( omni::strMatch(op, "receive_response_dataitem_sequence") ) {
 355
 356     _0RL_cd_00d6793dc2c2a80c_20000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_50000000, "receive_response_dataitem_sequence", 35, 1);
 357
 358     _handle.upcall(this,_call_desc);
 359     return 1;
 360   }
 361
 362
 363   return 0;
 364 }
 365
 366 void*
 367 plpbus_orb::_impl_OrbClient::_ptrToInterface(const char* id)
 368 {
 369   if( id == ::plpbus_orb::OrbClient::_PD_repoId )
 370     return (::plpbus_orb::_impl_OrbClient*) this;
 371
 372   if( id == ::CORBA::Object::_PD_repoId )
 373     return (void*) 1;
 374
 375   if( omni::strMatch(id, ::plpbus_orb::OrbClient::_PD_repoId) )
 376     return (::plpbus_orb::_impl_OrbClient*) this;
 377
 378   if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) )
 379     return (void*) 1;
 380   return 0;
 381 }
 382
 383 const char*
 384 plpbus_orb::_impl_OrbClient::_mostDerivedRepoId()
 385 {
 386   return ::plpbus_orb::OrbClient::_PD_repoId;
 387 }
 388
 389 plpbus_orb::OrbServer_ptr plpbus_orb::OrbServer_Helper::_nil() {
 390   return ::plpbus_orb::OrbServer::_nil();
 391 }
 392
 393 ::CORBA::Boolean plpbus_orb::OrbServer_Helper::is_nil(::plpbus_orb::OrbServer_ptr p) {
 394   return ::CORBA::is_nil(p);
 395
 396 }
 397
 398 void plpbus_orb::OrbServer_Helper::release(::plpbus_orb::OrbServer_ptr p) {
 399   ::CORBA::release(p);
 400 }
 401
 402 void plpbus_orb::OrbServer_Helper::marshalObjRef(::plpbus_orb::OrbServer_ptr obj, cdrStream& s) {
 403   ::plpbus_orb::OrbServer::_marshalObjRef(obj, s);
 404 }
 405
 406 plpbus_orb::OrbServer_ptr plpbus_orb::OrbServer_Helper::unmarshalObjRef(cdrStream& s) {
 407   return ::plpbus_orb::OrbServer::_unmarshalObjRef(s);
 408 }
 409
 410 void plpbus_orb::OrbServer_Helper::duplicate(::plpbus_orb::OrbServer_ptr obj) {
 411   if( obj && !obj->_NP_is_nil() )  omni::duplicateObjRef(obj);
 412 }
 413
 414 plpbus_orb::OrbServer_ptr
 415 plpbus_orb::OrbServer::_duplicate(::plpbus_orb::OrbServer_ptr obj)
 416 {
 417   if( obj && !obj->_NP_is_nil() )  omni::duplicateObjRef(obj);
 418   return obj;
 419 }
 420
 421 plpbus_orb::OrbServer_ptr
 422 plpbus_orb::OrbServer::_narrow(::CORBA::Object_ptr obj)
 423 {
 424   if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil();
 425   _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId);
 426   return e ? e : _nil();
 427 }
 428
 429
 430 plpbus_orb::OrbServer_ptr
 431 plpbus_orb::OrbServer::_unchecked_narrow(::CORBA::Object_ptr obj)
 432 {
 433   if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil();
 434   _ptr_type e = (_ptr_type) obj->_PR_getobj()->_uncheckedNarrow(_PD_repoId);
 435   return e ? e : _nil();
 436 }
 437
 438 plpbus_orb::OrbServer_ptr
 439 plpbus_orb::OrbServer::_nil()
 440 {
 441 #ifdef OMNI_UNLOADABLE_STUBS
 442   static _objref_OrbServer _the_nil_obj;
 443   return &_the_nil_obj;
 444 #else
 445   static _objref_OrbServer* _the_nil_ptr = 0;
 446   if( !_the_nil_ptr ) {
 447     omni::nilRefLock().lock();
 448     if( !_the_nil_ptr ) {
 449       _the_nil_ptr = new _objref_OrbServer;
 450       registerNilCorbaObject(_the_nil_ptr);
 451     }
 452     omni::nilRefLock().unlock();
 453   }
 454   return _the_nil_ptr;
 455 #endif
 456 }
 457
 458 const char* plpbus_orb::OrbServer::_PD_repoId = "IDL:plpbus_orb/OrbServer:1.0";
 459
 460
 461 plpbus_orb::_objref_OrbServer::~_objref_OrbServer() {
 462
 463 }
 464
 465
 466 plpbus_orb::_objref_OrbServer::_objref_OrbServer(omniIOR* ior, omniIdentity* id) :
 467    omniObjRef(::plpbus_orb::OrbServer::_PD_repoId, ior, id, 1)
 468
 469
 470 {
 471   _PR_setobj(this);
 472 }
 473
 474 void*
 475 plpbus_orb::_objref_OrbServer::_ptrToObjRef(const char* id)
 476 {
 477   if( id == ::plpbus_orb::OrbServer::_PD_repoId )
 478     return (::plpbus_orb::OrbServer_ptr) this;
 479
 480   if( id == ::CORBA::Object::_PD_repoId )
 481     return (::CORBA::Object_ptr) this;
 482
 483   if( omni::strMatch(id, ::plpbus_orb::OrbServer::_PD_repoId) )
 484     return (::plpbus_orb::OrbServer_ptr) this;
 485
 486   if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) )
 487     return (::CORBA::Object_ptr) this;
 488
 489   return 0;
 490 }
 491
 492 // Proxy call descriptor class. Mangled signature:
 493 //  void_i_cplpbus__orb_mOrbClient_i_cstring
 494 class _0RL_cd_00d6793dc2c2a80c_60000000
 495   : public omniCallDescriptor
 496 {
 497 public:
 498   inline _0RL_cd_00d6793dc2c2a80c_60000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0):
 499      omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall)
 500   {
 501
 502   }
 503
 504   void marshalArguments(cdrStream&);
 505   void unmarshalArguments(cdrStream&);
 506
 507
 508
 509   static const char* const _user_exns[];
 510
 511   plpbus_orb::OrbClient_var arg_0_;
 512   plpbus_orb::OrbClient_ptr arg_0;
 513   ::CORBA::String_var arg_1_;
 514   const char* arg_1;
 515 };
 516
 517 void _0RL_cd_00d6793dc2c2a80c_60000000::marshalArguments(cdrStream& _n)
 518 {
 519   plpbus_orb::OrbClient::_marshalObjRef(arg_0,_n);
 520   _n.marshalString(arg_1,0);
 521
 522 }
 523
 524 void _0RL_cd_00d6793dc2c2a80c_60000000::unmarshalArguments(cdrStream& _n)
 525 {
 526   arg_0_ = plpbus_orb::OrbClient::_unmarshalObjRef(_n);
 527   arg_0 = arg_0_.in();
 528   arg_1_ = _n.unmarshalString(0);
 529   arg_1 = arg_1_.in();
 530
 531 }
 532
 533 const char* const _0RL_cd_00d6793dc2c2a80c_60000000::_user_exns[] = {
 534   0
 535 };
 536
 537 // Local call call-back function.
 538 static void
 539 _0RL_lcfn_00d6793dc2c2a80c_70000000(omniCallDescriptor* cd, omniServant* svnt)
 540 {
 541   _0RL_cd_00d6793dc2c2a80c_60000000* tcd = (_0RL_cd_00d6793dc2c2a80c_60000000*)cd;
 542   plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId);
 543   impl->send_message_and_request_response(tcd->arg_0, tcd->arg_1);
 544
 545
 546 }
 547
 548 void plpbus_orb::_objref_OrbServer::send_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const char* msg_param)
 549 {
 550   _0RL_cd_00d6793dc2c2a80c_60000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_70000000, "send_message_and_request_response", 34);
 551   _call_desc.arg_0 = response_listener_param;
 552   _call_desc.arg_1 = msg_param;
 553
 554   _invoke(_call_desc);
 555
 556
 557
 558 }
 559 // Proxy call descriptor class. Mangled signature:
 560 //  void_i_cplpbus__orb_mOrbClient_i_cplpbus__orb_mDataItemSequence
 561 class _0RL_cd_00d6793dc2c2a80c_80000000
 562   : public omniCallDescriptor
 563 {
 564 public:
 565   inline _0RL_cd_00d6793dc2c2a80c_80000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0):
 566      omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall)
 567   {
 568
 569   }
 570
 571   void marshalArguments(cdrStream&);
 572   void unmarshalArguments(cdrStream&);
 573
 574
 575
 576   static const char* const _user_exns[];
 577
 578   plpbus_orb::OrbClient_var arg_0_;
 579   plpbus_orb::OrbClient_ptr arg_0;
 580   plpbus_orb::DataItemSequence_var arg_1_;
 581   const plpbus_orb::DataItemSequence* arg_1;
 582 };
 583
 584 void _0RL_cd_00d6793dc2c2a80c_80000000::marshalArguments(cdrStream& _n)
 585 {
 586   plpbus_orb::OrbClient::_marshalObjRef(arg_0,_n);
 587   (const plpbus_orb::DataItemSequence&) *arg_1 >>= _n;
 588
 589 }
 590
 591 void _0RL_cd_00d6793dc2c2a80c_80000000::unmarshalArguments(cdrStream& _n)
 592 {
 593   arg_0_ = plpbus_orb::OrbClient::_unmarshalObjRef(_n);
 594   arg_0 = arg_0_.in();
 595   arg_1_ = new plpbus_orb::DataItemSequence;
 596   (plpbus_orb::DataItemSequence&)arg_1_ <<= _n;
 597   arg_1 = &arg_1_.in();
 598
 599 }
 600
 601 const char* const _0RL_cd_00d6793dc2c2a80c_80000000::_user_exns[] = {
 602   0
 603 };
 604
 605 // Local call call-back function.
 606 static void
 607 _0RL_lcfn_00d6793dc2c2a80c_90000000(omniCallDescriptor* cd, omniServant* svnt)
 608 {
 609   _0RL_cd_00d6793dc2c2a80c_80000000* tcd = (_0RL_cd_00d6793dc2c2a80c_80000000*)cd;
 610   plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId);
 611   impl->send_dataitem_message_and_request_response(tcd->arg_0, *tcd->arg_1);
 612
 613
 614 }
 615
 616 void plpbus_orb::_objref_OrbServer::send_dataitem_message_and_request_response(::plpbus_orb::OrbClient_ptr response_listener_param, const ::plpbus_orb::DataItemSequence& req_seq_param)
 617 {
 618   _0RL_cd_00d6793dc2c2a80c_80000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_90000000, "send_dataitem_message_and_request_response", 43);
 619   _call_desc.arg_0 = response_listener_param;
 620   _call_desc.arg_1 = &(::plpbus_orb::DataItemSequence&) req_seq_param;
 621
 622   _invoke(_call_desc);
 623
 624
 625
 626 }
 627 // Proxy call descriptor class. Mangled signature:
 628 //  _cstring_i_cstring_o_clong
 629 class _0RL_cd_00d6793dc2c2a80c_a0000000
 630   : public omniCallDescriptor
 631 {
 632 public:
 633   inline _0RL_cd_00d6793dc2c2a80c_a0000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0):
 634      omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall)
 635   {
 636
 637   }
 638
 639   void marshalArguments(cdrStream&);
 640   void unmarshalArguments(cdrStream&);
 641
 642   void unmarshalReturnedValues(cdrStream&);
 643   void marshalReturnedValues(cdrStream&);
 644
 645
 646   static const char* const _user_exns[];
 647
 648   ::CORBA::String_var arg_0_;
 649   const char* arg_0;
 650   ::CORBA::Long arg_1;
 651   ::CORBA::String_var result;
 652 };
 653
 654 void _0RL_cd_00d6793dc2c2a80c_a0000000::marshalArguments(cdrStream& _n)
 655 {
 656   _n.marshalString(arg_0,0);
 657
 658 }
 659
 660 void _0RL_cd_00d6793dc2c2a80c_a0000000::unmarshalArguments(cdrStream& _n)
 661 {
 662   arg_0_ = _n.unmarshalString(0);
 663   arg_0 = arg_0_.in();
 664
 665 }
 666
 667 void _0RL_cd_00d6793dc2c2a80c_a0000000::marshalReturnedValues(cdrStream& _n)
 668 {
 669   _n.marshalString(result,0);
 670   arg_1 >>= _n;
 671
 672 }
 673
 674 void _0RL_cd_00d6793dc2c2a80c_a0000000::unmarshalReturnedValues(cdrStream& _n)
 675 {
 676   result = _n.unmarshalString(0);
 677   (::CORBA::Long&)arg_1 <<= _n;
 678
 679 }
 680
 681 const char* const _0RL_cd_00d6793dc2c2a80c_a0000000::_user_exns[] = {
 682   0
 683 };
 684
 685 // Local call call-back function.
 686 static void
 687 _0RL_lcfn_00d6793dc2c2a80c_b0000000(omniCallDescriptor* cd, omniServant* svnt)
 688 {
 689   _0RL_cd_00d6793dc2c2a80c_a0000000* tcd = (_0RL_cd_00d6793dc2c2a80c_a0000000*)cd;
 690   plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId);
 691   tcd->result = impl->send_message_and_wait_response(tcd->arg_0, tcd->arg_1);
 692
 693
 694 }
 695
 696 char* plpbus_orb::_objref_OrbServer::send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg)
 697 {
 698   _0RL_cd_00d6793dc2c2a80c_a0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_b0000000, "send_message_and_wait_response", 31);
 699   _call_desc.arg_0 = msg_req_param;
 700
 701   _invoke(_call_desc);
 702   err_flg = _call_desc.arg_1;
 703   return _call_desc.result._retn();
 704
 705
 706 }
 707 // Proxy call descriptor class. Mangled signature:
 708 //  _clong_i_cplpbus__orb_mDataItemSequence_o_cplpbus__orb_mDataItemSequence
 709 class _0RL_cd_00d6793dc2c2a80c_c0000000
 710   : public omniCallDescriptor
 711 {
 712 public:
 713   inline _0RL_cd_00d6793dc2c2a80c_c0000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0):
 714      omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall)
 715   {
 716
 717   }
 718
 719   void marshalArguments(cdrStream&);
 720   void unmarshalArguments(cdrStream&);
 721
 722   void unmarshalReturnedValues(cdrStream&);
 723   void marshalReturnedValues(cdrStream&);
 724
 725
 726   static const char* const _user_exns[];
 727
 728   plpbus_orb::DataItemSequence_var arg_0_;
 729   const plpbus_orb::DataItemSequence* arg_0;
 730   plpbus_orb::DataItemSequence_var arg_1;
 731   ::CORBA::Long result;
 732 };
 733
 734 void _0RL_cd_00d6793dc2c2a80c_c0000000::marshalArguments(cdrStream& _n)
 735 {
 736   (const plpbus_orb::DataItemSequence&) *arg_0 >>= _n;
 737
 738 }
 739
 740 void _0RL_cd_00d6793dc2c2a80c_c0000000::unmarshalArguments(cdrStream& _n)
 741 {
 742   arg_0_ = new plpbus_orb::DataItemSequence;
 743   (plpbus_orb::DataItemSequence&)arg_0_ <<= _n;
 744   arg_0 = &arg_0_.in();
 745
 746 }
 747
 748 void _0RL_cd_00d6793dc2c2a80c_c0000000::marshalReturnedValues(cdrStream& _n)
 749 {
 750   result >>= _n;
 751   (const plpbus_orb::DataItemSequence&) arg_1 >>= _n;
 752
 753 }
 754
 755 void _0RL_cd_00d6793dc2c2a80c_c0000000::unmarshalReturnedValues(cdrStream& _n)
 756 {
 757   (::CORBA::Long&)result <<= _n;
 758   arg_1 = new plpbus_orb::DataItemSequence;
 759   (plpbus_orb::DataItemSequence&)arg_1 <<= _n;
 760
 761 }
 762
 763 const char* const _0RL_cd_00d6793dc2c2a80c_c0000000::_user_exns[] = {
 764   0
 765 };
 766
 767 // Local call call-back function.
 768 static void
 769 _0RL_lcfn_00d6793dc2c2a80c_d0000000(omniCallDescriptor* cd, omniServant* svnt)
 770 {
 771   _0RL_cd_00d6793dc2c2a80c_c0000000* tcd = (_0RL_cd_00d6793dc2c2a80c_c0000000*)cd;
 772   plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId);
 773   tcd->result = impl->send_dataitem_message_and_wait_response(*tcd->arg_0, tcd->arg_1.out());
 774
 775
 776 }
 777
 778 ::CORBA::Long plpbus_orb::_objref_OrbServer::send_dataitem_message_and_wait_response(const ::plpbus_orb::DataItemSequence& req_seq_param, ::plpbus_orb::DataItemSequence_out rsp_seq_param)
 779 {
 780   _0RL_cd_00d6793dc2c2a80c_c0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_d0000000, "send_dataitem_message_and_wait_response", 40);
 781   _call_desc.arg_0 = &(::plpbus_orb::DataItemSequence&) req_seq_param;
 782
 783   _invoke(_call_desc);
 784   rsp_seq_param = _call_desc.arg_1._retn();
 785   return _call_desc.result;
 786
 787
 788 }
 789 // Proxy call descriptor class. Mangled signature:
 790 //  void_i_cplpbus__orb_mOrbClient_i_cstring_i_cunsigned_pshort
 791 class _0RL_cd_00d6793dc2c2a80c_e0000000
 792   : public omniCallDescriptor
 793 {
 794 public:
 795   inline _0RL_cd_00d6793dc2c2a80c_e0000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0):
 796      omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall)
 797   {
 798
 799   }
 800
 801   void marshalArguments(cdrStream&);
 802   void unmarshalArguments(cdrStream&);
 803
 804
 805
 806   static const char* const _user_exns[];
 807
 808   plpbus_orb::OrbClient_var arg_0_;
 809   plpbus_orb::OrbClient_ptr arg_0;
 810   ::CORBA::String_var arg_1_;
 811   const char* arg_1;
 812   ::CORBA::UShort arg_2;
 813 };
 814
 815 void _0RL_cd_00d6793dc2c2a80c_e0000000::marshalArguments(cdrStream& _n)
 816 {
 817   plpbus_orb::OrbClient::_marshalObjRef(arg_0,_n);
 818   _n.marshalString(arg_1,0);
 819   arg_2 >>= _n;
 820
 821 }
 822
 823 void _0RL_cd_00d6793dc2c2a80c_e0000000::unmarshalArguments(cdrStream& _n)
 824 {
 825   arg_0_ = plpbus_orb::OrbClient::_unmarshalObjRef(_n);
 826   arg_0 = arg_0_.in();
 827   arg_1_ = _n.unmarshalString(0);
 828   arg_1 = arg_1_.in();
 829   (::CORBA::UShort&)arg_2 <<= _n;
 830
 831 }
 832
 833 const char* const _0RL_cd_00d6793dc2c2a80c_e0000000::_user_exns[] = {
 834   0
 835 };
 836
 837 // Local call call-back function.
 838 static void
 839 _0RL_lcfn_00d6793dc2c2a80c_f0000000(omniCallDescriptor* cd, omniServant* svnt)
 840 {
 841   _0RL_cd_00d6793dc2c2a80c_e0000000* tcd = (_0RL_cd_00d6793dc2c2a80c_e0000000*)cd;
 842   plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId);
 843   impl->add_event_listener(tcd->arg_0, tcd->arg_1, tcd->arg_2);
 844
 845
 846 }
 847
 848 void plpbus_orb::_objref_OrbServer::add_event_listener(::plpbus_orb::OrbClient_ptr callback_client_param, const char* msg_param, ::CORBA::UShort period_secs)
 849 {
 850   _0RL_cd_00d6793dc2c2a80c_e0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_f0000000, "add_event_listener", 19);
 851   _call_desc.arg_0 = callback_client_param;
 852   _call_desc.arg_1 = msg_param;
 853   _call_desc.arg_2 = period_secs;
 854
 855   _invoke(_call_desc);
 856
 857
 858
 859 }
 860 // Proxy call descriptor class. Mangled signature:
 861 //  void
 862 class _0RL_cd_00d6793dc2c2a80c_01000000
 863   : public omniCallDescriptor
 864 {
 865 public:
 866   inline _0RL_cd_00d6793dc2c2a80c_01000000(LocalCallFn lcfn,const char* op_,size_t oplen,_CORBA_Boolean upcall=0):
 867      omniCallDescriptor(lcfn, op_, oplen, 0, _user_exns, 0, upcall)
 868   {
 869
 870   }
 871
 872
 873
 874
 875   static const char* const _user_exns[];
 876
 877
 878 };
 879
 880 const char* const _0RL_cd_00d6793dc2c2a80c_01000000::_user_exns[] = {
 881   0
 882 };
 883
 884 // Local call call-back function.
 885 static void
 886 _0RL_lcfn_00d6793dc2c2a80c_11000000(omniCallDescriptor*, omniServant* svnt)
 887 {
 888
 889   plpbus_orb::_impl_OrbServer* impl = (plpbus_orb::_impl_OrbServer*) svnt->_ptrToInterface(plpbus_orb::OrbServer::_PD_repoId);
 890   impl->shutdown();
 891
 892
 893 }
 894
 895 void plpbus_orb::_objref_OrbServer::shutdown()
 896 {
 897   _0RL_cd_00d6793dc2c2a80c_01000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_11000000, "shutdown", 9);
 898
 899
 900   _invoke(_call_desc);
 901
 902
 903
 904 }
 905 plpbus_orb::_pof_OrbServer::~_pof_OrbServer() {}
 906
 907
 908 omniObjRef*
 909 plpbus_orb::_pof_OrbServer::newObjRef(omniIOR* ior, omniIdentity* id)
 910 {
 911   return new ::plpbus_orb::_objref_OrbServer(ior, id);
 912 }
 913
 914
 915 ::CORBA::Boolean
 916 plpbus_orb::_pof_OrbServer::is_a(const char* id) const
 917 {
 918   if( omni::ptrStrMatch(id, ::plpbus_orb::OrbServer::_PD_repoId) )
 919     return 1;
 920
 921   return 0;
 922 }
 923
 924 const plpbus_orb::_pof_OrbServer _the_pof_plpbus__orb_mOrbServer;
 925
 926 plpbus_orb::_impl_OrbServer::~_impl_OrbServer() {}
 927
 928
 929 ::CORBA::Boolean
 930 plpbus_orb::_impl_OrbServer::_dispatch(omniCallHandle& _handle)
 931 {
 932   const char* op = _handle.operation_name();
 933
 934   if( omni::strMatch(op, "send_message_and_request_response") ) {
 935
 936     _0RL_cd_00d6793dc2c2a80c_60000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_70000000, "send_message_and_request_response", 34, 1);
 937
 938     _handle.upcall(this,_call_desc);
 939     return 1;
 940   }
 941
 942   if( omni::strMatch(op, "send_dataitem_message_and_request_response") ) {
 943
 944     _0RL_cd_00d6793dc2c2a80c_80000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_90000000, "send_dataitem_message_and_request_response", 43, 1);
 945
 946     _handle.upcall(this,_call_desc);
 947     return 1;
 948   }
 949
 950   if( omni::strMatch(op, "send_message_and_wait_response") ) {
 951
 952     _0RL_cd_00d6793dc2c2a80c_a0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_b0000000, "send_message_and_wait_response", 31, 1);
 953
 954     _handle.upcall(this,_call_desc);
 955     return 1;
 956   }
 957
 958   if( omni::strMatch(op, "send_dataitem_message_and_wait_response") ) {
 959
 960     _0RL_cd_00d6793dc2c2a80c_c0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_d0000000, "send_dataitem_message_and_wait_response", 40, 1);
 961
 962     _handle.upcall(this,_call_desc);
 963     return 1;
 964   }
 965
 966   if( omni::strMatch(op, "add_event_listener") ) {
 967
 968     _0RL_cd_00d6793dc2c2a80c_e0000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_f0000000, "add_event_listener", 19, 1);
 969
 970     _handle.upcall(this,_call_desc);
 971     return 1;
 972   }
 973
 974   if( omni::strMatch(op, "shutdown") ) {
 975
 976     _0RL_cd_00d6793dc2c2a80c_01000000 _call_desc(_0RL_lcfn_00d6793dc2c2a80c_11000000, "shutdown", 9, 1);
 977
 978     _handle.upcall(this,_call_desc);
 979     return 1;
 980   }
 981
 982
 983   return 0;
 984 }
 985
 986 void*
 987 plpbus_orb::_impl_OrbServer::_ptrToInterface(const char* id)
 988 {
 989   if( id == ::plpbus_orb::OrbServer::_PD_repoId )
 990     return (::plpbus_orb::_impl_OrbServer*) this;
 991
 992   if( id == ::CORBA::Object::_PD_repoId )
 993     return (void*) 1;
 994
 995   if( omni::strMatch(id, ::plpbus_orb::OrbServer::_PD_repoId) )
 996     return (::plpbus_orb::_impl_OrbServer*) this;
 997
 998   if( omni::strMatch(id, ::CORBA::Object::_PD_repoId) )
 999     return (void*) 1;
1000   return 0;
1001 }
1002
1003 const char*
1004 plpbus_orb::_impl_OrbServer::_mostDerivedRepoId()
1005 {
1006   return ::plpbus_orb::OrbServer::_PD_repoId;
1007 }
1008
1009 POA_plpbus_orb::OrbClient::~OrbClient() {}
1010
1011 POA_plpbus_orb::OrbServer::~OrbServer() {}
1012