← 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_StructGrid_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_StructGrid_fStub.c
2
2
 * File:          bHYPRE_StructGrid_fStub.c
3
3
 * Symbol:        bHYPRE.StructGrid-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.StructGrid
7
7
 * 
8
8
 * WARNING: Automatically generated; changes will be lost
78
78
static struct bHYPRE_StructGrid__object* bHYPRE_StructGrid__remoteConnect(const 
79
79
  char* url, sidl_bool ar, sidl_BaseInterface *_ex);
80
80
static struct bHYPRE_StructGrid__object* bHYPRE_StructGrid__IHConnect(struct 
81
 
  sidl_rmi_InstanceHandle__object *instance,
82
 
  struct sidl_BaseInterface__object **_ex);
 
81
  sidl_rmi_InstanceHandle__object *instance, struct sidl_BaseInterface__object 
 
82
  **_ex);
83
83
/*
84
84
 * Return pointer to internal IOR functions.
85
85
 */
91
91
#ifdef SIDL_STATIC_LIBRARY
92
92
    _ior = bHYPRE_StructGrid__externals();
93
93
#else
94
 
    _ior = (struct 
95
 
      bHYPRE_StructGrid__external*)sidl_dynamicLoadIOR("bHYPRE.StructGrid",
96
 
      "bHYPRE_StructGrid__externals") ;
97
 
    sidl_checkIORVersion("bHYPRE.StructGrid", _ior->d_ior_major_version,
98
 
      _ior->d_ior_minor_version, 0, 10);
 
94
    _ior = (struct bHYPRE_StructGrid__external*)sidl_dynamicLoadIOR(
 
95
      "bHYPRE.StructGrid","bHYPRE_StructGrid__externals") ;
 
96
    sidl_checkIORVersion("bHYPRE.StructGrid", _ior->d_ior_major_version, 
 
97
      _ior->d_ior_minor_version, 1, 0);
99
98
#endif
100
99
  }
101
100
  return _ior;
149
148
  char* _proxy_url = NULL;
150
149
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
151
150
  _proxy_url =
152
 
    sidl_copy_fortran_str(SIDL_F77_STR(url),
 
151
    sidl_copy_fortran_str(SIDL_F77_STR(url),(ptrdiff_t)
153
152
      SIDL_F77_STR_LEN(url));
154
153
  _proxy_self = bHYPRE_StructGrid__remoteCreate(_proxy_url, &_proxy_exception);
155
154
  if (_proxy_exception) {
174
173
)
175
174
{
176
175
  struct sidl_BaseInterface__object *_ior_exception = NULL;
177
 
  *self = (ptrdiff_t) 
178
 
    (*(_getIOR()->createObject))((void*)(ptrdiff_t)*private_data,
179
 
    &_ior_exception);
 
176
  *self = (ptrdiff_t) (*(_getIOR()->createObject))((void*)(
 
177
    ptrdiff_t)*private_data,&_ior_exception);
180
178
  *exception = (ptrdiff_t)_ior_exception;
181
179
  if (_ior_exception) *self = 0;
182
180
}
199
197
  char* _proxy_url = NULL;
200
198
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
201
199
  _proxy_url =
202
 
    sidl_copy_fortran_str(SIDL_F77_STR(url),
 
200
    sidl_copy_fortran_str(SIDL_F77_STR(url),(ptrdiff_t)
203
201
      SIDL_F77_STR_LEN(url));
204
 
  _proxy_self = bHYPRE_StructGrid__remoteConnect(_proxy_url, 1,
 
202
  _proxy_self = bHYPRE_StructGrid__remoteConnect(_proxy_url, 1, 
205
203
    &_proxy_exception);
206
204
  if (_proxy_exception) {
207
205
    *exception = (ptrdiff_t)_proxy_exception;
230
228
 
231
229
  *retval = 0;
232
230
  if(!connect_loaded) {
233
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.StructGrid",
234
 
      (void*)bHYPRE_StructGrid__IHConnect, &proxy_exception);
 
231
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.StructGrid", (
 
232
      void*)bHYPRE_StructGrid__IHConnect, &proxy_exception);
235
233
    SIDL_CHECK(proxy_exception);
236
234
    connect_loaded = 1;
237
235
  }
273
271
    (struct bHYPRE_StructGrid__object*)
274
272
    (ptrdiff_t)(*self);
275
273
  _proxy_name =
276
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
274
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
277
275
      SIDL_F77_STR_LEN(name));
278
276
  _epv = _proxy_self->d_epv;
279
277
  _proxy_retval = 
319
317
    (struct bHYPRE_StructGrid__object*)
320
318
    (ptrdiff_t)(*self);
321
319
  _proxy_methodName =
