← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/babel/bHYPREClient-F/bHYPRE_SStructStencil_fStub.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/bHYPREClient-F/bHYPRE_SStructStencil_fStub.c
2
2
 * File:          bHYPRE_SStructStencil_fStub.c
3
3
 * Symbol:        bHYPRE.SStructStencil-v1.0.0
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 bHYPRE.SStructStencil
7
7
 * 
8
8
 * WARNING: Automatically generated; changes will be lost
72
72
static struct bHYPRE_SStructStencil__object* 
73
73
  bHYPRE_SStructStencil__remoteCreate(const char* url, sidl_BaseInterface *_ex);
74
74
static struct bHYPRE_SStructStencil__object* 
75
 
  bHYPRE_SStructStencil__remoteConnect(const char* url, sidl_bool ar,
 
75
  bHYPRE_SStructStencil__remoteConnect(const char* url, sidl_bool ar, 
76
76
  sidl_BaseInterface *_ex);
77
 
static struct bHYPRE_SStructStencil__object* 
78
 
  bHYPRE_SStructStencil__IHConnect(struct sidl_rmi_InstanceHandle__object 
79
 
  *instance, struct sidl_BaseInterface__object **_ex);
 
77
static struct bHYPRE_SStructStencil__object* bHYPRE_SStructStencil__IHConnect(
 
78
  struct sidl_rmi_InstanceHandle__object *instance, struct 
 
79
  sidl_BaseInterface__object **_ex);
80
80
/*
81
81
 * Return pointer to internal IOR functions.
82
82
 */
88
88
#ifdef SIDL_STATIC_LIBRARY
89
89
    _ior = bHYPRE_SStructStencil__externals();
90
90
#else
91
 
    _ior = (struct 
92
 
      bHYPRE_SStructStencil__external*)sidl_dynamicLoadIOR(
 
91
    _ior = (struct bHYPRE_SStructStencil__external*)sidl_dynamicLoadIOR(
93
92
      "bHYPRE.SStructStencil","bHYPRE_SStructStencil__externals") ;
94
 
    sidl_checkIORVersion("bHYPRE.SStructStencil", _ior->d_ior_major_version,
95
 
      _ior->d_ior_minor_version, 0, 10);
 
93
    sidl_checkIORVersion("bHYPRE.SStructStencil", _ior->d_ior_major_version, 
 
94
      _ior->d_ior_minor_version, 1, 0);
96
95
#endif
97
96
  }
98
97
  return _ior;
146
145
  char* _proxy_url = NULL;
147
146
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
148
147
  _proxy_url =
149
 
    sidl_copy_fortran_str(SIDL_F77_STR(url),
 
148
    sidl_copy_fortran_str(SIDL_F77_STR(url),(ptrdiff_t)
150
149
      SIDL_F77_STR_LEN(url));
151
 
  _proxy_self = bHYPRE_SStructStencil__remoteCreate(_proxy_url,
 
150
  _proxy_self = bHYPRE_SStructStencil__remoteCreate(_proxy_url, 
152
151
    &_proxy_exception);
153
152
  if (_proxy_exception) {
154
153
    *exception = (ptrdiff_t)_proxy_exception;
172
171
)
173
172
{
174
173
  struct sidl_BaseInterface__object *_ior_exception = NULL;
175
 
  *self = (ptrdiff_t) 
176
 
    (*(_getIOR()->createObject))((void*)(ptrdiff_t)*private_data,
177
 
    &_ior_exception);
 
174
  *self = (ptrdiff_t) (*(_getIOR()->createObject))((void*)(
 
175
    ptrdiff_t)*private_data,&_ior_exception);
178
176
  *exception = (ptrdiff_t)_ior_exception;
179
177
  if (_ior_exception) *self = 0;
180
178
}
197
195
  char* _proxy_url = NULL;
198
196
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
199
197
  _proxy_url =
200
 
    sidl_copy_fortran_str(SIDL_F77_STR(url),
 
198
    sidl_copy_fortran_str(SIDL_F77_STR(url),(ptrdiff_t)
201
199
      SIDL_F77_STR_LEN(url));
202
 
  _proxy_self = bHYPRE_SStructStencil__remoteConnect(_proxy_url, 1,
 
200
  _proxy_self = bHYPRE_SStructStencil__remoteConnect(_proxy_url, 1, 
203
201
    &_proxy_exception);
204
202
  if (_proxy_exception) {
205
203
    *exception = (ptrdiff_t)_proxy_exception;
228
226
 
229
227
  *retval = 0;
230
228
  if(!connect_loaded) {
231
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructStencil",
232
 
      (void*)bHYPRE_SStructStencil__IHConnect, &proxy_exception);
 
229
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructStencil", (
 
230
      void*)bHYPRE_SStructStencil__IHConnect, &proxy_exception);
233
231
    SIDL_CHECK(proxy_exception);
234
232
    connect_loaded = 1;
235
233
  }
271
269
    (struct bHYPRE_SStructStencil__object*)
272
270
    (ptrdiff_t)(*self);
273
271
  _proxy_name =
274
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
272
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
275
273
      SIDL_F77_STR_LEN(name));
276
274
  _epv = _proxy_self->d_epv;
277
275
  _proxy_retval = 
317
315
    (struct bHYPRE_SStructStencil__object*)
318
316
    (ptrdiff_t)(*self);
319
317
  _proxy_methodName =
320
 
    sidl_copy_fortran_str(SIDL_F77_STR(methodName),
 
318
    sidl_copy_fortran_str(SIDL_F77_STR(methodName),(ptrdiff_t)
321
319
      SIDL_F77_STR_LEN(methodName));
322
320
  _proxy_inArgs =
323
321
    (struct sidl_rmi_Call__object*)
376
374
  else {
377
375
    *exception = (ptrdiff_t)NULL;
378
376
    sidl_copy_c_str(
379
 
      SIDL_F77_STR(retval),
 
377
      SIDL_F77_STR(retval),(size_t)
380
378
      SIDL_F77_STR_LEN(retval),
381
379
      _proxy_retval);
 
380
    if (_proxy_retval) free(_proxy_retval);
382
381
  }
383
 
  free((void *)_proxy_retval);
384
382
}
385
383
 
386
384
 
517
515
}
518
516
 
519
517
/*
520
 
 * Method:  Create[]
 
518
 *  This function is the preferred way to create a SStruct Stencil. 
521
519
 */
522
520
 
523
521
void
643
641
    (struct bHYPRE_SStructStencil__object*)
644
642
    (ptrdiff_t)(*self);
645
643
  offset_upper[0] = (*dim)-1;
646
 
  sidl_int__array_init(offset, _proxy_offset, 1, offset_lower, offset_upper,
 
644
  sidl_int__array_init(offset, _proxy_offset, 1, offset_lower, offset_upper, 
647
645
    offset_stride);
648
646
  _epv = _proxy_self->d_epv;
649
647
  *retval = 
660
658
  else {
661
659
    *exception = (ptrdiff_t)NULL;
662
660
  }
 
661
#ifdef SIDL_DEBUG_REFCOUNT
 
662
  sidl__array_deleteRef((struct sidl__array*)_proxy_offset);
 
663
#endif /* SIDL_DEBUG_REFCOUNT */
663
664
}
664
665
 
665
666
/*
805
806
    (struct bHYPRE_SStructStencil__object*)
806
807
    (ptrdiff_t)(*self);
807
808
  _proxy_name =
808
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
809
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
809
810
      SIDL_F77_STR_LEN(name));
810
811
  _epv = _proxy_self->d_epv;
811
812
  _proxy_retval = 
917
918
                  bHYPRE_SStructStencil__array_addRef_f)
918
919
  (int64_t *array)
919
920
{
920
 
  sidl_interface__array_addRef((struct sidl_interface__array 
921
 
    *)(ptrdiff_t)*array);
 
921
  sidl_interface__array_addRef((struct sidl_interface__array *)(
 
922
    ptrdiff_t)*array);
922
923
}
923
924
 
924
925
void
927
928
                  bHYPRE_SStructStencil__array_deleteRef_f)
928
929
  (int64_t *array)
929
930
{
930
 
  sidl_interface__array_deleteRef((struct sidl_interface__array 
931
 
    *)(ptrdiff_t)*array);
 
931
  sidl_interface__array_deleteRef((struct sidl_interface__array *)(
 
932
    ptrdiff_t)*array);
932
933
}
933
934
 
934
935
void
940
941
   int64_t *result)
941
942
{
942
943
  *result = (ptrdiff_t)
943
 
    sidl_interface__array_get1((const struct sidl_interface__array 
944
 
      *)(ptrdiff_t)*array
 
944
    sidl_interface__array_get1((const struct sidl_interface__array *)(
 
945
      ptrdiff_t)*array
945
946
    , *i1);
946
947
}
947
948
 
955
956
   int64_t *result)
956
957
{
957
958
  *result = (ptrdiff_t)
958
 
    sidl_interface__array_get2((const struct sidl_interface__array 
959
 
      *)(ptrdiff_t)*array
 
959
    sidl_interface__array_get2((const struct sidl_interface__array *)(
 
960
      ptrdiff_t)*array
960
961
    , *i1, *i2);
961
962
}
962
963
 
971
972
   int64_t *result)
972
973
{
973
974
  *result = (ptrdiff_t)
974
 
    sidl_interface__array_get3((const struct sidl_interface__array 
975
 
      *)(ptrdiff_t)*array
 
975
    sidl_interface__array_get3((const struct sidl_interface__array *)(
 
976
      ptrdiff_t)*array
976
977
    , *i1, *i2, *i3);
977
978
}
978
979
 
988
989
   int64_t *result)
989
990
{
990
991
  *result = (ptrdiff_t)
991
 
    sidl_interface__array_get4((const struct sidl_interface__array 
992
 
      *)(ptrdiff_t)*array
 
992
    sidl_interface__array_get4((const struct sidl_interface__array *)(
 
993
      ptrdiff_t)*array
993
994
    , *i1, *i2, *i3, *i4);
994
995
}
995
996
 
1006
1007
   int64_t *result)
1007
1008
{
1008
1009
  *result = (ptrdiff_t)
1009
 
    sidl_interface__array_get5((const struct sidl_interface__array 
1010
 
      *)(ptrdiff_t)*array
 
1010
    sidl_interface__array_get5((const struct sidl_interface__array *)(
 
1011
      ptrdiff_t)*array
1011
1012
    , *i1, *i2, *i3, *i4, *i5);
1012
1013
}
1013
1014
 
1025
1026
   int64_t *result)
1026
1027
{
1027
1028
  *result = (ptrdiff_t)
1028
 
    sidl_interface__array_get6((const struct sidl_interface__array 
1029
 
      *)(ptrdiff_t)*array
 
1029
    sidl_interface__array_get6((const struct sidl_interface__array *)(
 
1030
      ptrdiff_t)*array
1030
1031
    , *i1, *i2, *i3, *i4, *i5, *i6);
1031
1032
}
1032
1033
 
1045
1046
   int64_t *result)
1046
1047
{
1047
1048
  *result = (ptrdiff_t)
1048
 
    sidl_interface__array_get7((const struct sidl_interface__array 
1049
 
      *)(ptrdiff_t)*array
 
1049
    sidl_interface__array_get7((const struct sidl_interface__array *)(
 
1050
      ptrdiff_t)*array
1050
1051
    , *i1, *i2, *i3, *i4, *i5, *i6, *i7);
1051
1052
}
1052
1053
 
1059
1060
   int64_t *result)
1060
1061
{
1061
1062
  *result = (ptrdiff_t)
1062
 
    sidl_interface__array_get((const struct sidl_interface__array 
1063
 
      *)(ptrdiff_t)*array, indices);
 
1063
    sidl_interface__array_get((const struct sidl_interface__array *)(
 
1064
      ptrdiff_t)*array, indices);
1064
1065
}
1065
1066
 
1066
1067
void
1130
1131
   int64_t *value)
1131
1132
{
1132
1133
  sidl_interface__array_set5((struct sidl_interface__array *)(ptrdiff_t)*array
1133
 
  , *i1, *i2, *i3, *i4, *i5,
1134
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1134
  , *i1, *i2, *i3, *i4, *i5, (struct sidl_BaseInterface__object *)(
 
1135
    ptrdiff_t)*value);
1135
1136
}
1136
1137
 
1137
1138
void
1148
1149
   int64_t *value)
1149
1150
{
1150
1151
  sidl_interface__array_set6((struct sidl_interface__array *)(ptrdiff_t)*array
1151
 
  , *i1, *i2, *i3, *i4, *i5, *i6,
1152
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1152
  , *i1, *i2, *i3, *i4, *i5, *i6, (struct sidl_BaseInterface__object *)(
 
1153
    ptrdiff_t)*value);
1153
1154
}
1154
1155
 
1155
1156
void
1167
1168
   int64_t *value)
1168
1169
{
1169
1170
  sidl_interface__array_set7((struct sidl_interface__array *)(ptrdiff_t)*array
1170
 
  , *i1, *i2, *i3, *i4, *i5, *i6, *i7,
1171
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1171
  , *i1, *i2, *i3, *i4, *i5, *i6, *i7, (struct sidl_BaseInterface__object *)(
 
1172
    ptrdiff_t)*value);
1172
1173
}
1173
1174
 
1174
1175
void
1179
1180
  int32_t indices[],
1180
1181
  int64_t *value)
1181
1182
{
1182
 
  sidl_interface__array_set((struct sidl_interface__array *)(ptrdiff_t)*array,
 
1183
  sidl_interface__array_set((struct sidl_interface__array *)(ptrdiff_t)*array, 
1183
1184
    indices, (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
1184
1185
}
1185
1186
 
1190
1191
  (int64_t *array, int32_t *result)
1191
1192
{
1192
1193
  *result =
1193
 
    sidl_interface__array_dimen((struct sidl_interface__array 
1194
 
      *)(ptrdiff_t)*array);
 
1194
    sidl_interface__array_dimen((struct sidl_interface__array *)(
 
1195
      ptrdiff_t)*array);
1195
1196
}
1196
1197
 
1197
1198
void
1203
1204
   int32_t *result)
1204
1205
{
1205
1206
  *result = 
1206
 
    sidl_interface__array_lower((struct sidl_interface__array 
1207
 
      *)(ptrdiff_t)*array, *ind);
 
1207
    sidl_interface__array_lower((struct sidl_interface__array *)(
 
1208
      ptrdiff_t)*array, *ind);
1208
1209
}
1209
1210
 
1210
1211
void
1216
1217
   int32_t *result)
1217
1218
{
1218
1219
  *result = 
1219
 
    sidl_interface__array_upper((struct sidl_interface__array 
1220
 
      *)(ptrdiff_t)*array, *ind);
 
1220
    sidl_interface__array_upper((struct sidl_interface__array *)(
 
1221
      ptrdiff_t)*array, *ind);
1221
1222
}
1222
1223
 
1223
1224
void
1229
1230
   int32_t *result)
1230
1231
{
1231
1232
  *result = 
1232
 
    sidl_interface__array_length((struct sidl_interface__array 
1233
 
      *)(ptrdiff_t)*array, *ind);
 
1233
    sidl_interface__array_length((struct sidl_interface__array *)(
 
1234
      ptrdiff_t)*array, *ind);
1234
1235
}
1235
1236
 
1236
1237
void
1242
1243
   int32_t *result)
1243
1244
{
1244
1245
  *result = 
1245
 
    sidl_interface__array_stride((struct sidl_interface__array 
1246
 
      *)(ptrdiff_t)*array, *ind);
 
1246
    sidl_interface__array_stride((struct sidl_interface__array *)(
 
1247
      ptrdiff_t)*array, *ind);
1247
1248
}
1248
1249
 
1249
1250
void
1264
1265
  (int64_t *array,
1265
1266
   SIDL_F77_Bool *result)
1266
1267
{
1267
 
  *result = sidl_interface__array_isRowOrder((struct sidl_interface__array 
1268
 
    *)(ptrdiff_t)*array);
 
1268
  *result = sidl_interface__array_isRowOrder((struct sidl_interface__array *)(
 
1269
    ptrdiff_t)*array);
1269
1270
}
1270
1271
 
1271
1272
void
1275
1276
  (int64_t *src,
1276
1277
   int64_t *dest)
1277
1278
{
1278
 
  sidl_interface__array_copy((const struct sidl_interface__array 
1279
 
    *)(ptrdiff_t)*src,
 
1279
  sidl_interface__array_copy((const struct sidl_interface__array *)(
 
1280
    ptrdiff_t)*src,
1280
1281
                             (struct sidl_interface__array *)(ptrdiff_t)*dest);
1281
1282
}
1282
1283
 
1286
1287
                  bHYPRE_SStructStencil__array_smartCopy_f)
1287
1288
  (int64_t *src)
1288
1289
{
1289
 
  sidl_interface__array_smartCopy((struct sidl_interface__array 
1290
 
    *)(ptrdiff_t)*src);
 
1290
  sidl_interface__array_smartCopy((struct sidl_interface__array *)(
 
1291
    ptrdiff_t)*src);
1291
1292
}
1292
1293
 
1293
1294
void
1317
1318
   int64_t *result)
1318
1319
{
1319
1320
  *result = (ptrdiff_t)
1320
 
    sidl_interface__array_ensure((struct sidl_interface__array 
1321
 
      *)(ptrdiff_t)*src,
 
1321
    sidl_interface__array_ensure((struct sidl_interface__array *)(
 
1322
      ptrdiff_t)*src,
1322
1323
    *dimen, *ordering);
1323
1324
}
1324
1325
 
1373
1374
#endif
1374
1375
 
1375
1376
/* Static variables to hold version of IOR */
1376
 
static const int32_t s_IOR_MAJOR_VERSION = 0;
1377
 
static const int32_t s_IOR_MINOR_VERSION = 10;
 
1377
static const int32_t s_IOR_MAJOR_VERSION = 1;
 
1378
static const int32_t s_IOR_MINOR_VERSION = 0;
1378
1379
 
1379
1380
/* Static variables for managing EPV initialization. */
1380
1381
static int s_remote_initialized = 0;
1399
1400
  cmp0 = strcmp(name, "sidl.BaseClass");
1400
1401
  if (!cmp0) {
1401
1402
    (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
1402
 
    cast = self;
 
1403
    cast = ((struct sidl_BaseClass__object*)self);
1403
1404
    return cast;
1404
1405
  }
1405
1406
  else if (cmp0 < 0) {
1406
1407
    cmp1 = strcmp(name, "bHYPRE.SStructStencil");
1407
1408
    if (!cmp1) {
1408
1409
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
1409
 
      cast = self;
 
1410
      cast = ((struct bHYPRE_SStructStencil__object*)self);
1410
1411
      return cast;
1411
1412
    }
1412
1413
  }
1419
1420
    }
1420
1421
  }
