← Back to branch summary

~ubuntu-branches/ubuntu/karmic/hypre/karmic

« back to all changes in this revision

Viewing changes to src/babel-runtime/sidlx/sidlx_rmi_SimpleTicket_Stub.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam C. Powell, IV
  • Date: 2009-03-20 11:40:12 UTC
  • mfrom: (4.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20090320114012-132h6ok9w2r6o609
Tags: 2.4.0b-2
Rebuild against new openmpi.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/babel-runtime/sidlx/sidlx_rmi_SimpleTicket_Stub.c
2
2
 * File:          sidlx_rmi_SimpleTicket_Stub.c
3
3
 * Symbol:        sidlx.rmi.SimpleTicket-v0.1
4
4
 * Symbol Type:   class
5
 
 * Babel Version: 1.0.0
 
5
 * Babel Version: 1.0.4
6
6
 * Description:   Client-side glue code for sidlx.rmi.SimpleTicket
7
7
 * 
8
8
 * WARNING: Automatically generated; changes will be lost
59
59
#ifdef SIDL_STATIC_LIBRARY
60
60
  _externals = sidlx_rmi_SimpleTicket__externals();
61
61
#else
62
 
  _externals = (struct 
63
 
    sidlx_rmi_SimpleTicket__external*)sidl_dynamicLoadIOR(
 
62
  _externals = (struct sidlx_rmi_SimpleTicket__external*)sidl_dynamicLoadIOR(
64
63
    "sidlx.rmi.SimpleTicket","sidlx_rmi_SimpleTicket__externals") ;
65
 
  sidl_checkIORVersion("sidlx.rmi.SimpleTicket",
66
 
    _externals->d_ior_major_version, _externals->d_ior_minor_version, 0, 10);
 
64
  sidl_checkIORVersion("sidlx.rmi.SimpleTicket", 
 
65
    _externals->d_ior_major_version, _externals->d_ior_minor_version, 1, 0);
67
66
#endif
68
67
  return _externals;
69
68
}
102
101
}
103
102
 
104
103
static struct sidlx_rmi_SimpleTicket__object* 
105
 
  sidlx_rmi_SimpleTicket__remoteConnect(const char* url, sidl_bool ar,
 
104
  sidlx_rmi_SimpleTicket__remoteConnect(const char* url, sidl_bool ar, 
106
105
  sidl_BaseInterface *_ex);
107
 
static struct sidlx_rmi_SimpleTicket__object* 
108
 
  sidlx_rmi_SimpleTicket__IHConnect(struct sidl_rmi_InstanceHandle__object* 
109
 
  instance, sidl_BaseInterface *_ex);
 
106
static struct sidlx_rmi_SimpleTicket__object* sidlx_rmi_SimpleTicket__IHConnect(
 
107
  struct sidl_rmi_InstanceHandle__object* instance, sidl_BaseInterface *_ex);
110
108
/*
111
109
 * RMI connector function for the class.
112
110
 */
204
202
  /* out */ sidl_BaseInterface *_ex)
205
203
#if SIDL_C_INLINE_REPEAT_DEFN
206
204
{
207
 
  return (*self->d_epv->f_isSame)(
 
205
  sidl_bool _result;
 
206
  _result = (*self->d_epv->f_isSame)(
208
207
    self,
209
208
    iobj,
210
209
    _ex);
 
210
  return _result;
211
211
}
212
212
#else /* ISO C 1999 inline semantics */
213
213
;
228
228
  /* out */ sidl_BaseInterface *_ex)
229
229
#if SIDL_C_INLINE_REPEAT_DEFN
230
230
{
231
 
  return (*self->d_epv->f_isType)(
 
231
  sidl_bool _result;
 
232
  _result = (*self->d_epv->f_isType)(
232
233
    self,
233
234
    name,
234
235
    _ex);
 
236
  return _result;
235
237
}
236
238
#else /* ISO C 1999 inline semantics */
237
239
;
248
250
  /* out */ sidl_BaseInterface *_ex)