322
 
    sidl_copy_fortran_str(SIDL_F77_STR(methodName),
 
320
    sidl_copy_fortran_str(SIDL_F77_STR(methodName),(ptrdiff_t)
323
321
      SIDL_F77_STR_LEN(methodName));
324
322
  _proxy_inArgs =
325
323
    (struct sidl_rmi_Call__object*)
378
376
  else {
379
377
    *exception = (ptrdiff_t)NULL;
380
378
    sidl_copy_c_str(
381
 
      SIDL_F77_STR(retval),
 
379
      SIDL_F77_STR(retval),(size_t)
382
380
      SIDL_F77_STR_LEN(retval),
383
381
      _proxy_retval);
 
382
    if (_proxy_retval) free(_proxy_retval);
384
383
  }
385
 
  free((void *)_proxy_retval);
386
384
}
387
385
 
388
386
 
519
517
}
520
518
 
521
519
/*
522
 
 * Method:  Create[]
 
520
 *  This function is the preferred way to create a Struct Grid. 
523
521
 */
524
522
 
525
523
void
660
658
}
661
659
 
662
660
/*
663
 
 * Method:  SetExtents[]
 
661
 *  Define the lower and upper corners of a box of the grid.
 
662
 * "ilower" and "iupper" are arrays of size "dim", the number of spatial
 
663
 * dimensions. 
664
664
 */
665
665
 
666
666
void
687
687
    (struct bHYPRE_StructGrid__object*)
688
688
    (ptrdiff_t)(*self);
689
689
  ilower_upper[0] = (*dim)-1;
690
 
  sidl_int__array_init(ilower, _proxy_ilower, 1, ilower_lower, ilower_upper,
 
690
  sidl_int__array_init(ilower, _proxy_ilower, 1, ilower_lower, ilower_upper, 
691
691
    ilower_stride);
692
692
  iupper_upper[0] = (*dim)-1;
693
 
  sidl_int__array_init(iupper, _proxy_iupper, 1, iupper_lower, iupper_upper,
 
693
  sidl_int__array_init(iupper, _proxy_iupper, 1, iupper_lower, iupper_upper, 
694
694
    iupper_stride);
695
695
  _epv = _proxy_self->d_epv;
696
696
  *retval = 
706
706
  else {
707
707
    *exception = (ptrdiff_t)NULL;
708
708
  }
 
709
#ifdef SIDL_DEBUG_REFCOUNT
 
710
  sidl__array_deleteRef((struct sidl__array*)_proxy_ilower);
 
711
  sidl__array_deleteRef((struct sidl__array*)_proxy_iupper);
 
712
#endif /* SIDL_DEBUG_REFCOUNT */
709
713
}
710
714
 
711
715
/*
712
 
 * Method:  SetPeriodic[]
 
716
 *  Set the periodicity for the grid.  Default is no periodicity.
 
717
 * 
 
718
 * The argument {\tt periodic} is an {\tt dim}-dimensional integer array that
 
719
 * contains the periodicity for each dimension.  A zero value for a dimension
 
720
 * means non-periodic, while a nonzero value means periodic and contains the
 
721
 * actual period.  For example, periodicity in the first and third dimensions
 
722
 * for a 10x11x12 grid is indicated by the array [10,0,12].
 
723
 * 
 
724
 * NOTE: Some of the solvers in hypre have power-of-two restrictions on the size
 
725
 * of the periodic dimensions.
713
726
 */
714
727
 
715
728
void
732
745
    (struct bHYPRE_StructGrid__object*)
733
746
    (ptrdiff_t)(*self);
734
747
  periodic_upper[0] = (*dim)-1;
735
 
  sidl_int__array_init(periodic, _proxy_periodic, 1, periodic_lower,
 
748
  sidl_int__array_init(periodic, _proxy_periodic, 1, periodic_lower, 
736
749
    periodic_upper, periodic_stride);
737
750
  _epv = _proxy_self->d_epv;
738
751
  *retval = 
747
760
  else {
748
761
    *exception = (ptrdiff_t)NULL;
749
762
  }
 
763
#ifdef SIDL_DEBUG_REFCOUNT
 
764
  sidl__array_deleteRef((struct sidl__array*)_proxy_periodic);
 
765
#endif /* SIDL_DEBUG_REFCOUNT */
750
766
}
751
767
 
752
768
/*
753
 
 * Method:  SetNumGhost[]
 
769
 *  Set the number of ghost zones, separately on the lower and upper sides
 
770
 * for each dimension.
 
771
 * "num_ghost" is an array of size "dim2", twice the number of dimensions. 
754
772
 */
755
773
 
756
774
void
773
791
    (struct bHYPRE_StructGrid__object*)
774
792
    (ptrdiff_t)(*self);
775
793
  num_ghost_upper[0] = (*dim2)-1;
776
 
  sidl_int__array_init(num_ghost, _proxy_num_ghost, 1, num_ghost_lower,
 
794
  sidl_int__array_init(num_ghost, _proxy_num_ghost, 1, num_ghost_lower, 
777
795
    num_ghost_upper, num_ghost_stride);
778
796
  _epv = _proxy_self->d_epv;
779
797
  *retval = 
788
806
  else {
789
807
    *exception = (ptrdiff_t)NULL;
790
808
  }
 
809
#ifdef SIDL_DEBUG_REFCOUNT
 
810
  sidl__array_deleteRef((struct sidl__array*)_proxy_num_ghost);
 
811
#endif /* SIDL_DEBUG_REFCOUNT */
791
812
}
792
813
 
793
814
/*
794
 
 * Method:  Assemble[]
 
815
 *  final construction of the object before its use 
795
816
 */
796
817
 
797
818
void
965
986
    (struct bHYPRE_StructGrid__object*)
966
987
    (ptrdiff_t)(*self);
967
988
  _proxy_name =
968
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
989
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
969
990
      SIDL_F77_STR_LEN(name));