1421
1422
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
1422
 
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,
1423
 
      struct sidl_BaseInterface__object**) = 
1424
 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,
1425
 
        struct sidl_BaseInterface__object**)) 
 
1423
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1424
      sidl_BaseInterface__object**) = 
 
1425
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1426
        sidl_BaseInterface__object**)) 
1426
1427
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
1427
1428
    cast =  (*func)(((struct bHYPRE_SStructStencil__remote*)self->d_data)->d_ih,
1428
1429
      _ex);
1465
1466
  struct sidl_rmi_InstanceHandle__object *_conn = ((struct 
1466
1467
    bHYPRE_SStructStencil__remote*)self->d_data)->d_ih;
1467
1468
  sidl_rmi_Response _rsvp = NULL;
1468
 
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1469
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1469
1470
    "addRef", _ex ); SIDL_CHECK(*_ex);
1470
1471
  /* send actual RMI request */
1471
1472
  _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
1510
1511
    sidl_rmi_Response _rsvp = NULL;
1511
1512
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1512
1513
      bHYPRE_SStructStencil__remote*)self->d_data)->d_ih;
1513
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1514
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1514
1515
      "_set_hooks", _ex ); SIDL_CHECK(*_ex);
1515
1516
 
1516
1517
    /* pack in and inout arguments */