249
251
#if SIDL_C_INLINE_REPEAT_DEFN
250
252
{
251
 
  return (*self->d_epv->f_getClassInfo)(
 
253
  sidl_ClassInfo _result;
 
254
  _result = (*self->d_epv->f_getClassInfo)(
252
255
    self,
253
256
    _ex);
 
257
  return _result;
254
258
}
255
259
#else /* ISO C 1999 inline semantics */
256
260
;
288
292
  /* out */ sidl_BaseInterface *_ex)
289
293
#if SIDL_C_INLINE_REPEAT_DEFN
290
294
{
291
 
  return (*self->d_epv->f_test)(
 
295
  sidl_bool _result;
 
296
  _result = (*self->d_epv->f_test)(
292
297
    self,
293
298
    _ex);
 
299
  return _result;
294
300
}
295
301
#else /* ISO C 1999 inline semantics */
296
302
;
307
313
  /* out */ sidl_BaseInterface *_ex)
308
314
#if SIDL_C_INLINE_REPEAT_DEFN
309
315
{
310
 
  return (*self->d_epv->f_createEmptyTicketBook)(
 
316
  sidl_rmi_TicketBook _result;
 
317
  _result = (*self->d_epv->f_createEmptyTicketBook)(
311
318
    self,
312
319
    _ex);
 
320
  return _result;
313
321
}
314
322
#else /* ISO C 1999 inline semantics */
315
323
;
328
336
  /* out */ sidl_BaseInterface *_ex)