970
991
  _epv = _proxy_self->d_epv;
971
992
  _proxy_retval = 
1077
1098
                  bHYPRE_StructGrid__array_addRef_f)
1078
1099
  (int64_t *array)
1079
1100
{
1080
 
  sidl_interface__array_addRef((struct sidl_interface__array 
1081
 
    *)(ptrdiff_t)*array);
 
1101
  sidl_interface__array_addRef((struct sidl_interface__array *)(
 
1102
    ptrdiff_t)*array);
1082
1103
}
1083
1104
 
1084
1105
void
1087
1108
                  bHYPRE_StructGrid__array_deleteRef_f)
1088
1109
  (int64_t *array)
1089
1110
{
1090
 
  sidl_interface__array_deleteRef((struct sidl_interface__array 
1091
 
    *)(ptrdiff_t)*array);
 
1111
  sidl_interface__array_deleteRef((struct sidl_interface__array *)(
 
1112
    ptrdiff_t)*array);
1092
1113
}
1093
1114
 
1094
1115
void
1100
1121
   int64_t *result)
1101
1122
{
1102
1123
  *result = (ptrdiff_t)
1103
 
    sidl_interface__array_get1((const struct sidl_interface__array 
1104
 
      *)(ptrdiff_t)*array
 
1124
    sidl_interface__array_get1((const struct sidl_interface__array *)(
 
1125
      ptrdiff_t)*array
1105
1126
    , *i1);
1106
1127
}
1107
1128
 
1115
1136
   int64_t *result)
1116
1137
{
1117
1138
  *result = (ptrdiff_t)
1118
 
    sidl_interface__array_get2((const struct sidl_interface__array 
1119
 
      *)(ptrdiff_t)*array
 
1139
    sidl_interface__array_get2((const struct sidl_interface__array *)(
 
1140
      ptrdiff_t)*array
1120
1141
    , *i1, *i2);
1121
1142
}
1122
1143
 
1131
1152
   int64_t *result)
1132
1153
{
1133
1154
  *result = (ptrdiff_t)
1134
 
    sidl_interface__array_get3((const struct sidl_interface__array 
1135
 
      *)(ptrdiff_t)*array
 
1155
    sidl_interface__array_get3((const struct sidl_interface__array *)(
 
1156
      ptrdiff_t)*array
1136
1157
    , *i1, *i2, *i3);
1137
1158
}
1138
1159
 
1148
1169
   int64_t *result)
1149
1170
{
1150
1171
  *result = (ptrdiff_t)
1151
 
    sidl_interface__array_get4((const struct sidl_interface__array 
1152
 
      *)(ptrdiff_t)*array
 
1172
    sidl_interface__array_get4((const struct sidl_interface__array *)(
 
1173
      ptrdiff_t)*array
1153
1174
    , *i1, *i2, *i3, *i4);
1154
1175
}
1155
1176
 
1166
1187
   int64_t *result)
1167
1188
{
1168
1189
  *result = (ptrdiff_t)
1169
 
    sidl_interface__array_get5((const struct sidl_interface__array 
1170
 
      *)(ptrdiff_t)*array
 
1190
    sidl_interface__array_get5((const struct sidl_interface__array *)(
 
1191
      ptrdiff_t)*array
1171
1192
    , *i1, *i2, *i3, *i4, *i5);
1172
1193
}
1173
1194
 
1185
1206
   int64_t *result)