1563
1564
    sidl_rmi_Response _rsvp = NULL;
1564
1565
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1565
1566
      bHYPRE_SStructStencil__remote*)self->d_data)->d_ih;
1566
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1567
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1567
1568
      "Destroy", _ex ); SIDL_CHECK(*_ex);
1568
1569
 
1569
1570
    /* pack in and inout arguments */
1608
1609
    int32_t _retval = 0;
1609
1610
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1610
1611
      bHYPRE_SStructStencil__remote*)self->d_data)->d_ih;
1611
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1612
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1612
1613
      "SetNumDimSize", _ex ); SIDL_CHECK(*_ex);
1613
1614
 
1614
1615
    /* pack in and inout arguments */
1628
1629
    }
1629
1630
 
1630
1631
    /* extract return value */
1631
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1632
 
      _ex);SIDL_CHECK(*_ex);
 
1632
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1633
      *_ex);
1633
1634
 
1634
1635
    /* unpack out and inout arguments */
1635
1636
 
1660
1661
    int32_t _retval = 0;
1661
1662
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1662
1663
      bHYPRE_SStructStencil__remote*)self->d_data)->d_ih;
1663
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1664
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1664
1665
      "SetEntry", _ex ); SIDL_CHECK(*_ex);
1665
1666
 
1666
1667
    /* pack in and inout arguments */