329
337
#if SIDL_C_INLINE_REPEAT_DEFN
330
338
{
331
 
  return (*self->d_epv->f_getResponse)(
 
339
  sidl_rmi_Response _result;
 
340
  _result = (*self->d_epv->f_getResponse)(
332
341
    self,
333
342
    _ex);
 
343
  return _result;
334
344
}
335
345
#else /* ISO C 1999 inline semantics */
336
346
;
349
359
 
350
360
  if(!connect_loaded) {
351
361
    connect_loaded = 1;
352
 
    sidl_rmi_ConnectRegistry_registerConnect("sidlx.rmi.SimpleTicket",
353
 
      (void*)sidlx_rmi_SimpleTicket__IHConnect,_ex);SIDL_CHECK(*_ex);
 
362
    sidl_rmi_ConnectRegistry_registerConnect("sidlx.rmi.SimpleTicket", (
 
363
      void*)sidlx_rmi_SimpleTicket__IHConnect,_ex);SIDL_CHECK(*_ex);
354
364
  }
355
365
  if (obj != NULL) {
356
366
    sidl_BaseInterface base = (sidl_BaseInterface) obj;
420
430
  /* out */ sidl_BaseInterface *_ex)
421
431
#if SIDL_C_INLINE_REPEAT_DEFN
422
432
{
423
 
  return (*self->d_epv->f__getURL)(
 
433
  char* _result;
 
434
  _result = (*self->d_epv->f__getURL)(
424
435
    self,
425
436
    _ex);
 
437
  return _result;
426
438
}
427
439
#else /* ISO C 1999 inline semantics */
428
440
;
481
493
  /* out */ sidl_BaseInterface *_ex)
482
494
#if SIDL_C_INLINE_REPEAT_DEFN
483
495
{
484
 
  return (*self->d_epv->f__isRemote)(
 
496
  sidl_bool _result;
 
497
  _result = (*self->d_epv->f__isRemote)(
485
498
    self,
486
499
    _ex);
 
500
  return _result;
487
501
}
488
502
#else /* ISO C 1999 inline semantics */
489
503
;
515
529
  const int32_t lower[],
516
530
  const int32_t upper[])
517
531
{
518
 
  return (struct 
519
 
    sidlx_rmi_SimpleTicket__array*)sidl_interface__array_createCol(dimen, lower,
520
 
    upper);
 
532
  return (struct sidlx_rmi_SimpleTicket__array*)sidl_interface__array_createCol(
 
533
    dimen, lower, upper);
521
534
}
522
535
 
523
536
/**
533
546
  const int32_t lower[],
534
547
  const int32_t upper[])
535
548
{
536
 
  return (struct 
537
 
    sidlx_rmi_SimpleTicket__array*)sidl_interface__array_createRow(dimen, lower,
538
 
    upper);
 
549
  return (struct sidlx_rmi_SimpleTicket__array*)sidl_interface__array_createRow(
 
550
    dimen, lower, upper);
539
551
}
540
552
 
541
553
/**
548
560
struct sidlx_rmi_SimpleTicket__array*
549
561
sidlx_rmi_SimpleTicket__array_create1d(int32_t len)
550
562
{
551
 
  return (struct 
552
 
    sidlx_rmi_SimpleTicket__array*)sidl_interface__array_create1d(len);
 
563
  return (struct sidlx_rmi_SimpleTicket__array*)sidl_interface__array_create1d(
 
564
    len);
553
565
}
554
566
 
555
567
/**
566
578
  sidlx_rmi_SimpleTicket* data)
567
579
{
568
580
  return (struct 
569
 
    sidlx_rmi_SimpleTicket__array*)sidl_interface__array_create1dInit(len,
570
 
    (struct sidl_BaseInterface__object **)data);
 
581
    sidlx_rmi_SimpleTicket__array*)sidl_interface__array_create1dInit(len, (
 
582
    struct sidl_BaseInterface__object **)data);
571
583
}
572
584
 
573
585
/**
782
794
  const int32_t indices[])
783
795
{
784
796
  return (sidlx_rmi_SimpleTicket)
785
 
    sidl_interface__array_get((const struct sidl_interface__array *)array,
 
797
    sidl_interface__array_get((const struct sidl_interface__array *)array, 
786
798
      indices);
787
799
}
788
800
 
908
920
  const int32_t indices[],
909
921
  sidlx_rmi_SimpleTicket const value)
910
922
{
911
 
  sidl_interface__array_set((struct sidl_interface__array *)array, indices,
912
 
    (struct sidl_BaseInterface__object *)value);
 
923
  sidl_interface__array_set((struct sidl_interface__array *)array, indices, (
 
924
    struct sidl_BaseInterface__object *)value);
913
925
}
914
926
 
915
927
/**
933
945
  const struct sidlx_rmi_SimpleTicket__array* array,
934
946
  const int32_t ind)
935
947
{
936
 
  return sidl_interface__array_lower((struct sidl_interface__array *)array,
 
948
  return sidl_interface__array_lower((struct sidl_interface__array *)array, 
937
949
    ind);
938
950
}
939
951
 
947
959
  const struct sidlx_rmi_SimpleTicket__array* array,
948
960
  const int32_t ind)
949
961
{
950
 
  return sidl_interface__array_upper((struct sidl_interface__array *)array,
 
962
  return sidl_interface__array_upper((struct sidl_interface__array *)array, 
951
963
    ind);
952
964
}
953
965
 
961
973
  const struct sidlx_rmi_SimpleTicket__array* array,
962
974
  const int32_t ind)
963
975
{
964
 
  return sidl_interface__array_length((struct sidl_interface__array *)array,
 
976
  return sidl_interface__array_length((struct sidl_interface__array *)array, 
965
977
    ind);
966
978
}
967
979
 
975
987
  const struct sidlx_rmi_SimpleTicket__array* array,
976
988
  const int32_t ind)
977
989
{
978
 
  return sidl_interface__array_stride((struct sidl_interface__array *)array,
 
990
  return sidl_interface__array_stride((struct sidl_interface__array *)array, 
979
991
    ind);
980
992
}
981
993
 
1141
1153
  int     ordering)
1142
1154
{
1143
1155
  return (struct sidlx_rmi_SimpleTicket__array*)
1144
 
    sidl_interface__array_ensure((struct sidl_interface__array *)src, dimen,
 
1156
    sidl_interface__array_ensure((struct sidl_interface__array *)src, dimen, 
1145
1157
      ordering);
1146
1158
}
1147
1159
 
1196
1208
#endif
1197
1209
 
1198
1210
/* Static variables to hold version of IOR */
1199
 
static const int32_t s_IOR_MAJOR_VERSION = 0;
1200
 
static const int32_t s_IOR_MINOR_VERSION = 10;
 
1211
static const int32_t s_IOR_MAJOR_VERSION = 1;
 
1212
static const int32_t s_IOR_MINOR_VERSION = 0;
1201
1213
 
1202
1214
/* Static variables for managing EPV initialization. */
1203
1215
static int s_remote_initialized = 0;
1239
1251
      cmp2 = strcmp(name, "sidl.BaseClass");
1240
1252
      if (!cmp2) {
1241
1253
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
1242
 
        cast = self;
 
1254
        cast = ((struct sidl_BaseClass__object*)self);
1243
1255
        return cast;
1244
1256
      }
1245
1257
    }