1186
1207
{
1187
1208
  *result = (ptrdiff_t)
1188
 
    sidl_interface__array_get6((const struct sidl_interface__array 
1189
 
      *)(ptrdiff_t)*array
 
1209
    sidl_interface__array_get6((const struct sidl_interface__array *)(
 
1210
      ptrdiff_t)*array
1190
1211
    , *i1, *i2, *i3, *i4, *i5, *i6);
1191
1212
}
1192
1213
 
1205
1226
   int64_t *result)
1206
1227
{
1207
1228
  *result = (ptrdiff_t)
1208
 
    sidl_interface__array_get7((const struct sidl_interface__array 
1209
 
      *)(ptrdiff_t)*array
 
1229
    sidl_interface__array_get7((const struct sidl_interface__array *)(
 
1230
      ptrdiff_t)*array
1210
1231
    , *i1, *i2, *i3, *i4, *i5, *i6, *i7);
1211
1232
}
1212
1233
 
1219
1240
   int64_t *result)
1220
1241
{
1221
1242
  *result = (ptrdiff_t)
1222
 
    sidl_interface__array_get((const struct sidl_interface__array 
1223
 
      *)(ptrdiff_t)*array, indices);
 
1243
    sidl_interface__array_get((const struct sidl_interface__array *)(
 
1244
      ptrdiff_t)*array, indices);
1224
1245
}
1225
1246
 
1226
1247
void
1290
1311
   int64_t *value)
1291
1312
{
1292
1313
  sidl_interface__array_set5((struct sidl_interface__array *)(ptrdiff_t)*array
1293
 
  , *i1, *i2, *i3, *i4, *i5,
1294
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1314
  , *i1, *i2, *i3, *i4, *i5, (struct sidl_BaseInterface__object *)(
 
1315
    ptrdiff_t)*value);
1295
1316
}
1296
1317
 
1297
1318
void
1308
1329
   int64_t *value)
1309
1330
{
1310
1331
  sidl_interface__array_set6((struct sidl_interface__array *)(ptrdiff_t)*array
1311
 
  , *i1, *i2, *i3, *i4, *i5, *i6,
1312
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1332
  , *i1, *i2, *i3, *i4, *i5, *i6, (struct sidl_BaseInterface__object *)(
 
1333
    ptrdiff_t)*value);
1313
1334
}
1314
1335
 
1315
1336
void
1327
1348
   int64_t *value)
1328
1349
{
1329
1350
  sidl_interface__array_set7((struct sidl_interface__array *)(ptrdiff_t)*array
1330
 
  , *i1, *i2, *i3, *i4, *i5, *i6, *i7,
1331
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1351
  , *i1, *i2, *i3, *i4, *i5, *i6, *i7, (struct sidl_BaseInterface__object *)(
 
1352
    ptrdiff_t)*value);
1332
1353
}
1333
1354
 
1334
1355
void
1339
1360
  int32_t indices[],
1340
1361
  int64_t *value)
1341
1362
{
1342
 
  sidl_interface__array_set((struct sidl_interface__array *)(ptrdiff_t)*array,
 
1363
  sidl_interface__array_set((struct sidl_interface__array *)(ptrdiff_t)*array, 
1343
1364
    indices, (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
1344
1365
}
1345
1366
 
1350
1371
  (int64_t *array, int32_t *result)
1351
1372
{
1352
1373
  *result =
1353
 
    sidl_interface__array_dimen((struct sidl_interface__array 
1354
 
      *)(ptrdiff_t)*array);
 
1374
    sidl_interface__array_dimen((struct sidl_interface__array *)(
 
1375
      ptrdiff_t)*array);
1355
1376
}
1356
1377
 
1357
1378
void
1363
1384
   int32_t *result)
1364
1385
{
1365
1386
  *result = 
1366
 
    sidl_interface__array_lower((struct sidl_interface__array 
1367
 
      *)(ptrdiff_t)*array, *ind);
 
1387
    sidl_interface__array_lower((struct sidl_interface__array *)(
 
1388
      ptrdiff_t)*array, *ind);
1368
1389
}
1369
1390
 
1370
1391
void
1376
1397
   int32_t *result)
1377
1398
{
1378
1399
  *result = 
1379
 
    sidl_interface__array_upper((struct sidl_interface__array 
1380
 
      *)(ptrdiff_t)*array, *ind);
 
1400
    sidl_interface__array_upper((struct sidl_interface__array *)(
 
1401
      ptrdiff_t)*array, *ind);
1381
1402
}
1382
1403
 
1383
1404
void
1389
1410
   int32_t *result)