1682
1683
    }
1683
1684
 
1684
1685
    /* extract return value */
1685
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1686
 
      _ex);SIDL_CHECK(*_ex);
 
1686
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1687
      *_ex);
1687
1688
 
1688
1689
    /* unpack out and inout arguments */
1689
1690
 
1751
1752
    sidl_bool _retval = FALSE;
1752
1753
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1753
1754
      bHYPRE_SStructStencil__remote*)self->d_data)->d_ih;
1754
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1755
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1755
1756
      "isSame", _ex ); SIDL_CHECK(*_ex);
1756
1757
 
1757
1758
    /* pack in and inout arguments */
1758
1759
    if(iobj){
1759
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,
 
1760
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj, 
1760
1761
        _ex);SIDL_CHECK(*_ex);
1761
1762
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(*_ex);
1762
1763
      free((void*)_url);
1777
1778
    }
1778
1779
 
1779
1780
    /* extract return value */
1780
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1781
 
      _ex);SIDL_CHECK(*_ex);
 
1781
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1782
      *_ex);
1782
1783
 
1783
1784
    /* unpack out and inout arguments */
1784
1785
 
1807
1808
    sidl_bool _retval = FALSE;
1808
1809
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1809
1810
      bHYPRE_SStructStencil__remote*)self->d_data)->d_ih;