1248
1260
    cmp1 = strcmp(name, "sidlx.rmi.SimpleTicket");
1249
1261
    if (!cmp1) {
1250
1262
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
1251
 
      cast = self;
 
1263
      cast = ((struct sidlx_rmi_SimpleTicket__object*)self);
1252
1264
      return cast;
1253
1265
    }
1254
1266
  }
1255
1267
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
1256
 
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,
1257
 
      struct sidl_BaseInterface__object**) = 
1258
 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,
1259
 
        struct sidl_BaseInterface__object**)) 
 
1268
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1269
      sidl_BaseInterface__object**) = 
 
1270
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1271
        sidl_BaseInterface__object**)) 
1260
1272
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
1261
1273
    cast =  (*func)(((struct 
1262
1274
      sidlx_rmi_SimpleTicket__remote*)self->d_data)->d_ih, _ex);
1299
1311
  struct sidl_rmi_InstanceHandle__object *_conn = ((struct 
1300
1312
    sidlx_rmi_SimpleTicket__remote*)self->d_data)->d_ih;
1301
1313
  sidl_rmi_Response _rsvp = NULL;
1302
 
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1314
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1303
1315
    "addRef", _ex ); SIDL_CHECK(*_ex);
1304
1316
  /* send actual RMI request */
1305
1317
  _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
1344
1356
    sidl_rmi_Response _rsvp = NULL;
1345
1357
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1346
1358
      sidlx_rmi_SimpleTicket__remote*)self->d_data)->d_ih;
1347
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1359
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1348
1360
      "_set_hooks", _ex ); SIDL_CHECK(*_ex);
1349
1361
 
1350
1362
    /* pack in and inout arguments */
1398
1410
    sidl_rmi_Response _rsvp = NULL;
1399
1411
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1400
1412
      sidlx_rmi_SimpleTicket__remote*)self->d_data)->d_ih;
1401
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1413
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1402
1414
      "setResponse", _ex ); SIDL_CHECK(*_ex);
1403
1415
 
1404
1416
    /* pack in and inout arguments */
1405
1417
    if(r){
1406
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)r,
 
1418
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)r, 
1407
1419
        _ex);SIDL_CHECK(*_ex);
1408
1420
      sidl_rmi_Invocation_packString( _inv, "r", _url, _ex);SIDL_CHECK(*_ex);
1409
1421
      free((void*)_url);
1489
1501
    sidl_bool _retval = FALSE;
1490
1502
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1491
1503
      sidlx_rmi_SimpleTicket__remote*)self->d_data)->d_ih;
1492
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1504
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1493
1505
      "isSame", _ex ); SIDL_CHECK(*_ex);
1494
1506
 
1495
1507
    /* pack in and inout arguments */
1496
1508
    if(iobj){
1497
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,
 
1509
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj, 
1498
1510
        _ex);SIDL_CHECK(*_ex);
1499
1511
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(*_ex);
1500
1512
      free((void*)_url);
1515
1527
    }
