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