1810
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1811
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1811
1812
      "isType", _ex ); SIDL_CHECK(*_ex);
1812
1813
 
1813
1814
    /* pack in and inout arguments */
1826
1827
    }
1827
1828
 
1828
1829
    /* extract return value */
1829
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1830
 
      _ex);SIDL_CHECK(*_ex);
 
1830
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1831
      *_ex);
1831
1832
 
1832
1833
    /* unpack out and inout arguments */
1833
1834
 
1856
1857
    struct sidl_ClassInfo__object* _retval = 0;
1857
1858
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1858
1859
      bHYPRE_SStructStencil__remote*)self->d_data)->d_ih;
1859
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1860
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1860
1861
      "getClassInfo", _ex ); SIDL_CHECK(*_ex);
1861
1862
 
1862
1863
    /* pack in and inout arguments */
1874
1875
    }
1875
1876
 
1876
1877
    /* extract return value */
1877
 
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
1878
 
      _ex);SIDL_CHECK(*_ex);
1879
 
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,
1880
 
      _ex);SIDL_CHECK(*_ex);
 
1878
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
1879
      _ex);SIDL_CHECK(*_ex);
 
1880
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
1881
      *_ex);
1881
1882
 
1882
1883
    /* unpack out and inout arguments */
1883
1884
 