1516
1528
 
1517
1529
    /* extract return value */
1518
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1519
 
      _ex);SIDL_CHECK(*_ex);
 
1530
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1531
      *_ex);
1520
1532
 
1521
1533
    /* unpack out and inout arguments */
1522
1534
 
1545
1557
    sidl_bool _retval = FALSE;
1546
1558
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1547
1559
      sidlx_rmi_SimpleTicket__remote*)self->d_data)->d_ih;
1548
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1560
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1549
1561
      "isType", _ex ); SIDL_CHECK(*_ex);
1550
1562
 
1551
1563
    /* pack in and inout arguments */
1564
1576
    }
1565
1577
 
1566
1578
    /* extract return value */
1567
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1568
 
      _ex);SIDL_CHECK(*_ex);
 
1579
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1580
      *_ex);
1569
1581
 
1570
1582
    /* unpack out and inout arguments */
1571
1583
 
1594
1606
    struct sidl_ClassInfo__object* _retval = 0;
1595
1607
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1596
1608
      sidlx_rmi_SimpleTicket__remote*)self->d_data)->d_ih;
1597
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1609
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1598
1610
      "getClassInfo", _ex ); SIDL_CHECK(*_ex);
1599
1611
 
1600
1612
    /* pack in and inout arguments */
1612
1624
    }
1613
1625
 
1614
1626
    /* extract return value */
1615
 
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
1616
 
      _ex);SIDL_CHECK(*_ex);
1617
 
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,
1618
 
      _ex);SIDL_CHECK(*_ex);
 
1627
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
1628
      _ex);SIDL_CHECK(*_ex);
 
1629
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
1630
      *_ex);
1619
1631
 
1620
1632
    /* unpack out and inout arguments */
1621
1633
 
1642
1654
    sidl_rmi_Response _rsvp = NULL;
1643
1655
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1644
1656
      sidlx_rmi_SimpleTicket__remote*)self->d_data)->d_ih;
1645
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1657
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1646
1658
      "block", _ex ); SIDL_CHECK(*_ex);
1647
1659
 
1648
1660
    /* pack in and inout arguments */
1685
1697
    sidl_bool _retval = FALSE;
1686
1698
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1687
1699
      sidlx_rmi_SimpleTicket__remote*)self->d_data)->d_ih;
1688
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1700
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1689
1701
      "test", _ex ); SIDL_CHECK(*_ex);
1690
1702
 
1691
1703
    /* pack in and inout arguments */
1703
1715
    }
1704
1716
 
1705
1717
    /* extract return value */
1706
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1707
 
      _ex);SIDL_CHECK(*_ex);
 
1718
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1719
      *_ex);
1708
1720
 
1709
1721
    /* unpack out and inout arguments */
1710
1722
 
1733
1745
    struct sidl_rmi_TicketBook__object* _retval = 0;
1734
1746
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1735
1747
      sidlx_rmi_SimpleTicket__remote*)self->d_data)->d_ih;
1736
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1748
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1737
1749
      "createEmptyTicketBook", _ex ); SIDL_CHECK(*_ex);
1738
1750
 
1739
1751
    /* pack in and inout arguments */
1751
1763
    }
1752
1764
 
1753
1765
    /* extract return value */
1754
 
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
1755
 
      _ex);SIDL_CHECK(*_ex);
1756
 
    _retval = sidl_rmi_TicketBook__connectI(_retval_str, FALSE,
1757
 
      _ex);SIDL_CHECK(*_ex);
 
1766
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
1767
      _ex);SIDL_CHECK(*_ex);
 
1768
    _retval = sidl_rmi_TicketBook__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
1769
      *_ex);
1758
1770
 
1759
1771
    /* unpack out and inout arguments */
1760
1772
 
1783
1795
    struct sidl_rmi_Response__object* _retval = 0;
1784
1796
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1785
1797
      sidlx_rmi_SimpleTicket__remote*)self->d_data)->d_ih;