1390
1411
{
1391
1412
  *result = 
1392
 
    sidl_interface__array_length((struct sidl_interface__array 
1393
 
      *)(ptrdiff_t)*array, *ind);
 
1413
    sidl_interface__array_length((struct sidl_interface__array *)(
 
1414
      ptrdiff_t)*array, *ind);
1394
1415
}
1395
1416
 
1396
1417
void
1402
1423
   int32_t *result)
1403
1424
{
1404
1425
  *result = 
1405
 
    sidl_interface__array_stride((struct sidl_interface__array 
1406
 
      *)(ptrdiff_t)*array, *ind);
 
1426
    sidl_interface__array_stride((struct sidl_interface__array *)(
 
1427
      ptrdiff_t)*array, *ind);
1407
1428
}
1408
1429
 
1409
1430
void
1424
1445
  (int64_t *array,
1425
1446
   SIDL_F77_Bool *result)
1426
1447
{
1427
 
  *result = sidl_interface__array_isRowOrder((struct sidl_interface__array 
1428
 
    *)(ptrdiff_t)*array);
 
1448
  *result = sidl_interface__array_isRowOrder((struct sidl_interface__array *)(
 
1449
    ptrdiff_t)*array);
1429
1450
}
1430
1451
 
1431
1452
void
1435
1456
  (int64_t *src,
1436
1457
   int64_t *dest)
1437
1458
{
1438
 
  sidl_interface__array_copy((const struct sidl_interface__array 
1439
 
    *)(ptrdiff_t)*src,
 
1459
  sidl_interface__array_copy((const struct sidl_interface__array *)(
 
1460
    ptrdiff_t)*src,
1440
1461
                             (struct sidl_interface__array *)(ptrdiff_t)*dest);
1441
1462
}
1442
1463
 
1446
1467
                  bHYPRE_StructGrid__array_smartCopy_f)
1447
1468
  (int64_t *src)
1448
1469
{
1449
 
  sidl_interface__array_smartCopy((struct sidl_interface__array 
1450
 
    *)(ptrdiff_t)*src);
 
1470
  sidl_interface__array_smartCopy((struct sidl_interface__array *)(
 
1471
    ptrdiff_t)*src);
1451
1472
}
1452
1473
 
1453
1474
void
1477
1498
   int64_t *result)
1478
1499
{
1479
1500
  *result = (ptrdiff_t)
1480
 
    sidl_interface__array_ensure((struct sidl_interface__array 
1481
 
      *)(ptrdiff_t)*src,
 
1501
    sidl_interface__array_ensure((struct sidl_interface__array *)(
 
1502
      ptrdiff_t)*src,
1482
1503
    *dimen, *ordering);
1483
1504
}
1484
1505
 
1533
1554
#endif
1534
1555
 
1535
1556
/* Static variables to hold version of IOR */
1536
 
static const int32_t s_IOR_MAJOR_VERSION = 0;
1537
 
static const int32_t s_IOR_MINOR_VERSION = 10;
 
1557
static const int32_t s_IOR_MAJOR_VERSION = 1;
 
1558
static const int32_t s_IOR_MINOR_VERSION = 0;
1538
1559
 
1539
1560
/* Static variables for managing EPV initialization. */
1540
1561
static int s_remote_initialized = 0;
1559
1580
  cmp0 = strcmp(name, "sidl.BaseClass");
1560
1581
  if (!cmp0) {
1561
1582
    (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
1562
 
    cast = self;
 
1583
    cast = ((struct sidl_BaseClass__object*)self);
1563
1584
    return cast;
1564
1585
  }
1565
1586
  else if (cmp0 < 0) {
1566
1587
    cmp1 = strcmp(name, "bHYPRE.StructGrid");
1567
1588
    if (!cmp1) {
1568
1589
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
1569
 
      cast = self;
 
1590
      cast = ((struct bHYPRE_StructGrid__object*)self);
1570
1591
      return cast;
1571
1592
    }
1572
1593
  }
1579
1600
    }
1580
1601
  }
1581
1602
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
1582
 
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,
1583
 
      struct sidl_BaseInterface__object**) = 
1584
 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,
1585
 
        struct sidl_BaseInterface__object**)) 
 
1603
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1604
      sidl_BaseInterface__object**) = 
 
1605
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1606
        sidl_BaseInterface__object**)) 
1586
1607
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
1587
 
    cast =  (*func)(((struct bHYPRE_StructGrid__remote*)self->d_data)->d_ih,
 
1608
    cast =  (*func)(((struct bHYPRE_StructGrid__remote*)self->d_data)->d_ih, 
1588
1609
      _ex);
1589
1610
  }
1590
1611
 