1926
1927
    sidl_BaseInterface*)) epv->f__raddRef;
1927
1928
  e0->f__isRemote    = (sidl_bool (*)(struct sidl_BaseClass__object*,
1928
1929
    sidl_BaseInterface*)) epv->f__isRemote;
1929
 
  e0->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t,
 
1930
  e0->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t, 
1930
1931
    sidl_BaseInterface*)) epv->f__set_hooks;
1931
1932
  e0->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,
1932
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
1933
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1934
 
  e0->f_addRef       = (void (*)(struct sidl_BaseClass__object*,
1935
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1936
 
  e0->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,
1937
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1938
 
  e0->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,
1939
 
    struct sidl_BaseInterface__object*,
1940
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1941
 
  e0->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,
1942
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
1933
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
1934
    sidl_BaseInterface__object **)) epv->f__exec;
 
1935
  e0->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct 
 
1936
    sidl_BaseInterface__object **)) epv->f_addRef;
 
1937
  e0->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct 
 
1938
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1939
  e0->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct 
 
1940
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
1941
    epv->f_isSame;
 
1942
  e0->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const 
 
1943
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
1943
1944
  e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
1944
 
    sidl_BaseClass__object*,
1945
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1945
    sidl_BaseClass__object*,struct sidl_BaseInterface__object **)) 
 