1786
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1798
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1787
1799
      "getResponse", _ex ); SIDL_CHECK(*_ex);
1788
1800
 
1789
1801
    /* pack in and inout arguments */
1801
1813
    }
1802
1814
 
1803
1815
    /* extract return value */
1804
 
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
1805
 
      _ex);SIDL_CHECK(*_ex);
1806
 
    _retval = sidl_rmi_Response__connectI(_retval_str, FALSE,
1807
 
      _ex);SIDL_CHECK(*_ex);
 
1816
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
1817
      _ex);SIDL_CHECK(*_ex);
 
1818
    _retval = sidl_rmi_Response__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
1819
      *_ex);
1808
1820
 
1809
1821
    /* unpack out and inout arguments */
1810
1822
 
1858
1870
    sidl_BaseInterface*)) epv->f__raddRef;
1859
1871
  e0->f__isRemote    = (sidl_bool (*)(struct sidl_BaseClass__object*,
1860
1872
    sidl_BaseInterface*)) epv->f__isRemote;
1861
 
  e0->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t,
 
1873
  e0->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t, 
1862
1874
    sidl_BaseInterface*)) epv->f__set_hooks;
1863
1875
  e0->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,
1864
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
1865
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1866
 
  e0->f_addRef       = (void (*)(struct sidl_BaseClass__object*,
1867
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1868
 
  e0->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,
1869
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1870
 
  e0->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,
1871
 
    struct sidl_BaseInterface__object*,
1872
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1873
 
  e0->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,
1874
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
1876
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
1877
    sidl_BaseInterface__object **)) epv->f__exec;
 
1878
  e0->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct 
 
1879
    sidl_BaseInterface__object **)) epv->f_addRef;
 
1880
  e0->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct 
 
1881
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1882
  e0->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct 
 
1883
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
1884
    epv->f_isSame;
 
1885
  e0->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const 
 
1886
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
1875
1887
  e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
1876
 
    sidl_BaseClass__object*,
1877
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1888
    sidl_BaseClass__object*,struct sidl_BaseInterface__object **)) 
 
1889
    epv->f_getClassInfo;
1878
1890
 
1879
 
  e1->f__cast        = (void* (*)(void*,const char*,
1880
 
    sidl_BaseInterface*)) epv->f__cast;
 
1891
  e1->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
1892
    epv->f__cast;
1881
1893
  e1->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
1882
1894
  e1->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
1883
1895
  e1->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
1884
 
  e1->f__isRemote    = (sidl_bool (*)(void*,
1885
 
    sidl_BaseInterface*)) epv->f__isRemote;
1886
 
  e1->f__set_hooks   = (void (*)(void*,int32_t,
1887
 
    sidl_BaseInterface*)) epv->f__set_hooks;