1625
1646
  struct sidl_rmi_InstanceHandle__object *_conn = ((struct 
1626
1647
    bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
1627
1648
  sidl_rmi_Response _rsvp = NULL;
1628
 
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1649
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1629
1650
    "addRef", _ex ); SIDL_CHECK(*_ex);
1630
1651
  /* send actual RMI request */
1631
1652
  _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
1670
1691
    sidl_rmi_Response _rsvp = NULL;
1671
1692
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1672
1693
      bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
1673
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1694
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1674
1695
      "_set_hooks", _ex ); SIDL_CHECK(*_ex);
1675
1696
 
1676
1697
    /* pack in and inout arguments */
1725
1746
    int32_t _retval = 0;
1726
1747
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1727
1748
      bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
1728
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1749
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1729
1750
      "SetCommunicator", _ex ); SIDL_CHECK(*_ex);
1730
1751
 
1731
1752
    /* pack in and inout arguments */
1732
1753
    if(mpi_comm){
1733
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm,
1734
 
        _ex);SIDL_CHECK(*_ex);
1735
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url,
1736
 
        _ex);SIDL_CHECK(*_ex);
 
1754
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm, 
 
1755
        _ex);SIDL_CHECK(*_ex);
 
1756
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url, _ex);SIDL_CHECK(
 
1757
        *_ex);
1737
1758
      free((void*)_url);
1738
1759
    } else {
1739
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL,
1740
 
        _ex);SIDL_CHECK(*_ex);
 
1760
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL, _ex);SIDL_CHECK(
 
1761
        *_ex);
1741
1762
    }
1742
1763
 
1743
1764
    /* send actual RMI request */
1753
1774
    }
1754
1775
 
1755
1776
    /* extract return value */
1756
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1757
 
      _ex);SIDL_CHECK(*_ex);
 
1777
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1778
      *_ex);
1758
1779
 
1759
1780
    /* unpack out and inout arguments */
1760
1781
 
1781
1802
    sidl_rmi_Response _rsvp = NULL;
1782
1803
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1783
1804
      bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
1784
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1805
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1785
1806
      "Destroy", _ex ); SIDL_CHECK(*_ex);
1786
1807
 
1787
1808
    /* pack in and inout arguments */
1825
1846
    int32_t _retval = 0;
1826
1847
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1827
1848
      bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
1828
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1849
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1829
1850
      "SetDimension", _ex ); SIDL_CHECK(*_ex);
1830
1851
 
1831
1852
    /* pack in and inout arguments */
1844
1865
    }
1845
1866
 
1846
1867
    /* extract return value */
1847
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1848
 
      _ex);SIDL_CHECK(*_ex);
 
1868
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1869
      *_ex);
1849
1870
 
1850
1871
    /* unpack out and inout arguments */
1851
1872
 
1875
1896
    int32_t _retval = 0;
1876
1897
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1877
1898
      bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
1878
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1899
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1879
1900
      "SetExtents", _ex ); SIDL_CHECK(*_ex);
1880
1901
 
1881
1902
    /* pack in and inout arguments */
1897
1918
    }
1898
1919
 
1899
1920
    /* extract return value */
1900
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1901
 
      _ex);SIDL_CHECK(*_ex);
 
1921
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1922
      *_ex);
1902
1923
 
1903
1924
    /* unpack out and inout arguments */
1904
1925
 
1927
1948
    int32_t _retval = 0;
1928
1949
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1929
1950
      bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
1930
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1951
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1931
1952
      "SetPeriodic", _ex ); SIDL_CHECK(*_ex);
1932
1953
 
1933
1954
    /* pack in and inout arguments */
1947
1968
    }
1948
1969
 
1949
1970
    /* extract return value */
1950
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1951
 
      _ex);SIDL_CHECK(*_ex);
 
1971
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1972
      *_ex);
1952
1973
 
1953
1974
    /* unpack out and inout arguments */
1954
1975
 
1977
1998
    int32_t _retval = 0;
1978
1999
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1979
2000
      bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
1980
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2001
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1981
2002
      "SetNumGhost", _ex ); SIDL_CHECK(*_ex);
1982
2003
 
1983
2004
    /* pack in and inout arguments */
1997
2018
    }
1998
2019
 
1999
2020
    /* extract return value */
2000
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2001
 
      _ex);SIDL_CHECK(*_ex);
 
2021
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2022
      *_ex);
2002
2023
 
2003
2024
    /* unpack out and inout arguments */
2004
2025
 
2026
2047
    int32_t _retval = 0;
2027
2048
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2028
2049
      bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
2029
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2050
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2030
2051
      "Assemble", _ex ); SIDL_CHECK(*_ex);
2031
2052
 
2032
2053
    /* pack in and inout arguments */
2044
2065
    }
2045
2066
 
2046
2067
    /* extract return value */
2047
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2048
 
      _ex);SIDL_CHECK(*_ex);
 