1946
    epv->f_getClassInfo;
1946
1947
 
1947
 
  e1->f__cast        = (void* (*)(void*,const char*,
1948
 
    sidl_BaseInterface*)) epv->f__cast;
 
1948
  e1->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
1949
    epv->f__cast;
1949
1950
  e1->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
1950
1951
  e1->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
1951
1952
  e1->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
1952
 
  e1->f__isRemote    = (sidl_bool (*)(void*,
1953
 
    sidl_BaseInterface*)) epv->f__isRemote;
1954
 
  e1->f__set_hooks   = (void (*)(void*,int32_t,
1955
 
    sidl_BaseInterface*)) epv->f__set_hooks;
1956
 
  e1->f__exec        = (void (*)(void*,const char*,
1957
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
1958
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1959
 
  e1->f_addRef       = (void (*)(void*,
1960
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1961
 
  e1->f_deleteRef    = (void (*)(void*,
1962
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1953
  e1->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
1954
    epv->f__isRemote;
 
1955
  e1->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
1956
    epv->f__set_hooks;
 
1957
  e1->f__exec        = (void (*)(void*,const char*,struct 
 
1958
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
1959
    sidl_BaseInterface__object **)) epv->f__exec;
 
1960
  e1->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
1961
    epv->f_addRef;
 
1962
  e1->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
1963
    epv->f_deleteRef;
1963
1964
  e1->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
1964
1965
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1965
 
  e1->f_isType       = (sidl_bool (*)(void*,const char*,
1966
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
1967
 
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
1968
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1966
  e1->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
1967
    sidl_BaseInterface__object **)) epv->f_isType;
 
1968
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
1969
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
1969
1970
 
1970
1971
  s_remote_initialized = 1;
1971
1972
}
1972
1973
 
1973
1974
/* Create an instance that connects to an existing remote object. */
1974
1975
static struct bHYPRE_SStructStencil__object*
1975
 
bHYPRE_SStructStencil__remoteConnect(const char *url, sidl_bool ar,
 
1976
bHYPRE_SStructStencil__remoteConnect(const char *url, sidl_bool ar, 
1976
1977
  sidl_BaseInterface *_ex)
1977
1978
{
1978
1979
  struct bHYPRE_SStructStencil__object* self;
1988
1989
  if(url == NULL) {return NULL;}
1989
1990
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
1990
1991
  if(objectID) {
1991
 
    sidl_BaseInterface bi = 
1992
 
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
1993
 
      objectID, _ex); SIDL_CHECK(*_ex);
 
1992
    sidl_BaseInterface bi = (
 
1993
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(objectID,
 
1994
      _ex); SIDL_CHECK(*_ex);
1994
1995
    return bHYPRE_SStructStencil__rmicast(bi,_ex);SIDL_CHECK(*_ex);
1995
1996
  }
1996
 
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar,
1997
 
    _ex ); SIDL_CHECK(*_ex);
 
1997
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex ); 
 
1998
    SIDL_CHECK(*_ex);
1998
1999
  if ( instance == NULL) { return NULL; }
1999
2000
  self =
2000
2001
    (struct bHYPRE_SStructStencil__object*) malloc(
2033
2034
/* Create an instance that uses an already existing  */
2034
2035
/* InstanceHandle to connect to an existing remote object. */
2035
2036
static struct bHYPRE_SStructStencil__object*
2036
 
bHYPRE_SStructStencil__IHConnect(sidl_rmi_InstanceHandle instance,
 
2037
bHYPRE_SStructStencil__IHConnect(sidl_rmi_InstanceHandle instance, 
2037
2038
  sidl_BaseInterface *_ex)
2038
2039
{
2039
2040
  struct bHYPRE_SStructStencil__object* self;
2088
2089
  struct sidl_BaseClass__object* s1;
2089
2090
 
2090
2091
  struct bHYPRE_SStructStencil__remote* r_obj;
2091
 
  sidl_rmi_InstanceHandle instance = 
2092
 
    sidl_rmi_ProtocolFactory_createInstance(url, "bHYPRE.SStructStencil",
2093
 
    _ex ); SIDL_CHECK(*_ex);
 
2092
  sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance(
 
2093
    url, "bHYPRE.SStructStencil", _ex ); SIDL_CHECK(*_ex);
2094
2094
  if ( instance == NULL) { return NULL; }
2095
2095
  self =
2096
2096
    (struct bHYPRE_SStructStencil__object*) malloc(
2124
2124
 
2125
2125
  return self;
2126
2126
  EXIT:
2127
 
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance,
 
2127
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance, 
2128
2128
    &_throwaway_exception); }
2129
2129
  return NULL;
2130
2130
}
2141
2141
 
2142
2142
  *_ex = NULL;
2143
2143
  if(!connect_loaded) {
2144
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructStencil",
2145
 
      (void*)bHYPRE_SStructStencil__IHConnect, _ex);
 
2144
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructStencil", (
 
2145
      void*)bHYPRE_SStructStencil__IHConnect, _ex);
2146
2146
    connect_loaded = 1;
2147
2147
  }
2148
2148
  if (obj != NULL) {
2163
2163
 */
2164
2164
 
2165
2165
struct bHYPRE_SStructStencil__object*
2166
 
bHYPRE_SStructStencil__connectI(const char* url, sidl_bool ar,
2167
 
  struct sidl_BaseInterface__object **_ex)
 
2166
bHYPRE_SStructStencil__connectI(const char* url, sidl_bool ar, struct 
 
2167
  sidl_BaseInterface__object **_ex)
2168
2168
{
2169
2169
  return bHYPRE_SStructStencil__remoteConnect(url, ar, _ex);
2170
2170
}