1888
 
  e1->f__exec        = (void (*)(void*,const char*,
1889
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
1890
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1891
 
  e1->f_addRef       = (void (*)(void*,
1892
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1893
 
  e1->f_deleteRef    = (void (*)(void*,
1894
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1896
  e1->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
1897
    epv->f__isRemote;
 
1898
  e1->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
1899
    epv->f__set_hooks;
 
1900
  e1->f__exec        = (void (*)(void*,const char*,struct 
 
1901
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
1902
    sidl_BaseInterface__object **)) epv->f__exec;
 
1903
  e1->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
1904
    epv->f_addRef;
 
1905
  e1->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
1906
    epv->f_deleteRef;
1895
1907
  e1->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
1896
1908
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1897
 
  e1->f_isType       = (sidl_bool (*)(void*,const char*,
1898
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
1899
 
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
1900
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1909
  e1->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
1910
    sidl_BaseInterface__object **)) epv->f_isType;
 
1911
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
1912
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
1901
1913
 
1902
1914
  e2->f__cast                 = (void* (*)(void*,const char*,
1903
1915
    sidl_BaseInterface*)) epv->f__cast;
1904
 
  e2->f__delete               = (void (*)(void*,
1905
 
    sidl_BaseInterface*)) epv->f__delete;
1906
 
  e2->f__getURL               = (char* (*)(void*,
1907
 
    sidl_BaseInterface*)) epv->f__getURL;
1908
 
  e2->f__raddRef              = (void (*)(void*,
1909
 
    sidl_BaseInterface*)) epv->f__raddRef;
1910
 
  e2->f__isRemote             = (sidl_bool (*)(void*,
1911
 
    sidl_BaseInterface*)) epv->f__isRemote;
1912
 
  e2->f__set_hooks            = (void (*)(void*,int32_t,
1913
 
    sidl_BaseInterface*)) epv->f__set_hooks;
1914
 
  e2->f__exec                 = (void (*)(void*,const char*,
1915
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
1916
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1917
 
  e2->f_block                 = (void (*)(void*,
1918
 
    struct sidl_BaseInterface__object **)) epv->f_block;
1919
 
  e2->f_test                  = (sidl_bool (*)(void*,
1920
 
    struct sidl_BaseInterface__object **)) epv->f_test;
 
1916
  e2->f__delete               = (void (*)(void*,sidl_BaseInterface*)) 
 
1917
    epv->f__delete;
 
1918
  e2->f__getURL               = (char* (*)(void*,sidl_BaseInterface*)) 
 
1919
    epv->f__getURL;
 
1920
  e2->f__raddRef              = (void (*)(void*,sidl_BaseInterface*)) 
 
1921
    epv->f__raddRef;
 
1922
  e2->f__isRemote             = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
1923
    epv->f__isRemote;
 
1924
  e2->f__set_hooks            = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
1925
    epv->f__set_hooks;
 
1926
  e2->f__exec                 = (void (*)(void*,const char*,struct 
 
1927
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
1928
    sidl_BaseInterface__object **)) epv->f__exec;
 
1929
  e2->f_block                 = (void (*)(void*,struct 
 
1930
    sidl_BaseInterface__object **)) epv->f_block;
 
1931
  e2->f_test                  = (sidl_bool (*)(void*,struct 
 
1932
    sidl_BaseInterface__object **)) epv->f_test;
1921
1933
  e2->f_createEmptyTicketBook = (struct sidl_rmi_TicketBook__object* (*)(void*,
1922
1934
    struct sidl_BaseInterface__object **)) epv->f_createEmptyTicketBook;
1923
1935
  e2->f_getResponse           = (struct sidl_rmi_Response__object* (*)(void*,
1924
1936
    struct sidl_BaseInterface__object **)) epv->f_getResponse;
1925
 
  e2->f_addRef                = (void (*)(void*,
1926
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1927
 
  e2->f_deleteRef             = (void (*)(void*,
1928
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1929
 
  e2->f_isSame                = (sidl_bool (*)(void*,
1930
 
    struct sidl_BaseInterface__object*,
1931
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1932
 
  e2->f_isType                = (sidl_bool (*)(void*,const char*,
1933
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
1937
  e2->f_addRef                = (void (*)(void*,struct 
 
1938
    sidl_BaseInterface__object **)) epv->f_addRef;
 
1939
  e2->f_deleteRef             = (void (*)(void*,struct 
 
1940
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1941
  e2->f_isSame                = (sidl_bool (*)(void*,struct 
 
1942
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
1943
    epv->f_isSame;
 
1944
  e2->f_isType                = (sidl_bool (*)(void*,const char*,struct 
 
1945
    sidl_BaseInterface__object **)) epv->f_isType;
1934
1946
  e2->f_getClassInfo          = (struct sidl_ClassInfo__object* (*)(void*,
1935
1947
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
1936
1948
 
1939
1951
 
1940
1952
/* Create an instance that connects to an existing remote object. */
1941
1953
static struct sidlx_rmi_SimpleTicket__object*
1942
 
sidlx_rmi_SimpleTicket__remoteConnect(const char *url, sidl_bool ar,
 
1954
sidlx_rmi_SimpleTicket__remoteConnect(const char *url, sidl_bool ar, 
1943
1955
  sidl_BaseInterface *_ex)
1944
1956
{
1945
1957
  struct sidlx_rmi_SimpleTicket__object* self;
1955
1967
  if(url == NULL) {return NULL;}
1956
1968
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
1957
1969
  if(objectID) {
1958
 
    sidl_BaseInterface bi = 
1959
 
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
1960
 
      objectID, _ex); SIDL_CHECK(*_ex);
 
1970
    sidl_BaseInterface bi = (
 
1971
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(objectID,
 
1972
      _ex); SIDL_CHECK(*_ex);
1961
1973
    return sidlx_rmi_SimpleTicket__rmicast(bi,_ex);SIDL_CHECK(*_ex);
1962
1974
  }
1963
 
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar,
1964
 
    _ex ); SIDL_CHECK(*_ex);
 
1975
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex ); 
 
1976
    SIDL_CHECK(*_ex);
1965
1977
  if ( instance == NULL) { return NULL; }
1966
1978
  self =
1967
1979
    (struct sidlx_rmi_SimpleTicket__object*) malloc(
2003
2015
/* Create an instance that uses an already existing  */
2004
2016
/* InstanceHandle to connect to an existing remote object. */
2005
2017
static struct sidlx_rmi_SimpleTicket__object*
2006
 
sidlx_rmi_SimpleTicket__IHConnect(sidl_rmi_InstanceHandle instance,
 
2018
sidlx_rmi_SimpleTicket__IHConnect(sidl_rmi_InstanceHandle instance, 
2007
2019
  sidl_BaseInterface *_ex)
2008
2020
{
2009
2021
  struct sidlx_rmi_SimpleTicket__object* self;
2061
2073
  struct sidl_BaseClass__object* s1;
2062
2074
 
2063
2075
  struct sidlx_rmi_SimpleTicket__remote* r_obj;
2064
 
  sidl_rmi_InstanceHandle instance = 
2065
 
    sidl_rmi_ProtocolFactory_createInstance(url, "sidlx.rmi.SimpleTicket",
2066
 
    _ex ); SIDL_CHECK(*_ex);
 
2076
  sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance(
 
2077
    url, "sidlx.rmi.SimpleTicket", _ex ); SIDL_CHECK(*_ex);
2067
2078
  if ( instance == NULL) { return NULL; }
2068
2079
  self =
2069
2080
    (struct sidlx_rmi_SimpleTicket__object*) malloc(
2100
2111
 
2101
2112
  return self;
2102
2113
  EXIT:
2103
 
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance,
 
2114
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance, 
2104
2115
    &_throwaway_exception); }
2105
2116
  return NULL;
2106
2117
}
2117
2128
 
2118
2129
  *_ex = NULL;
2119
2130
  if(!connect_loaded) {
2120
 
    sidl_rmi_ConnectRegistry_registerConnect("sidlx.rmi.SimpleTicket",
2121
 
      (void*)sidlx_rmi_SimpleTicket__IHConnect, _ex);
 
2131
    sidl_rmi_ConnectRegistry_registerConnect("sidlx.rmi.SimpleTicket", (
 
2132
      void*)sidlx_rmi_SimpleTicket__IHConnect, _ex);
2122
2133
    connect_loaded = 1;
2123
2134
  }
2124
2135
  if (obj != NULL) {
2139
2150
 */
2140
2151
 
2141
2152
struct sidlx_rmi_SimpleTicket__object*
2142
 
sidlx_rmi_SimpleTicket__connectI(const char* url, sidl_bool ar,
2143
 
  struct sidl_BaseInterface__object **_ex)
 
2153
sidlx_rmi_SimpleTicket__connectI(const char* url, sidl_bool ar, struct 
 
2154
  sidl_BaseInterface__object **_ex)
2144
2155
{
2145
2156
  return sidlx_rmi_SimpleTicket__remoteConnect(url, ar, _ex);
2146
2157
}