2068
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2069
      *_ex);
2049
2070
 
2050
2071
    /* unpack out and inout arguments */
2051
2072
 
2113
2134
    sidl_bool _retval = FALSE;
2114
2135
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2115
2136
      bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
2116
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2137
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2117
2138
      "isSame", _ex ); SIDL_CHECK(*_ex);
2118
2139
 
2119
2140
    /* pack in and inout arguments */
2120
2141
    if(iobj){
2121
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,
 
2142
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj, 
2122
2143
        _ex);SIDL_CHECK(*_ex);
2123
2144
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(*_ex);
2124
2145
      free((void*)_url);
2139
2160
    }
2140
2161
 
2141
2162
    /* extract return value */
2142
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
2143
 
      _ex);SIDL_CHECK(*_ex);
 
2163
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2164
      *_ex);
2144
2165
 
2145
2166
    /* unpack out and inout arguments */
2146
2167
 
2169
2190
    sidl_bool _retval = FALSE;
2170
2191
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2171
2192
      bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
2172
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2193
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2173
2194
      "isType", _ex ); SIDL_CHECK(*_ex);
2174
2195
 
2175
2196
    /* pack in and inout arguments */
2188
2209
    }
2189
2210
 
2190
2211
    /* extract return value */
2191
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
2192
 
      _ex);SIDL_CHECK(*_ex);
 
2212
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2213
      *_ex);
2193
2214
 
2194
2215
    /* unpack out and inout arguments */
2195
2216
 
2218
2239
    struct sidl_ClassInfo__object* _retval = 0;
2219
2240
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2220
2241
      bHYPRE_StructGrid__remote*)self->d_data)->d_ih;
2221
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2242
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2222
2243
      "getClassInfo", _ex ); SIDL_CHECK(*_ex);
2223
2244
 
2224
2245
    /* pack in and inout arguments */
2236
2257
    }
2237
2258
 
2238
2259
    /* extract return value */
2239
 
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
2240
 
      _ex);SIDL_CHECK(*_ex);
2241
 
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,
2242
 
      _ex);SIDL_CHECK(*_ex);
 
2260
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
2261
      _ex);SIDL_CHECK(*_ex);
 
2262
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
2263
      *_ex);
2243
2264
 
2244
2265
    /* unpack out and inout arguments */
2245
2266
 
2292
2313
    sidl_BaseInterface*)) epv->f__raddRef;
2293
2314
  e0->f__isRemote    = (sidl_bool (*)(struct sidl_BaseClass__object*,
2294
2315
    sidl_BaseInterface*)) epv->f__isRemote;
2295
 
  e0->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t,
 
2316
  e0->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t, 
2296
2317
    sidl_BaseInterface*)) epv->f__set_hooks;
2297
2318
  e0->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,
2298
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2299
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
2300
 
  e0->f_addRef       = (void (*)(struct sidl_BaseClass__object*,
2301
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
2302
 
  e0->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,
2303
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
2304
 
  e0->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,
2305
 
    struct sidl_BaseInterface__object*,
2306
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
2307
 
  e0->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,
2308
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
2319
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2320
    sidl_BaseInterface__object **)) epv->f__exec;
 
2321
  e0->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct 
 
2322
    sidl_BaseInterface__object **)) epv->f_addRef;
 
2323
  e0->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct 
 
2324
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2325
  e0->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct 
 
2326
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2327
    epv->f_isSame;
 
2328
  e0->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const 
 
2329
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
2309
2330
  e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
2310
 
    sidl_BaseClass__object*,
2311
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2331
    sidl_BaseClass__object*,struct sidl_BaseInterface__object **)) 
 
2332
    epv->f_getClassInfo;
2312
2333
 
2313
 
  e1->f__cast        = (void* (*)(void*,const char*,
2314
 
    sidl_BaseInterface*)) epv->f__cast;
 
2334
  e1->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
2335
    epv->f__cast;
2315
2336
  e1->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
2316
2337
  e1->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
2317
2338
  e1->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
2318
 
  e1->f__isRemote    = (sidl_bool (*)(void*,
2319
 
    sidl_BaseInterface*)) epv->f__isRemote;
2320
 
  e1->f__set_hooks   = (void (*)(void*,int32_t,
2321
 
    sidl_BaseInterface*)) epv->f__set_hooks;
