开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
SynDataSetsSK.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：51k
源码类别：

模拟服务器

开发平台：

C/C++

SynDataSetsSK.cpp：源码内容
  1. // This file is generated by omniidl (C++ backend)- omniORB_3_0. Do not edit.
  3. #include "SynDataSets.h"
  4. #include <omniORB3/callDescriptor.h>
  6. static const char* _0RL_library_version = omniORB_3_0;
  8. SynDataSets_ptr SynDataSets_Helper::_nil() {
  9.   return SynDataSets::_nil();
  10. }
  12. CORBA::Boolean SynDataSets_Helper::is_nil(SynDataSets_ptr p) {
  13.   return CORBA::is_nil(p);
  15. }
  17. void SynDataSets_Helper::release(SynDataSets_ptr p) {
  18.   CORBA::release(p);
  19. }
  21. void SynDataSets_Helper::duplicate(SynDataSets_ptr p) {
  22.   if( p && !p->_NP_is_nil() )  omni::duplicateObjRef(p);
  23. }
  25. size_t SynDataSets_Helper::NP_alignedSize(SynDataSets_ptr obj, size_t offset) {
  26.   return SynDataSets::_alignedSize(obj, offset);
  27. }
  29. void SynDataSets_Helper::marshalObjRef(SynDataSets_ptr obj, NetBufferedStream& s) {
  30.   SynDataSets::_marshalObjRef(obj, s);
  31. }
  33. SynDataSets_ptr SynDataSets_Helper::unmarshalObjRef(NetBufferedStream& s) {
  34.   return SynDataSets::_unmarshalObjRef(s);
  35. }
  37. void SynDataSets_Helper::marshalObjRef(SynDataSets_ptr obj, MemBufferedStream& s) {
  38.   SynDataSets::_marshalObjRef(obj, s);
  39. }
  41. SynDataSets_ptr SynDataSets_Helper::unmarshalObjRef(MemBufferedStream& s) {
  42.   return SynDataSets::_unmarshalObjRef(s);
  43. }
  45. SynDataSets_ptr
  46. SynDataSets::_duplicate(SynDataSets_ptr obj)
  47. {
  48.   if( obj && !obj->_NP_is_nil() )  omni::duplicateObjRef(obj);
  50.   return obj;
  51. }
  53. SynDataSets_ptr
  54. SynDataSets::_narrow(CORBA::Object_ptr obj)
  55. {
  56.   if( !obj || obj->_NP_is_nil() || obj->_NP_is_pseudo() ) return _nil();
  57.   _ptr_type e = (_ptr_type) obj->_PR_getobj()->_realNarrow(_PD_repoId);
  58.   return e ? e : _nil();
  59. }
  61. SynDataSets_ptr
  62. SynDataSets::_nil()
  63. {
  64.   static _objref_SynDataSets* _the_nil_ptr = 0;
  65.   if( !_the_nil_ptr ) {
  66.     omni::nilRefLock().lock();
  67.   if( !_the_nil_ptr )  _the_nil_ptr = new _objref_SynDataSets;
  68.     omni::nilRefLock().unlock();
  69.   }
  70.   return _the_nil_ptr;
  71. }
  73. const char* SynDataSets::_PD_repoId = "IDL:SynDataSets:1.0";
  75. _objref_SynDataSets::~_objref_SynDataSets() {}
  77. _objref_SynDataSets::_objref_SynDataSets(const char* mdri,
  78.    IOP::TaggedProfileList* p, omniIdentity* id, omniLocalIdentity* lid) :
  79.    
  80.    omniObjRef(SynDataSets::_PD_repoId, mdri, p, id, lid)
  81. {
  82.   _PR_setobj(this);
  83. }
  85. void*
  86. _objref_SynDataSets::_ptrToObjRef(const char* id)
  87. {
  88.   if( !strcmp(id, CORBA::Object::_PD_repoId) )
  89.     return (CORBA::Object_ptr) this;
  90.   if( !strcmp(id, SynDataSets::_PD_repoId) )
  91.     return (SynDataSets_ptr) this;
  92.   
  93.   return 0;
  94. }
  96. // Proxy call descriptor class. Mangled signature:
  97. //  _clong_i_clong_i_clong_i_clong_i_cstring
  98. class _0RL_cd_44d3ab5e289658ff_00000000
  99.   : public omniCallDescriptor
  100. {
  101. public:
  102.   inline _0RL_cd_44d3ab5e289658ff_00000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1, CORBA::Long a_2, const char* a_3):
  103.      omniCallDescriptor(lcfn, op, oplen, oneway),
  104.      arg_0(a_0),
  105.      arg_1(a_1),
  106.      arg_2(a_2),
  107.      arg_3(a_3) {}
  109.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  110.   virtual void marshalArguments(GIOP_C&);
  111.   
  112.   virtual void unmarshalReturnedValues(GIOP_C&);
  113.     
  114.   inline CORBA::Long result() { return pd_result; }
  115.   CORBA::Long arg_0;
  116.   CORBA::Long arg_1;
  117.   CORBA::Long arg_2;
  118.   const char* arg_3;
  119.   CORBA::Long pd_result;
  120. };
  122. CORBA::ULong _0RL_cd_44d3ab5e289658ff_00000000::alignedSize(CORBA::ULong msgsize)
  123. {
  124.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  125.   
  126.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  127.   
  128.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  129.   
  130.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  131.   msgsize += ((const char*) arg_3) ? strlen((const char*) arg_3) + 1 : 1;
  132.   
  133.   return msgsize;
  134. }
  136. void _0RL_cd_44d3ab5e289658ff_00000000::marshalArguments(GIOP_C& giop_client)
  137. {
  138.   arg_0 >>= giop_client;
  139.   arg_1 >>= giop_client;
  140.   arg_2 >>= giop_client;
  141.   {
  142.     CORBA::ULong _len = (((const char*) arg_3)? strlen((const char*) arg_3) + 1 : 1);
  143.     
  144.     _len >>= giop_client;
  145.     if (_len > 1)
  146.       giop_client.put_char_array((const CORBA::Char *)((const char*)arg_3),_len);
  147.     else {
  148.       if ((const char*) arg_3 == 0 && omniORB::traceLevel > 1)
  149.         _CORBA_null_string_ptr(0);
  150.       CORBA::Char('') >>= giop_client;
  151.     }
  152.   }
  153.   
  154. }
  156. void _0RL_cd_44d3ab5e289658ff_00000000::unmarshalReturnedValues(GIOP_C& giop_client)
  157. {
  158.   
  159.   pd_result <<= giop_client;
  160.   
  161. }
  163. // Local call call-back function.
  164. static void
  165. _0RL_lcfn_44d3ab5e289658ff_10000000(omniCallDescriptor* cd, omniServant* svnt)
  166. {
  167.   _0RL_cd_44d3ab5e289658ff_00000000* tcd = (_0RL_cd_44d3ab5e289658ff_00000000*) cd;
  168.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  169.   tcd->pd_result = impl->Lock(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
  170. }
  172. CORBA::Long _objref_SynDataSets::Lock(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, const char* ObjName)
  173. {
  174.   _0RL_cd_44d3ab5e289658ff_00000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_10000000, "Lock", 5, 0, MapId, StyleId, Id, ObjName);
  175.   
  176.   _invoke(_call_desc);
  177.   return _call_desc.result();
  178. }
  180. // Proxy call descriptor class. Mangled signature:
  181. //  _clong_i_clong_i_clong_i_clong_i_clong
  182. class _0RL_cd_44d3ab5e289658ff_20000000
  183.   : public omniCallDescriptor
  184. {
  185. public:
  186.   inline _0RL_cd_44d3ab5e289658ff_20000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1, CORBA::Long a_2, CORBA::Long a_3):
  187.      omniCallDescriptor(lcfn, op, oplen, oneway),
  188.      arg_0(a_0),
  189.      arg_1(a_1),
  190.      arg_2(a_2),
  191.      arg_3(a_3) {}
  193.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  194.   virtual void marshalArguments(GIOP_C&);
  195.   
  196.   virtual void unmarshalReturnedValues(GIOP_C&);
  197.     
  198.   inline CORBA::Long result() { return pd_result; }
  199.   CORBA::Long arg_0;
  200.   CORBA::Long arg_1;
  201.   CORBA::Long arg_2;
  202.   CORBA::Long arg_3;
  203.   CORBA::Long pd_result;
  204. };
  206. CORBA::ULong _0RL_cd_44d3ab5e289658ff_20000000::alignedSize(CORBA::ULong msgsize)
  207. {
  208.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  209.   
  210.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  211.   
  212.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  213.   
  214.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  215.   
  216.   return msgsize;
  217. }
  219. void _0RL_cd_44d3ab5e289658ff_20000000::marshalArguments(GIOP_C& giop_client)
  220. {
  221.   arg_0 >>= giop_client;
  222.   arg_1 >>= giop_client;
  223.   arg_2 >>= giop_client;
  224.   arg_3 >>= giop_client;
  225.   
  226. }
  228. void _0RL_cd_44d3ab5e289658ff_20000000::unmarshalReturnedValues(GIOP_C& giop_client)
  229. {
  230.   
  231.   pd_result <<= giop_client;
  232.   
  233. }
  235. // Local call call-back function.
  236. static void
  237. _0RL_lcfn_44d3ab5e289658ff_30000000(omniCallDescriptor* cd, omniServant* svnt)
  238. {
  239.   _0RL_cd_44d3ab5e289658ff_20000000* tcd = (_0RL_cd_44d3ab5e289658ff_20000000*) cd;
  240.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  241.   tcd->pd_result = impl->UnLock(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
  242. }
  244. CORBA::Long _objref_SynDataSets::UnLock(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, CORBA::Long index)
  245. {
  246.   _0RL_cd_44d3ab5e289658ff_20000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_30000000, "UnLock", 7, 0, MapId, StyleId, Id, index);
  247.   
  248.   _invoke(_call_desc);
  249.   return _call_desc.result();
  250. }
  252. // Proxy call descriptor class. Mangled signature:
  253. //  _cany_i_clong_i_clong_i_clong
  254. class _0RL_cd_44d3ab5e289658ff_40000000
  255.   : public omniCallDescriptor
  256. {
  257. public:
  258.   inline _0RL_cd_44d3ab5e289658ff_40000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1, CORBA::Long a_2):
  259.      omniCallDescriptor(lcfn, op, oplen, oneway),
  260.      arg_0(a_0),
  261.      arg_1(a_1),
  262.      arg_2(a_2) {}
  264.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  265.   virtual void marshalArguments(GIOP_C&);
  266.   
  267.   virtual void unmarshalReturnedValues(GIOP_C&);
  268.     
  269.   inline CORBA::Any* result() { return pd_result; }
  270.   CORBA::Long arg_0;
  271.   CORBA::Long arg_1;
  272.   CORBA::Long arg_2;
  273.   CORBA::Any* pd_result;
  274. };
  276. CORBA::ULong _0RL_cd_44d3ab5e289658ff_40000000::alignedSize(CORBA::ULong msgsize)
  277. {
  278.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  279.   
  280.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  281.   
  282.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  283.   
  284.   return msgsize;
  285. }
  287. void _0RL_cd_44d3ab5e289658ff_40000000::marshalArguments(GIOP_C& giop_client)
  288. {
  289.   arg_0 >>= giop_client;
  290.   arg_1 >>= giop_client;
  291.   arg_2 >>= giop_client;
  292.   
  293. }
  295. void _0RL_cd_44d3ab5e289658ff_40000000::unmarshalReturnedValues(GIOP_C& giop_client)
  296. {
  297.   
  298.   pd_result = new CORBA::Any;
  299.   
  300.   *pd_result <<= giop_client;
  301.   
  302. }
  304. // Local call call-back function.
  305. static void
  306. _0RL_lcfn_44d3ab5e289658ff_50000000(omniCallDescriptor* cd, omniServant* svnt)
  307. {
  308.   _0RL_cd_44d3ab5e289658ff_40000000* tcd = (_0RL_cd_44d3ab5e289658ff_40000000*) cd;
  309.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  310.   tcd->pd_result = impl->GetData(tcd->arg_0, tcd->arg_1, tcd->arg_2);
  311. }
  313. CORBA::Any* _objref_SynDataSets::GetData(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id)
  314. {
  315.   _0RL_cd_44d3ab5e289658ff_40000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_50000000, "GetData", 8, 0, MapId, StyleId, Id);
  316.   
  317.   _invoke(_call_desc);
  318.   return _call_desc.result();
  319. }
  321. // Proxy call descriptor class. Mangled signature:
  322. //  _cany_i_clong_i_clong_i_clong_i_clong
  323. class _0RL_cd_44d3ab5e289658ff_60000000
  324.   : public omniCallDescriptor
  325. {
  326. public:
  327.   inline _0RL_cd_44d3ab5e289658ff_60000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1, CORBA::Long a_2, CORBA::Long a_3):
  328.      omniCallDescriptor(lcfn, op, oplen, oneway),
  329.      arg_0(a_0),
  330.      arg_1(a_1),
  331.      arg_2(a_2),
  332.      arg_3(a_3) {}
  334.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  335.   virtual void marshalArguments(GIOP_C&);
  336.   
  337.   virtual void unmarshalReturnedValues(GIOP_C&);
  338.     
  339.   inline CORBA::Any* result() { return pd_result; }
  340.   CORBA::Long arg_0;
  341.   CORBA::Long arg_1;
  342.   CORBA::Long arg_2;
  343.   CORBA::Long arg_3;
  344.   CORBA::Any* pd_result;
  345. };
  347. CORBA::ULong _0RL_cd_44d3ab5e289658ff_60000000::alignedSize(CORBA::ULong msgsize)
  348. {
  349.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  350.   
  351.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  352.   
  353.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  354.   
  355.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  356.   
  357.   return msgsize;
  358. }
  360. void _0RL_cd_44d3ab5e289658ff_60000000::marshalArguments(GIOP_C& giop_client)
  361. {
  362.   arg_0 >>= giop_client;
  363.   arg_1 >>= giop_client;
  364.   arg_2 >>= giop_client;
  365.   arg_3 >>= giop_client;
  366.   
  367. }
  369. void _0RL_cd_44d3ab5e289658ff_60000000::unmarshalReturnedValues(GIOP_C& giop_client)
  370. {
  371.   
  372.   pd_result = new CORBA::Any;
  373.   
  374.   *pd_result <<= giop_client;
  375.   
  376. }
  378. // Local call call-back function.
  379. static void
  380. _0RL_lcfn_44d3ab5e289658ff_70000000(omniCallDescriptor* cd, omniServant* svnt)
  381. {
  382.   _0RL_cd_44d3ab5e289658ff_60000000* tcd = (_0RL_cd_44d3ab5e289658ff_60000000*) cd;
  383.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  384.   tcd->pd_result = impl->GetDataMember(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
  385. }
  387. CORBA::Any* _objref_SynDataSets::GetDataMember(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, CORBA::Long MemberId)
  388. {
  389.   _0RL_cd_44d3ab5e289658ff_60000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_70000000, "GetDataMember", 14, 0, MapId, StyleId, Id, MemberId);
  390.   
  391.   _invoke(_call_desc);
  392.   return _call_desc.result();
  393. }
  395. // Proxy call descriptor class. Mangled signature:
  396. //  _clong_i_clong_i_clong_i_clong_i_cany
  397. class _0RL_cd_44d3ab5e289658ff_80000000
  398.   : public omniCallDescriptor
  399. {
  400. public:
  401.   inline _0RL_cd_44d3ab5e289658ff_80000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1, CORBA::Long a_2, const CORBA::Any& a_3):
  402.      omniCallDescriptor(lcfn, op, oplen, oneway),
  403.      arg_0(a_0),
  404.      arg_1(a_1),
  405.      arg_2(a_2),
  406.      arg_3(a_3) {}
  408.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  409.   virtual void marshalArguments(GIOP_C&);
  410.   
  411.   virtual void unmarshalReturnedValues(GIOP_C&);
  412.     
  413.   inline CORBA::Long result() { return pd_result; }
  414.   CORBA::Long arg_0;
  415.   CORBA::Long arg_1;
  416.   CORBA::Long arg_2;
  417.   const CORBA::Any& arg_3;
  418.   CORBA::Long pd_result;
  419. };
  421. CORBA::ULong _0RL_cd_44d3ab5e289658ff_80000000::alignedSize(CORBA::ULong msgsize)
  422. {
  423.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  424.   
  425.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  426.   
  427.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  428.   
  429.   msgsize = arg_3._NP_alignedSize(msgsize);
  430.   
  431.   return msgsize;
  432. }
  434. void _0RL_cd_44d3ab5e289658ff_80000000::marshalArguments(GIOP_C& giop_client)
  435. {
  436.   arg_0 >>= giop_client;
  437.   arg_1 >>= giop_client;
  438.   arg_2 >>= giop_client;
  439.   arg_3 >>= giop_client;
  440.   
  441. }
  443. void _0RL_cd_44d3ab5e289658ff_80000000::unmarshalReturnedValues(GIOP_C& giop_client)
  444. {
  445.   
  446.   pd_result <<= giop_client;
  447.   
  448. }
  450. // Local call call-back function.
  451. static void
  452. _0RL_lcfn_44d3ab5e289658ff_90000000(omniCallDescriptor* cd, omniServant* svnt)
  453. {
  454.   _0RL_cd_44d3ab5e289658ff_80000000* tcd = (_0RL_cd_44d3ab5e289658ff_80000000*) cd;
  455.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  456.   tcd->pd_result = impl->SetData(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3);
  457. }
  459. CORBA::Long _objref_SynDataSets::SetData(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, const CORBA::Any& data)
  460. {
  461.   _0RL_cd_44d3ab5e289658ff_80000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_90000000, "SetData", 8, 0, MapId, StyleId, Id, data);
  462.   
  463.   _invoke(_call_desc);
  464.   return _call_desc.result();
  465. }
  467. // Proxy call descriptor class. Mangled signature:
  468. //  _clong_i_clong_i_clong_i_clong_i_clong_i_cany
  469. class _0RL_cd_44d3ab5e289658ff_a0000000
  470.   : public omniCallDescriptor
  471. {
  472. public:
  473.   inline _0RL_cd_44d3ab5e289658ff_a0000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1, CORBA::Long a_2, CORBA::Long a_3, const CORBA::Any& a_4):
  474.      omniCallDescriptor(lcfn, op, oplen, oneway),
  475.      arg_0(a_0),
  476.      arg_1(a_1),
  477.      arg_2(a_2),
  478.      arg_3(a_3),
  479.      arg_4(a_4) {}
  481.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  482.   virtual void marshalArguments(GIOP_C&);
  483.   
  484.   virtual void unmarshalReturnedValues(GIOP_C&);
  485.     
  486.   inline CORBA::Long result() { return pd_result; }
  487.   CORBA::Long arg_0;
  488.   CORBA::Long arg_1;
  489.   CORBA::Long arg_2;
  490.   CORBA::Long arg_3;
  491.   const CORBA::Any& arg_4;
  492.   CORBA::Long pd_result;
  493. };
  495. CORBA::ULong _0RL_cd_44d3ab5e289658ff_a0000000::alignedSize(CORBA::ULong msgsize)
  496. {
  497.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  498.   
  499.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  500.   
  501.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  502.   
  503.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  504.   
  505.   msgsize = arg_4._NP_alignedSize(msgsize);
  506.   
  507.   return msgsize;
  508. }
  510. void _0RL_cd_44d3ab5e289658ff_a0000000::marshalArguments(GIOP_C& giop_client)
  511. {
  512.   arg_0 >>= giop_client;
  513.   arg_1 >>= giop_client;
  514.   arg_2 >>= giop_client;
  515.   arg_3 >>= giop_client;
  516.   arg_4 >>= giop_client;
  517.   
  518. }
  520. void _0RL_cd_44d3ab5e289658ff_a0000000::unmarshalReturnedValues(GIOP_C& giop_client)
  521. {
  522.   
  523.   pd_result <<= giop_client;
  524.   
  525. }
  527. // Local call call-back function.
  528. static void
  529. _0RL_lcfn_44d3ab5e289658ff_b0000000(omniCallDescriptor* cd, omniServant* svnt)
  530. {
  531.   _0RL_cd_44d3ab5e289658ff_a0000000* tcd = (_0RL_cd_44d3ab5e289658ff_a0000000*) cd;
  532.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  533.   tcd->pd_result = impl->SetDataMember(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3, tcd->arg_4);
  534. }
  536. CORBA::Long _objref_SynDataSets::SetDataMember(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, CORBA::Long MemberId, const CORBA::Any& data)
  537. {
  538.   _0RL_cd_44d3ab5e289658ff_a0000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_b0000000, "SetDataMember", 14, 0, MapId, StyleId, Id, MemberId, data);
  539.   
  540.   _invoke(_call_desc);
  541.   return _call_desc.result();
  542. }
  544. // Proxy call descriptor class. Mangled signature:
  545. //  _cany_i_clong_i_clong_i_clong_o_clong_i_cstring
  546. class _0RL_cd_44d3ab5e289658ff_c0000000
  547.   : public omniCallDescriptor
  548. {
  549. public:
  550.   inline _0RL_cd_44d3ab5e289658ff_c0000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1, CORBA::Long a_2, CORBA::Long& a_3, const char* a_4):
  551.      omniCallDescriptor(lcfn, op, oplen, oneway),
  552.      arg_0(a_0),
  553.      arg_1(a_1),
  554.      arg_2(a_2),
  555.      arg_3(a_3),
  556.      arg_4(a_4) {}
  558.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  559.   virtual void marshalArguments(GIOP_C&);
  560.   
  561.   virtual void unmarshalReturnedValues(GIOP_C&);
  562.     
  563.   inline CORBA::Any* result() { return pd_result; }
  564.   CORBA::Long arg_0;
  565.   CORBA::Long arg_1;
  566.   CORBA::Long arg_2;
  567.   CORBA::Long& arg_3;
  568.   const char* arg_4;
  569.   CORBA::Any* pd_result;
  570. };
  572. CORBA::ULong _0RL_cd_44d3ab5e289658ff_c0000000::alignedSize(CORBA::ULong msgsize)
  573. {
  574.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  575.   
  576.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  577.   
  578.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  579.   
  580.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  581.   msgsize += ((const char*) arg_4) ? strlen((const char*) arg_4) + 1 : 1;
  582.   
  583.   return msgsize;
  584. }
  586. void _0RL_cd_44d3ab5e289658ff_c0000000::marshalArguments(GIOP_C& giop_client)
  587. {
  588.   arg_0 >>= giop_client;
  589.   arg_1 >>= giop_client;
  590.   arg_2 >>= giop_client;
  591.   {
  592.     CORBA::ULong _len = (((const char*) arg_4)? strlen((const char*) arg_4) + 1 : 1);
  593.     
  594.     _len >>= giop_client;
  595.     if (_len > 1)
  596.       giop_client.put_char_array((const CORBA::Char *)((const char*)arg_4),_len);
  597.     else {
  598.       if ((const char*) arg_4 == 0 && omniORB::traceLevel > 1)
  599.         _CORBA_null_string_ptr(0);
  600.       CORBA::Char('') >>= giop_client;
  601.     }
  602.   }
  603.   
  604. }
  606. void _0RL_cd_44d3ab5e289658ff_c0000000::unmarshalReturnedValues(GIOP_C& giop_client)
  607. {
  608.   
  609.   pd_result = new CORBA::Any;
  610.   
  611.   *pd_result <<= giop_client;
  612.   arg_3 <<= giop_client;
  613.   
  614. }
  616. // Local call call-back function.
  617. static void
  618. _0RL_lcfn_44d3ab5e289658ff_d0000000(omniCallDescriptor* cd, omniServant* svnt)
  619. {
  620.   _0RL_cd_44d3ab5e289658ff_c0000000* tcd = (_0RL_cd_44d3ab5e289658ff_c0000000*) cd;
  621.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  622.   tcd->pd_result = impl->GetDataWithLock(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3, tcd->arg_4);
  623. }
  625. CORBA::Any* _objref_SynDataSets::GetDataWithLock(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, CORBA::Long& Result, const char* ObjName)
  626. {
  627.   _0RL_cd_44d3ab5e289658ff_c0000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_d0000000, "GetDataWithLock", 16, 0, MapId, StyleId, Id, Result, ObjName);
  628.   
  629.   _invoke(_call_desc);
  630.   return _call_desc.result();
  631. }
  633. // Proxy call descriptor class. Mangled signature:
  634. //  _cany_i_clong_i_clong_i_clong_i_clong_i_cany_o_clong_i_cstring
  635. class _0RL_cd_44d3ab5e289658ff_e0000000
  636.   : public omniCallDescriptor
  637. {
  638. public:
  639.   inline _0RL_cd_44d3ab5e289658ff_e0000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1, CORBA::Long a_2, CORBA::Long a_3, const CORBA::Any& a_4, CORBA::Long& a_5, const char* a_6):
  640.      omniCallDescriptor(lcfn, op, oplen, oneway),
  641.      arg_0(a_0),
  642.      arg_1(a_1),
  643.      arg_2(a_2),
  644.      arg_3(a_3),
  645.      arg_4(a_4),
  646.      arg_5(a_5),
  647.      arg_6(a_6) {}
  649.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  650.   virtual void marshalArguments(GIOP_C&);
  651.   
  652.   virtual void unmarshalReturnedValues(GIOP_C&);
  653.     
  654.   inline CORBA::Any* result() { return pd_result; }
  655.   CORBA::Long arg_0;
  656.   CORBA::Long arg_1;
  657.   CORBA::Long arg_2;
  658.   CORBA::Long arg_3;
  659.   const CORBA::Any& arg_4;
  660.   CORBA::Long& arg_5;
  661.   const char* arg_6;
  662.   CORBA::Any* pd_result;
  663. };
  665. CORBA::ULong _0RL_cd_44d3ab5e289658ff_e0000000::alignedSize(CORBA::ULong msgsize)
  666. {
  667.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  668.   
  669.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  670.   
  671.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  672.   
  673.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  674.   
  675.   msgsize = arg_4._NP_alignedSize(msgsize);
  676.   
  677.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  678.   msgsize += ((const char*) arg_6) ? strlen((const char*) arg_6) + 1 : 1;
  679.   
  680.   return msgsize;
  681. }
  683. void _0RL_cd_44d3ab5e289658ff_e0000000::marshalArguments(GIOP_C& giop_client)
  684. {
  685.   arg_0 >>= giop_client;
  686.   arg_1 >>= giop_client;
  687.   arg_2 >>= giop_client;
  688.   arg_3 >>= giop_client;
  689.   arg_4 >>= giop_client;
  690.   {
  691.     CORBA::ULong _len = (((const char*) arg_6)? strlen((const char*) arg_6) + 1 : 1);
  692.     
  693.     _len >>= giop_client;
  694.     if (_len > 1)
  695.       giop_client.put_char_array((const CORBA::Char *)((const char*)arg_6),_len);
  696.     else {
  697.       if ((const char*) arg_6 == 0 && omniORB::traceLevel > 1)
  698.         _CORBA_null_string_ptr(0);
  699.       CORBA::Char('') >>= giop_client;
  700.     }
  701.   }
  702.   
  703. }
  705. void _0RL_cd_44d3ab5e289658ff_e0000000::unmarshalReturnedValues(GIOP_C& giop_client)
  706. {
  707.   
  708.   pd_result = new CORBA::Any;
  709.   
  710.   *pd_result <<= giop_client;
  711.   arg_5 <<= giop_client;
  712.   
  713. }
  715. // Local call call-back function.
  716. static void
  717. _0RL_lcfn_44d3ab5e289658ff_f0000000(omniCallDescriptor* cd, omniServant* svnt)
  718. {
  719.   _0RL_cd_44d3ab5e289658ff_e0000000* tcd = (_0RL_cd_44d3ab5e289658ff_e0000000*) cd;
  720.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  721.   tcd->pd_result = impl->GetDataMemberWithLock(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3, tcd->arg_4, tcd->arg_5, tcd->arg_6);
  722. }
  724. CORBA::Any* _objref_SynDataSets::GetDataMemberWithLock(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, CORBA::Long MemberId, const CORBA::Any& data, CORBA::Long& Result, const char* ObjName)
  725. {
  726.   _0RL_cd_44d3ab5e289658ff_e0000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_f0000000, "GetDataMemberWithLock", 22, 0, MapId, StyleId, Id, MemberId, data, Result, ObjName);
  727.   
  728.   _invoke(_call_desc);
  729.   return _call_desc.result();
  730. }
  732. // Proxy call descriptor class. Mangled signature:
  733. //  _clong_i_clong_i_clong_i_clong_i_cany_o_clong_i_cstring
  734. class _0RL_cd_44d3ab5e289658ff_01000000
  735.   : public omniCallDescriptor
  736. {
  737. public:
  738.   inline _0RL_cd_44d3ab5e289658ff_01000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1, CORBA::Long a_2, const CORBA::Any& a_3, CORBA::Long& a_4, const char* a_5):
  739.      omniCallDescriptor(lcfn, op, oplen, oneway),
  740.      arg_0(a_0),
  741.      arg_1(a_1),
  742.      arg_2(a_2),
  743.      arg_3(a_3),
  744.      arg_4(a_4),
  745.      arg_5(a_5) {}
  747.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  748.   virtual void marshalArguments(GIOP_C&);
  749.   
  750.   virtual void unmarshalReturnedValues(GIOP_C&);
  751.     
  752.   inline CORBA::Long result() { return pd_result; }
  753.   CORBA::Long arg_0;
  754.   CORBA::Long arg_1;
  755.   CORBA::Long arg_2;
  756.   const CORBA::Any& arg_3;
  757.   CORBA::Long& arg_4;
  758.   const char* arg_5;
  759.   CORBA::Long pd_result;
  760. };
  762. CORBA::ULong _0RL_cd_44d3ab5e289658ff_01000000::alignedSize(CORBA::ULong msgsize)
  763. {
  764.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  765.   
  766.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  767.   
  768.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  769.   
  770.   msgsize = arg_3._NP_alignedSize(msgsize);
  771.   
  772.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  773.   msgsize += ((const char*) arg_5) ? strlen((const char*) arg_5) + 1 : 1;
  774.   
  775.   return msgsize;
  776. }
  778. void _0RL_cd_44d3ab5e289658ff_01000000::marshalArguments(GIOP_C& giop_client)
  779. {
  780.   arg_0 >>= giop_client;
  781.   arg_1 >>= giop_client;
  782.   arg_2 >>= giop_client;
  783.   arg_3 >>= giop_client;
  784.   {
  785.     CORBA::ULong _len = (((const char*) arg_5)? strlen((const char*) arg_5) + 1 : 1);
  786.     
  787.     _len >>= giop_client;
  788.     if (_len > 1)
  789.       giop_client.put_char_array((const CORBA::Char *)((const char*)arg_5),_len);
  790.     else {
  791.       if ((const char*) arg_5 == 0 && omniORB::traceLevel > 1)
  792.         _CORBA_null_string_ptr(0);
  793.       CORBA::Char('') >>= giop_client;
  794.     }
  795.   }
  796.   
  797. }
  799. void _0RL_cd_44d3ab5e289658ff_01000000::unmarshalReturnedValues(GIOP_C& giop_client)
  800. {
  801.   
  802.   pd_result <<= giop_client;
  803.   arg_4 <<= giop_client;
  804.   
  805. }
  807. // Local call call-back function.
  808. static void
  809. _0RL_lcfn_44d3ab5e289658ff_11000000(omniCallDescriptor* cd, omniServant* svnt)
  810. {
  811.   _0RL_cd_44d3ab5e289658ff_01000000* tcd = (_0RL_cd_44d3ab5e289658ff_01000000*) cd;
  812.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  813.   tcd->pd_result = impl->SetDataWithLock(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3, tcd->arg_4, tcd->arg_5);
  814. }
  816. CORBA::Long _objref_SynDataSets::SetDataWithLock(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, const CORBA::Any& data, CORBA::Long& Result, const char* ObjName)
  817. {
  818.   _0RL_cd_44d3ab5e289658ff_01000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_11000000, "SetDataWithLock", 16, 0, MapId, StyleId, Id, data, Result, ObjName);
  819.   
  820.   _invoke(_call_desc);
  821.   return _call_desc.result();
  822. }
  824. // Proxy call descriptor class. Mangled signature:
  825. //  _clong_i_clong_i_clong_i_clong_i_clong_i_cany_o_clong_i_cstring
  826. class _0RL_cd_44d3ab5e289658ff_21000000
  827.   : public omniCallDescriptor
  828. {
  829. public:
  830.   inline _0RL_cd_44d3ab5e289658ff_21000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1, CORBA::Long a_2, CORBA::Long a_3, const CORBA::Any& a_4, CORBA::Long& a_5, const char* a_6):
  831.      omniCallDescriptor(lcfn, op, oplen, oneway),
  832.      arg_0(a_0),
  833.      arg_1(a_1),
  834.      arg_2(a_2),
  835.      arg_3(a_3),
  836.      arg_4(a_4),
  837.      arg_5(a_5),
  838.      arg_6(a_6) {}
  840.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  841.   virtual void marshalArguments(GIOP_C&);
  842.   
  843.   virtual void unmarshalReturnedValues(GIOP_C&);
  844.     
  845.   inline CORBA::Long result() { return pd_result; }
  846.   CORBA::Long arg_0;
  847.   CORBA::Long arg_1;
  848.   CORBA::Long arg_2;
  849.   CORBA::Long arg_3;
  850.   const CORBA::Any& arg_4;
  851.   CORBA::Long& arg_5;
  852.   const char* arg_6;
  853.   CORBA::Long pd_result;
  854. };
  856. CORBA::ULong _0RL_cd_44d3ab5e289658ff_21000000::alignedSize(CORBA::ULong msgsize)
  857. {
  858.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  859.   
  860.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  861.   
  862.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  863.   
  864.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  865.   
  866.   msgsize = arg_4._NP_alignedSize(msgsize);
  867.   
  868.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  869.   msgsize += ((const char*) arg_6) ? strlen((const char*) arg_6) + 1 : 1;
  870.   
  871.   return msgsize;
  872. }
  874. void _0RL_cd_44d3ab5e289658ff_21000000::marshalArguments(GIOP_C& giop_client)
  875. {
  876.   arg_0 >>= giop_client;
  877.   arg_1 >>= giop_client;
  878.   arg_2 >>= giop_client;
  879.   arg_3 >>= giop_client;
  880.   arg_4 >>= giop_client;
  881.   {
  882.     CORBA::ULong _len = (((const char*) arg_6)? strlen((const char*) arg_6) + 1 : 1);
  883.     
  884.     _len >>= giop_client;
  885.     if (_len > 1)
  886.       giop_client.put_char_array((const CORBA::Char *)((const char*)arg_6),_len);
  887.     else {
  888.       if ((const char*) arg_6 == 0 && omniORB::traceLevel > 1)
  889.         _CORBA_null_string_ptr(0);
  890.       CORBA::Char('') >>= giop_client;
  891.     }
  892.   }
  893.   
  894. }
  896. void _0RL_cd_44d3ab5e289658ff_21000000::unmarshalReturnedValues(GIOP_C& giop_client)
  897. {
  898.   
  899.   pd_result <<= giop_client;
  900.   arg_5 <<= giop_client;
  901.   
  902. }
  904. // Local call call-back function.
  905. static void
  906. _0RL_lcfn_44d3ab5e289658ff_31000000(omniCallDescriptor* cd, omniServant* svnt)
  907. {
  908.   _0RL_cd_44d3ab5e289658ff_21000000* tcd = (_0RL_cd_44d3ab5e289658ff_21000000*) cd;
  909.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  910.   tcd->pd_result = impl->SetDataMemberWithLock(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3, tcd->arg_4, tcd->arg_5, tcd->arg_6);
  911. }
  913. CORBA::Long _objref_SynDataSets::SetDataMemberWithLock(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, CORBA::Long MemberId, const CORBA::Any& data, CORBA::Long& Result, const char* ObjName)
  914. {
  915.   _0RL_cd_44d3ab5e289658ff_21000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_31000000, "SetDataMemberWithLock", 22, 0, MapId, StyleId, Id, MemberId, data, Result, ObjName);
  916.   
  917.   _invoke(_call_desc);
  918.   return _call_desc.result();
  919. }
  921. // Local call call-back function.
  922. static void
  923. _0RL_lcfn_44d3ab5e289658ff_41000000(omniCallDescriptor* cd, omniServant* svnt)
  924. {
  925.   _0RL_cd_44d3ab5e289658ff_c0000000* tcd = (_0RL_cd_44d3ab5e289658ff_c0000000*) cd;
  926.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  927.   tcd->pd_result = impl->GetDataWithOnce(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3, tcd->arg_4);
  928. }
  930. CORBA::Any* _objref_SynDataSets::GetDataWithOnce(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, CORBA::Long& Result, const char* ObjName)
  931. {
  932.   _0RL_cd_44d3ab5e289658ff_c0000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_41000000, "GetDataWithOnce", 16, 0, MapId, StyleId, Id, Result, ObjName);
  933.   
  934.   _invoke(_call_desc);
  935.   return _call_desc.result();
  936. }
  938. // Proxy call descriptor class. Mangled signature:
  939. //  _cany_i_clong_i_clong_i_clong_i_clong_o_clong_i_cstring
  940. class _0RL_cd_44d3ab5e289658ff_51000000
  941.   : public omniCallDescriptor
  942. {
  943. public:
  944.   inline _0RL_cd_44d3ab5e289658ff_51000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1, CORBA::Long a_2, CORBA::Long a_3, CORBA::Long& a_4, const char* a_5):
  945.      omniCallDescriptor(lcfn, op, oplen, oneway),
  946.      arg_0(a_0),
  947.      arg_1(a_1),
  948.      arg_2(a_2),
  949.      arg_3(a_3),
  950.      arg_4(a_4),
  951.      arg_5(a_5) {}
  953.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  954.   virtual void marshalArguments(GIOP_C&);
  955.   
  956.   virtual void unmarshalReturnedValues(GIOP_C&);
  957.     
  958.   inline CORBA::Any* result() { return pd_result; }
  959.   CORBA::Long arg_0;
  960.   CORBA::Long arg_1;
  961.   CORBA::Long arg_2;
  962.   CORBA::Long arg_3;
  963.   CORBA::Long& arg_4;
  964.   const char* arg_5;
  965.   CORBA::Any* pd_result;
  966. };
  968. CORBA::ULong _0RL_cd_44d3ab5e289658ff_51000000::alignedSize(CORBA::ULong msgsize)
  969. {
  970.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  971.   
  972.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  973.   
  974.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  975.   
  976.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  977.   
  978.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  979.   msgsize += ((const char*) arg_5) ? strlen((const char*) arg_5) + 1 : 1;
  980.   
  981.   return msgsize;
  982. }
  984. void _0RL_cd_44d3ab5e289658ff_51000000::marshalArguments(GIOP_C& giop_client)
  985. {
  986.   arg_0 >>= giop_client;
  987.   arg_1 >>= giop_client;
  988.   arg_2 >>= giop_client;
  989.   arg_3 >>= giop_client;
  990.   {
  991.     CORBA::ULong _len = (((const char*) arg_5)? strlen((const char*) arg_5) + 1 : 1);
  992.     
  993.     _len >>= giop_client;
  994.     if (_len > 1)
  995.       giop_client.put_char_array((const CORBA::Char *)((const char*)arg_5),_len);
  996.     else {
  997.       if ((const char*) arg_5 == 0 && omniORB::traceLevel > 1)
  998.         _CORBA_null_string_ptr(0);
  999.       CORBA::Char('') >>= giop_client;
  1000.     }
  1001.   }
  1002.   
  1003. }
  1005. void _0RL_cd_44d3ab5e289658ff_51000000::unmarshalReturnedValues(GIOP_C& giop_client)
  1006. {
  1007.   
  1008.   pd_result = new CORBA::Any;
  1009.   
  1010.   *pd_result <<= giop_client;
  1011.   arg_4 <<= giop_client;
  1012.   
  1013. }
  1015. // Local call call-back function.
  1016. static void
  1017. _0RL_lcfn_44d3ab5e289658ff_61000000(omniCallDescriptor* cd, omniServant* svnt)
  1018. {
  1019.   _0RL_cd_44d3ab5e289658ff_51000000* tcd = (_0RL_cd_44d3ab5e289658ff_51000000*) cd;
  1020.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  1021.   tcd->pd_result = impl->GetDataMemberWithOnce(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3, tcd->arg_4, tcd->arg_5);
  1022. }
  1024. CORBA::Any* _objref_SynDataSets::GetDataMemberWithOnce(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, CORBA::Long MemberId, CORBA::Long& Result, const char* ObjName)
  1025. {
  1026.   _0RL_cd_44d3ab5e289658ff_51000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_61000000, "GetDataMemberWithOnce", 22, 0, MapId, StyleId, Id, MemberId, Result, ObjName);
  1027.   
  1028.   _invoke(_call_desc);
  1029.   return _call_desc.result();
  1030. }
  1032. // Local call call-back function.
  1033. static void
  1034. _0RL_lcfn_44d3ab5e289658ff_71000000(omniCallDescriptor* cd, omniServant* svnt)
  1035. {
  1036.   _0RL_cd_44d3ab5e289658ff_01000000* tcd = (_0RL_cd_44d3ab5e289658ff_01000000*) cd;
  1037.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  1038.   tcd->pd_result = impl->SetDataWithOnce(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3, tcd->arg_4, tcd->arg_5);
  1039. }
  1041. CORBA::Long _objref_SynDataSets::SetDataWithOnce(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, const CORBA::Any& data, CORBA::Long& Result, const char* ObjName)
  1042. {
  1043.   _0RL_cd_44d3ab5e289658ff_01000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_71000000, "SetDataWithOnce", 16, 0, MapId, StyleId, Id, data, Result, ObjName);
  1044.   
  1045.   _invoke(_call_desc);
  1046.   return _call_desc.result();
  1047. }
  1049. // Local call call-back function.
  1050. static void
  1051. _0RL_lcfn_44d3ab5e289658ff_81000000(omniCallDescriptor* cd, omniServant* svnt)
  1052. {
  1053.   _0RL_cd_44d3ab5e289658ff_21000000* tcd = (_0RL_cd_44d3ab5e289658ff_21000000*) cd;
  1054.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  1055.   tcd->pd_result = impl->SetDataMemberWithOnce(tcd->arg_0, tcd->arg_1, tcd->arg_2, tcd->arg_3, tcd->arg_4, tcd->arg_5, tcd->arg_6);
  1056. }
  1058. CORBA::Long _objref_SynDataSets::SetDataMemberWithOnce(CORBA::Long MapId, CORBA::Long StyleId, CORBA::Long Id, CORBA::Long MemberId, const CORBA::Any& data, CORBA::Long& Result, const char* ObjName)
  1059. {
  1060.   _0RL_cd_44d3ab5e289658ff_21000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_81000000, "SetDataMemberWithOnce", 22, 0, MapId, StyleId, Id, MemberId, data, Result, ObjName);
  1061.   
  1062.   _invoke(_call_desc);
  1063.   return _call_desc.result();
  1064. }
  1066. // Proxy call descriptor class. Mangled signature:
  1067. //  _cDataSeq_i_clong_i_clong
  1068. class _0RL_cd_44d3ab5e289658ff_91000000
  1069.   : public omniCallDescriptor
  1070. {
  1071. public:
  1072.   inline _0RL_cd_44d3ab5e289658ff_91000000(LocalCallFn lcfn, const char* op, size_t oplen, _CORBA_Boolean oneway, CORBA::Long a_0, CORBA::Long a_1):
  1073.      omniCallDescriptor(lcfn, op, oplen, oneway),
  1074.      arg_0(a_0),
  1075.      arg_1(a_1) {}
  1077.   virtual CORBA::ULong alignedSize(CORBA::ULong size_in);
  1078.   virtual void marshalArguments(GIOP_C&);
  1079.   
  1080.   virtual void unmarshalReturnedValues(GIOP_C&);
  1081.     
  1082.   inline DataSeq* result() { return pd_result; }
  1083.   CORBA::Long arg_0;
  1084.   CORBA::Long arg_1;
  1085.   DataSeq* pd_result;
  1086. };
  1088. CORBA::ULong _0RL_cd_44d3ab5e289658ff_91000000::alignedSize(CORBA::ULong msgsize)
  1089. {
  1090.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1091.   
  1092.   msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1093.   
  1094.   return msgsize;
  1095. }
  1097. void _0RL_cd_44d3ab5e289658ff_91000000::marshalArguments(GIOP_C& giop_client)
  1098. {
  1099.   arg_0 >>= giop_client;
  1100.   arg_1 >>= giop_client;
  1101.   
  1102. }
  1104. void _0RL_cd_44d3ab5e289658ff_91000000::unmarshalReturnedValues(GIOP_C& giop_client)
  1105. {
  1106.   
  1107.   pd_result = new DataSeq;
  1108.   
  1109.   *pd_result <<= giop_client;
  1110.   
  1111. }
  1113. // Local call call-back function.
  1114. static void
  1115. _0RL_lcfn_44d3ab5e289658ff_a1000000(omniCallDescriptor* cd, omniServant* svnt)
  1116. {
  1117.   _0RL_cd_44d3ab5e289658ff_91000000* tcd = (_0RL_cd_44d3ab5e289658ff_91000000*) cd;
  1118.   _impl_SynDataSets* impl = (_impl_SynDataSets*) svnt->_ptrToInterface(SynDataSets::_PD_repoId);
  1119.   tcd->pd_result = impl->SaveDataSets(tcd->arg_0, tcd->arg_1);
  1120. }
  1122. DataSeq* _objref_SynDataSets::SaveDataSets(CORBA::Long MapId, CORBA::Long StyleId)
  1123. {
  1124.   _0RL_cd_44d3ab5e289658ff_91000000 _call_desc(_0RL_lcfn_44d3ab5e289658ff_a1000000, "SaveDataSets", 13, 0, MapId, StyleId);
  1125.   
  1126.   _invoke(_call_desc);
  1127.   return _call_desc.result();
  1128. }
  1130. _pof_SynDataSets::~_pof_SynDataSets() {}
  1132. omniObjRef*
  1133. _pof_SynDataSets::newObjRef(const char* mdri, IOP::TaggedProfileList* p,
  1134.                omniIdentity* id, omniLocalIdentity* lid)
  1135. {
  1136.   return new _objref_SynDataSets(mdri, p, id, lid);
  1137. }
  1139. CORBA::Boolean
  1140. _pof_SynDataSets::is_a(const char* id) const
  1141. {
  1142.   if( !strcmp(id, SynDataSets::_PD_repoId) )
  1143.     return 1;
  1144.   
  1145.   return 0;
  1146. }
  1148. const _pof_SynDataSets _the_pof_SynDataSets;
  1150. _impl_SynDataSets::~_impl_SynDataSets() {}
  1152. CORBA::Boolean
  1153. _impl_SynDataSets::_dispatch(GIOP_S& giop_s)
  1154. {
  1155.   if( !strcmp(giop_s.operation(), "Lock") ) {
  1156.     
  1157.     CORBA::Long arg_MapId;
  1158.     
  1159.     arg_MapId <<= giop_s;
  1160.     CORBA::Long arg_StyleId;
  1161.     
  1162.     arg_StyleId <<= giop_s;
  1163.     CORBA::Long arg_Id;
  1164.     
  1165.     arg_Id <<= giop_s;
  1166.     CORBA::String_var arg_ObjName;
  1167.     
  1168.     {
  1169.       CORBA::String_member _0RL_str_tmp;
  1170.       _0RL_str_tmp <<=  giop_s;
  1171.       arg_ObjName = _0RL_str_tmp._ptr;
  1172.       _0RL_str_tmp._ptr = 0;
  1173.     }
  1174.     
  1175.     giop_s.RequestReceived();
  1176.     CORBA::Long result;
  1177.     
  1178.     result = this->Lock(arg_MapId, arg_StyleId, arg_Id, arg_ObjName.in());
  1179.     
  1180.     if( giop_s.response_expected() ) {
  1181.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1182.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1183.       
  1184.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1185.       result >>= giop_s;
  1186.       
  1187.     }
  1188.     giop_s.ReplyCompleted();
  1189.     return 1;
  1190.   }
  1192.   if( !strcmp(giop_s.operation(), "UnLock") ) {
  1193.     
  1194.     CORBA::Long arg_MapId;
  1195.     
  1196.     arg_MapId <<= giop_s;
  1197.     CORBA::Long arg_StyleId;
  1198.     
  1199.     arg_StyleId <<= giop_s;
  1200.     CORBA::Long arg_Id;
  1201.     
  1202.     arg_Id <<= giop_s;
  1203.     CORBA::Long arg_index;
  1204.     
  1205.     arg_index <<= giop_s;
  1206.     
  1207.     giop_s.RequestReceived();
  1208.     CORBA::Long result;
  1209.     
  1210.     result = this->UnLock(arg_MapId, arg_StyleId, arg_Id, arg_index);
  1211.     
  1212.     if( giop_s.response_expected() ) {
  1213.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1214.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1215.       
  1216.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1217.       result >>= giop_s;
  1218.       
  1219.     }
  1220.     giop_s.ReplyCompleted();
  1221.     return 1;
  1222.   }
  1224.   if( !strcmp(giop_s.operation(), "GetData") ) {
  1225.     
  1226.     CORBA::Long arg_MapId;
  1227.     
  1228.     arg_MapId <<= giop_s;
  1229.     CORBA::Long arg_StyleId;
  1230.     
  1231.     arg_StyleId <<= giop_s;
  1232.     CORBA::Long arg_Id;
  1233.     
  1234.     arg_Id <<= giop_s;
  1235.     
  1236.     giop_s.RequestReceived();
  1237.     CORBA::Any_var result;
  1238.     
  1239.     result = this->GetData(arg_MapId, arg_StyleId, arg_Id);
  1240.     
  1241.     if( giop_s.response_expected() ) {
  1242.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1243.       msgsize = (result.operator->())->_NP_alignedSize(msgsize);
  1244.       
  1245.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1246.       *(result.operator->()) >>= giop_s;
  1247.       
  1248.     }
  1249.     giop_s.ReplyCompleted();
  1250.     return 1;
  1251.   }
  1253.   if( !strcmp(giop_s.operation(), "GetDataMember") ) {
  1254.     
  1255.     CORBA::Long arg_MapId;
  1256.     
  1257.     arg_MapId <<= giop_s;
  1258.     CORBA::Long arg_StyleId;
  1259.     
  1260.     arg_StyleId <<= giop_s;
  1261.     CORBA::Long arg_Id;
  1262.     
  1263.     arg_Id <<= giop_s;
  1264.     CORBA::Long arg_MemberId;
  1265.     
  1266.     arg_MemberId <<= giop_s;
  1267.     
  1268.     giop_s.RequestReceived();
  1269.     CORBA::Any_var result;
  1270.     
  1271.     result = this->GetDataMember(arg_MapId, arg_StyleId, arg_Id, arg_MemberId);
  1272.     
  1273.     if( giop_s.response_expected() ) {
  1274.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1275.       msgsize = (result.operator->())->_NP_alignedSize(msgsize);
  1276.       
  1277.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1278.       *(result.operator->()) >>= giop_s;
  1279.       
  1280.     }
  1281.     giop_s.ReplyCompleted();
  1282.     return 1;
  1283.   }
  1285.   if( !strcmp(giop_s.operation(), "SetData") ) {
  1286.     
  1287.     CORBA::Long arg_MapId;
  1288.     
  1289.     arg_MapId <<= giop_s;
  1290.     CORBA::Long arg_StyleId;
  1291.     
  1292.     arg_StyleId <<= giop_s;
  1293.     CORBA::Long arg_Id;
  1294.     
  1295.     arg_Id <<= giop_s;
  1296.     CORBA::Any arg_data;
  1297.     
  1298.     arg_data <<= giop_s;
  1299.     
  1300.     giop_s.RequestReceived();
  1301.     CORBA::Long result;
  1302.     
  1303.     result = this->SetData(arg_MapId, arg_StyleId, arg_Id, arg_data);
  1304.     
  1305.     if( giop_s.response_expected() ) {
  1306.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1307.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1308.       
  1309.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1310.       result >>= giop_s;
  1311.       
  1312.     }
  1313.     giop_s.ReplyCompleted();
  1314.     return 1;
  1315.   }
  1317.   if( !strcmp(giop_s.operation(), "SetDataMember") ) {
  1318.     
  1319.     CORBA::Long arg_MapId;
  1320.     
  1321.     arg_MapId <<= giop_s;
  1322.     CORBA::Long arg_StyleId;
  1323.     
  1324.     arg_StyleId <<= giop_s;
  1325.     CORBA::Long arg_Id;
  1326.     
  1327.     arg_Id <<= giop_s;
  1328.     CORBA::Long arg_MemberId;
  1329.     
  1330.     arg_MemberId <<= giop_s;
  1331.     CORBA::Any arg_data;
  1332.     
  1333.     arg_data <<= giop_s;
  1334.     
  1335.     giop_s.RequestReceived();
  1336.     CORBA::Long result;
  1337.     
  1338.     result = this->SetDataMember(arg_MapId, arg_StyleId, arg_Id, arg_MemberId, arg_data);
  1339.     
  1340.     if( giop_s.response_expected() ) {
  1341.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1342.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1343.       
  1344.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1345.       result >>= giop_s;
  1346.       
  1347.     }
  1348.     giop_s.ReplyCompleted();
  1349.     return 1;
  1350.   }
  1352.   if( !strcmp(giop_s.operation(), "GetDataWithLock") ) {
  1353.     
  1354.     CORBA::Long arg_MapId;
  1355.     
  1356.     arg_MapId <<= giop_s;
  1357.     CORBA::Long arg_StyleId;
  1358.     
  1359.     arg_StyleId <<= giop_s;
  1360.     CORBA::Long arg_Id;
  1361.     
  1362.     arg_Id <<= giop_s;
  1363.     CORBA::Long arg_Result;
  1364.     
  1365.     CORBA::String_var arg_ObjName;
  1366.     
  1367.     {
  1368.       CORBA::String_member _0RL_str_tmp;
  1369.       _0RL_str_tmp <<=  giop_s;
  1370.       arg_ObjName = _0RL_str_tmp._ptr;
  1371.       _0RL_str_tmp._ptr = 0;
  1372.     }
  1373.     
  1374.     giop_s.RequestReceived();
  1375.     CORBA::Any_var result;
  1376.     
  1377.     result = this->GetDataWithLock(arg_MapId, arg_StyleId, arg_Id, arg_Result, arg_ObjName.in());
  1378.     
  1379.     if( giop_s.response_expected() ) {
  1380.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1381.       msgsize = (result.operator->())->_NP_alignedSize(msgsize);
  1382.       
  1383.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1384.       
  1385.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1386.       *(result.operator->()) >>= giop_s;
  1387.       
  1388.       arg_Result >>= giop_s;
  1389.       
  1390.     }
  1391.     giop_s.ReplyCompleted();
  1392.     return 1;
  1393.   }
  1395.   if( !strcmp(giop_s.operation(), "GetDataMemberWithLock") ) {
  1396.     
  1397.     CORBA::Long arg_MapId;
  1398.     
  1399.     arg_MapId <<= giop_s;
  1400.     CORBA::Long arg_StyleId;
  1401.     
  1402.     arg_StyleId <<= giop_s;
  1403.     CORBA::Long arg_Id;
  1404.     
  1405.     arg_Id <<= giop_s;
  1406.     CORBA::Long arg_MemberId;
  1407.     
  1408.     arg_MemberId <<= giop_s;
  1409.     CORBA::Any arg_data;
  1410.     
  1411.     arg_data <<= giop_s;
  1412.     CORBA::Long arg_Result;
  1413.     
  1414.     CORBA::String_var arg_ObjName;
  1415.     
  1416.     {
  1417.       CORBA::String_member _0RL_str_tmp;
  1418.       _0RL_str_tmp <<=  giop_s;
  1419.       arg_ObjName = _0RL_str_tmp._ptr;
  1420.       _0RL_str_tmp._ptr = 0;
  1421.     }
  1422.     
  1423.     giop_s.RequestReceived();
  1424.     CORBA::Any_var result;
  1425.     
  1426.     result = this->GetDataMemberWithLock(arg_MapId, arg_StyleId, arg_Id, arg_MemberId, arg_data, arg_Result, arg_ObjName.in());
  1427.     
  1428.     if( giop_s.response_expected() ) {
  1429.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1430.       msgsize = (result.operator->())->_NP_alignedSize(msgsize);
  1431.       
  1432.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1433.       
  1434.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1435.       *(result.operator->()) >>= giop_s;
  1436.       
  1437.       arg_Result >>= giop_s;
  1438.       
  1439.     }
  1440.     giop_s.ReplyCompleted();
  1441.     return 1;
  1442.   }
  1444.   if( !strcmp(giop_s.operation(), "SetDataWithLock") ) {
  1445.     
  1446.     CORBA::Long arg_MapId;
  1447.     
  1448.     arg_MapId <<= giop_s;
  1449.     CORBA::Long arg_StyleId;
  1450.     
  1451.     arg_StyleId <<= giop_s;
  1452.     CORBA::Long arg_Id;
  1453.     
  1454.     arg_Id <<= giop_s;
  1455.     CORBA::Any arg_data;
  1456.     
  1457.     arg_data <<= giop_s;
  1458.     CORBA::Long arg_Result;
  1459.     
  1460.     CORBA::String_var arg_ObjName;
  1461.     
  1462.     {
  1463.       CORBA::String_member _0RL_str_tmp;
  1464.       _0RL_str_tmp <<=  giop_s;
  1465.       arg_ObjName = _0RL_str_tmp._ptr;
  1466.       _0RL_str_tmp._ptr = 0;
  1467.     }
  1468.     
  1469.     giop_s.RequestReceived();
  1470.     CORBA::Long result;
  1471.     
  1472.     result = this->SetDataWithLock(arg_MapId, arg_StyleId, arg_Id, arg_data, arg_Result, arg_ObjName.in());
  1473.     
  1474.     if( giop_s.response_expected() ) {
  1475.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1476.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1477.       
  1478.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1479.       
  1480.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1481.       result >>= giop_s;
  1482.       
  1483.       arg_Result >>= giop_s;
  1484.       
  1485.     }
  1486.     giop_s.ReplyCompleted();
  1487.     return 1;
  1488.   }
  1490.   if( !strcmp(giop_s.operation(), "SetDataMemberWithLock") ) {
  1491.     
  1492.     CORBA::Long arg_MapId;
  1493.     
  1494.     arg_MapId <<= giop_s;
  1495.     CORBA::Long arg_StyleId;
  1496.     
  1497.     arg_StyleId <<= giop_s;
  1498.     CORBA::Long arg_Id;
  1499.     
  1500.     arg_Id <<= giop_s;
  1501.     CORBA::Long arg_MemberId;
  1502.     
  1503.     arg_MemberId <<= giop_s;
  1504.     CORBA::Any arg_data;
  1505.     
  1506.     arg_data <<= giop_s;
  1507.     CORBA::Long arg_Result;
  1508.     
  1509.     CORBA::String_var arg_ObjName;
  1510.     
  1511.     {
  1512.       CORBA::String_member _0RL_str_tmp;
  1513.       _0RL_str_tmp <<=  giop_s;
  1514.       arg_ObjName = _0RL_str_tmp._ptr;
  1515.       _0RL_str_tmp._ptr = 0;
  1516.     }
  1517.     
  1518.     giop_s.RequestReceived();
  1519.     CORBA::Long result;
  1520.     
  1521.     result = this->SetDataMemberWithLock(arg_MapId, arg_StyleId, arg_Id, arg_MemberId, arg_data, arg_Result, arg_ObjName.in());
  1522.     
  1523.     if( giop_s.response_expected() ) {
  1524.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1525.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1526.       
  1527.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1528.       
  1529.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1530.       result >>= giop_s;
  1531.       
  1532.       arg_Result >>= giop_s;
  1533.       
  1534.     }
  1535.     giop_s.ReplyCompleted();
  1536.     return 1;
  1537.   }
  1539.   if( !strcmp(giop_s.operation(), "GetDataWithOnce") ) {
  1540.     
  1541.     CORBA::Long arg_MapId;
  1542.     
  1543.     arg_MapId <<= giop_s;
  1544.     CORBA::Long arg_StyleId;
  1545.     
  1546.     arg_StyleId <<= giop_s;
  1547.     CORBA::Long arg_Id;
  1548.     
  1549.     arg_Id <<= giop_s;
  1550.     CORBA::Long arg_Result;
  1551.     
  1552.     CORBA::String_var arg_ObjName;
  1553.     
  1554.     {
  1555.       CORBA::String_member _0RL_str_tmp;
  1556.       _0RL_str_tmp <<=  giop_s;
  1557.       arg_ObjName = _0RL_str_tmp._ptr;
  1558.       _0RL_str_tmp._ptr = 0;
  1559.     }
  1560.     
  1561.     giop_s.RequestReceived();
  1562.     CORBA::Any_var result;
  1563.     
  1564.     result = this->GetDataWithOnce(arg_MapId, arg_StyleId, arg_Id, arg_Result, arg_ObjName.in());
  1565.     
  1566.     if( giop_s.response_expected() ) {
  1567.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1568.       msgsize = (result.operator->())->_NP_alignedSize(msgsize);
  1569.       
  1570.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1571.       
  1572.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1573.       *(result.operator->()) >>= giop_s;
  1574.       
  1575.       arg_Result >>= giop_s;
  1576.       
  1577.     }
  1578.     giop_s.ReplyCompleted();
  1579.     return 1;
  1580.   }
  1582.   if( !strcmp(giop_s.operation(), "GetDataMemberWithOnce") ) {
  1583.     
  1584.     CORBA::Long arg_MapId;
  1585.     
  1586.     arg_MapId <<= giop_s;
  1587.     CORBA::Long arg_StyleId;
  1588.     
  1589.     arg_StyleId <<= giop_s;
  1590.     CORBA::Long arg_Id;
  1591.     
  1592.     arg_Id <<= giop_s;
  1593.     CORBA::Long arg_MemberId;
  1594.     
  1595.     arg_MemberId <<= giop_s;
  1596.     CORBA::Long arg_Result;
  1597.     
  1598.     CORBA::String_var arg_ObjName;
  1599.     
  1600.     {
  1601.       CORBA::String_member _0RL_str_tmp;
  1602.       _0RL_str_tmp <<=  giop_s;
  1603.       arg_ObjName = _0RL_str_tmp._ptr;
  1604.       _0RL_str_tmp._ptr = 0;
  1605.     }
  1606.     
  1607.     giop_s.RequestReceived();
  1608.     CORBA::Any_var result;
  1609.     
  1610.     result = this->GetDataMemberWithOnce(arg_MapId, arg_StyleId, arg_Id, arg_MemberId, arg_Result, arg_ObjName.in());
  1611.     
  1612.     if( giop_s.response_expected() ) {
  1613.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1614.       msgsize = (result.operator->())->_NP_alignedSize(msgsize);
  1615.       
  1616.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1617.       
  1618.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1619.       *(result.operator->()) >>= giop_s;
  1620.       
  1621.       arg_Result >>= giop_s;
  1622.       
  1623.     }
  1624.     giop_s.ReplyCompleted();
  1625.     return 1;
  1626.   }
  1628.   if( !strcmp(giop_s.operation(), "SetDataWithOnce") ) {
  1629.     
  1630.     CORBA::Long arg_MapId;
  1631.     
  1632.     arg_MapId <<= giop_s;
  1633.     CORBA::Long arg_StyleId;
  1634.     
  1635.     arg_StyleId <<= giop_s;
  1636.     CORBA::Long arg_Id;
  1637.     
  1638.     arg_Id <<= giop_s;
  1639.     CORBA::Any arg_data;
  1640.     
  1641.     arg_data <<= giop_s;
  1642.     CORBA::Long arg_Result;
  1643.     
  1644.     CORBA::String_var arg_ObjName;
  1645.     
  1646.     {
  1647.       CORBA::String_member _0RL_str_tmp;
  1648.       _0RL_str_tmp <<=  giop_s;
  1649.       arg_ObjName = _0RL_str_tmp._ptr;
  1650.       _0RL_str_tmp._ptr = 0;
  1651.     }
  1652.     
  1653.     giop_s.RequestReceived();
  1654.     CORBA::Long result;
  1655.     
  1656.     result = this->SetDataWithOnce(arg_MapId, arg_StyleId, arg_Id, arg_data, arg_Result, arg_ObjName.in());
  1657.     
  1658.     if( giop_s.response_expected() ) {
  1659.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1660.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1661.       
  1662.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1663.       
  1664.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1665.       result >>= giop_s;
  1666.       
  1667.       arg_Result >>= giop_s;
  1668.       
  1669.     }
  1670.     giop_s.ReplyCompleted();
  1671.     return 1;
  1672.   }
  1674.   if( !strcmp(giop_s.operation(), "SetDataMemberWithOnce") ) {
  1675.     
  1676.     CORBA::Long arg_MapId;
  1677.     
  1678.     arg_MapId <<= giop_s;
  1679.     CORBA::Long arg_StyleId;
  1680.     
  1681.     arg_StyleId <<= giop_s;
  1682.     CORBA::Long arg_Id;
  1683.     
  1684.     arg_Id <<= giop_s;
  1685.     CORBA::Long arg_MemberId;
  1686.     
  1687.     arg_MemberId <<= giop_s;
  1688.     CORBA::Any arg_data;
  1689.     
  1690.     arg_data <<= giop_s;
  1691.     CORBA::Long arg_Result;
  1692.     
  1693.     CORBA::String_var arg_ObjName;
  1694.     
  1695.     {
  1696.       CORBA::String_member _0RL_str_tmp;
  1697.       _0RL_str_tmp <<=  giop_s;
  1698.       arg_ObjName = _0RL_str_tmp._ptr;
  1699.       _0RL_str_tmp._ptr = 0;
  1700.     }
  1701.     
  1702.     giop_s.RequestReceived();
  1703.     CORBA::Long result;
  1704.     
  1705.     result = this->SetDataMemberWithOnce(arg_MapId, arg_StyleId, arg_Id, arg_MemberId, arg_data, arg_Result, arg_ObjName.in());
  1706.     
  1707.     if( giop_s.response_expected() ) {
  1708.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1709.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1710.       
  1711.       msgsize = omni::align_to(msgsize, omni::ALIGN_4) + 4;
  1712.       
  1713.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1714.       result >>= giop_s;
  1715.       
  1716.       arg_Result >>= giop_s;
  1717.       
  1718.     }
  1719.     giop_s.ReplyCompleted();
  1720.     return 1;
  1721.   }
  1723.   if( !strcmp(giop_s.operation(), "SaveDataSets") ) {
  1724.     
  1725.     CORBA::Long arg_MapId;
  1726.     
  1727.     arg_MapId <<= giop_s;
  1728.     CORBA::Long arg_StyleId;
  1729.     
  1730.     arg_StyleId <<= giop_s;
  1731.     
  1732.     giop_s.RequestReceived();
  1733.     DataSeq_var result;
  1734.     
  1735.     result = this->SaveDataSets(arg_MapId, arg_StyleId);
  1736.     
  1737.     if( giop_s.response_expected() ) {
  1738.       size_t msgsize = (size_t) GIOP_S::ReplyHeaderSize();
  1739.       msgsize = (result.operator->())->_NP_alignedSize(msgsize);
  1740.       
  1741.       giop_s.InitialiseReply(GIOP::NO_EXCEPTION, (CORBA::ULong) msgsize);
  1742.       *(result.operator->()) >>= giop_s;
  1743.       
  1744.     }
  1745.     giop_s.ReplyCompleted();
  1746.     return 1;
  1747.   }
  1749.   return 0;
  1750. }
  1752. void*
  1753. _impl_SynDataSets::_ptrToInterface(const char* id)
  1754. {
  1755.   if( !strcmp(id, CORBA::Object::_PD_repoId) )
  1756.     return (void*) 1;
  1757.   if( !strcmp(id, SynDataSets::_PD_repoId) )
  1758.     return (_impl_SynDataSets*) this;
  1759.   
  1760.   return 0;
  1761. }
  1763. const char*
  1764. _impl_SynDataSets::_mostDerivedRepoId()
  1765. {
  1766.   return SynDataSets::_PD_repoId;
  1767. }
  1769. POA_SynDataSets::~POA_SynDataSets() {}