2322
 
  e1->f__exec        = (void (*)(void*,const char*,
2323
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2324
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
2325
 
  e1->f_addRef       = (void (*)(void*,
2326
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
2327
 
  e1->f_deleteRef    = (void (*)(void*,
2328
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2339
  e1->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
2340
    epv->f__isRemote;
 
2341
  e1->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
2342
    epv->f__set_hooks;
 
2343
  e1->f__exec        = (void (*)(void*,const char*,struct 
 
2344
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2345
    sidl_BaseInterface__object **)) epv->f__exec;
 
2346
  e1->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2347
    epv->f_addRef;
 
2348
  e1->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2349
    epv->f_deleteRef;
2329
2350
  e1->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
2330
2351
    struct sidl_BaseInterface__object **)) epv->f_isSame;
2331
 
  e1->f_isType       = (sidl_bool (*)(void*,const char*,
2332
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
2333
 
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
2334
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2352
  e1->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
2353
    sidl_BaseInterface__object **)) epv->f_isType;
 
2354
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2355
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
2335
2356
 
2336
2357
  s_remote_initialized = 1;
2337
2358
}
2338
2359
 
2339
2360
/* Create an instance that connects to an existing remote object. */
2340
2361
static struct bHYPRE_StructGrid__object*
2341
 
bHYPRE_StructGrid__remoteConnect(const char *url, sidl_bool ar,
 
2362
bHYPRE_StructGrid__remoteConnect(const char *url, sidl_bool ar, 
2342
2363
  sidl_BaseInterface *_ex)
2343
2364
{
2344
2365
  struct bHYPRE_StructGrid__object* self;
2354
2375
  if(url == NULL) {return NULL;}
2355
2376
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
2356
2377
  if(objectID) {
2357
 
    sidl_BaseInterface bi = 
2358
 
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
2359
 
      objectID, _ex); SIDL_CHECK(*_ex);
 
2378
    sidl_BaseInterface bi = (
 
2379
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(objectID,
 
2380
      _ex); SIDL_CHECK(*_ex);
2360
2381
    return bHYPRE_StructGrid__rmicast(bi,_ex);SIDL_CHECK(*_ex);
2361
2382
  }
2362
 
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar,
2363
 
    _ex ); SIDL_CHECK(*_ex);
 
2383
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex ); 
 
2384
    SIDL_CHECK(*_ex);
2364
2385
  if ( instance == NULL) { return NULL; }
2365
2386
  self =
2366
2387
    (struct bHYPRE_StructGrid__object*) malloc(
2399
2420
/* Create an instance that uses an already existing  */
2400
2421
/* InstanceHandle to connect to an existing remote object. */
2401
2422
static struct bHYPRE_StructGrid__object*
2402
 
bHYPRE_StructGrid__IHConnect(sidl_rmi_InstanceHandle instance,
 
2423
bHYPRE_StructGrid__IHConnect(sidl_rmi_InstanceHandle instance, 
2403
2424
  sidl_BaseInterface *_ex)
2404
2425
{
2405
2426
  struct bHYPRE_StructGrid__object* self;
2454
2475
  struct sidl_BaseClass__object* s1;
2455
2476
 
2456
2477
  struct bHYPRE_StructGrid__remote* r_obj;
2457
 
  sidl_rmi_InstanceHandle instance = 
2458
 
    sidl_rmi_ProtocolFactory_createInstance(url, "bHYPRE.StructGrid",
2459
 
    _ex ); SIDL_CHECK(*_ex);
 
2478
  sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance(
 
2479
    url, "bHYPRE.StructGrid", _ex ); SIDL_CHECK(*_ex);
2460
2480
  if ( instance == NULL) { return NULL; }
2461
2481
  self =
2462
2482
    (struct bHYPRE_StructGrid__object*) malloc(
2490
2510
 
2491
2511
  return self;
2492
2512
  EXIT:
2493
 
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance,
 
2513
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance, 
2494
2514
    &_throwaway_exception); }
2495
2515
  return NULL;
2496
2516
}
2507
2527
 
2508
2528
  *_ex = NULL;
2509
2529
  if(!connect_loaded) {
2510
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.StructGrid",
2511
 
      (void*)bHYPRE_StructGrid__IHConnect, _ex);
 
2530
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.StructGrid", (
 
2531
      void*)bHYPRE_StructGrid__IHConnect, _ex);
2512
2532
    connect_loaded = 1;
2513
2533
  }
2514
2534
  if (obj != NULL) {
2529
2549
 */
2530
2550
 
2531
2551
struct bHYPRE_StructGrid__object*
2532
 
bHYPRE_StructGrid__connectI(const char* url, sidl_bool ar,
2533
 
  struct sidl_BaseInterface__object **_ex)
 
2552
bHYPRE_StructGrid__connectI(const char* url, sidl_bool ar, struct 
 
2553
  sidl_BaseInterface__object **_ex)
2534
2554
{
2535
2555
  return bHYPRE_StructGrid__remoteConnect(url, ar, _ex);
2536
2556
}