← 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_SStructDiagScale_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_SStructDiagScale_fStub.c
2
2
 * File:          bHYPRE_SStructDiagScale_fStub.c
3
3
 * Symbol:        bHYPRE.SStructDiagScale-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.SStructDiagScale
7
7
 * 
8
8
 * WARNING: Automatically generated; changes will be lost
83
83
static int connect_loaded = 0;
84
84
 
85
85
static struct bHYPRE_SStructDiagScale__object* 
86
 
  bHYPRE_SStructDiagScale__remoteCreate(const char* url,
87
 
  sidl_BaseInterface *_ex);
 
86
  bHYPRE_SStructDiagScale__remoteCreate(const char* url, sidl_BaseInterface 
 
87
  *_ex);
88
88
static struct bHYPRE_SStructDiagScale__object* 
89
 
  bHYPRE_SStructDiagScale__remoteConnect(const char* url, sidl_bool ar,
 
89
  bHYPRE_SStructDiagScale__remoteConnect(const char* url, sidl_bool ar, 
90
90
  sidl_BaseInterface *_ex);
91
91
static struct bHYPRE_SStructDiagScale__object* 
92
92
  bHYPRE_SStructDiagScale__IHConnect(struct sidl_rmi_InstanceHandle__object 
102
102
#ifdef SIDL_STATIC_LIBRARY
103
103
    _ior = bHYPRE_SStructDiagScale__externals();
104
104
#else
105
 
    _ior = (struct 
106
 
      bHYPRE_SStructDiagScale__external*)sidl_dynamicLoadIOR(
 
105
    _ior = (struct bHYPRE_SStructDiagScale__external*)sidl_dynamicLoadIOR(
107
106
      "bHYPRE.SStructDiagScale","bHYPRE_SStructDiagScale__externals") ;
108
 
    sidl_checkIORVersion("bHYPRE.SStructDiagScale", _ior->d_ior_major_version,
109
 
      _ior->d_ior_minor_version, 0, 10);
 
107
    sidl_checkIORVersion("bHYPRE.SStructDiagScale", _ior->d_ior_major_version, 
 
108
      _ior->d_ior_minor_version, 1, 0);
110
109
#endif
111
110
  }
112
111
  return _ior;
160
159
  char* _proxy_url = NULL;
161
160
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
162
161
  _proxy_url =
163
 
    sidl_copy_fortran_str(SIDL_F77_STR(url),
 
162
    sidl_copy_fortran_str(SIDL_F77_STR(url),(ptrdiff_t)
164
163
      SIDL_F77_STR_LEN(url));
165
 
  _proxy_self = bHYPRE_SStructDiagScale__remoteCreate(_proxy_url,
 
164
  _proxy_self = bHYPRE_SStructDiagScale__remoteCreate(_proxy_url, 
166
165
    &_proxy_exception);
167
166
  if (_proxy_exception) {
168
167
    *exception = (ptrdiff_t)_proxy_exception;
186
185
)
187
186
{
188
187
  struct sidl_BaseInterface__object *_ior_exception = NULL;
189
 
  *self = (ptrdiff_t) 
190
 
    (*(_getIOR()->createObject))((void*)(ptrdiff_t)*private_data,
191
 
    &_ior_exception);
 
188
  *self = (ptrdiff_t) (*(_getIOR()->createObject))((void*)(
 
189
    ptrdiff_t)*private_data,&_ior_exception);
192
190
  *exception = (ptrdiff_t)_ior_exception;
193
191
  if (_ior_exception) *self = 0;
194
192
}
211
209
  char* _proxy_url = NULL;
212
210
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
213
211
  _proxy_url =
214
 
    sidl_copy_fortran_str(SIDL_F77_STR(url),
 
212
    sidl_copy_fortran_str(SIDL_F77_STR(url),(ptrdiff_t)
215
213
      SIDL_F77_STR_LEN(url));
216
 
  _proxy_self = bHYPRE_SStructDiagScale__remoteConnect(_proxy_url, 1,
 
214
  _proxy_self = bHYPRE_SStructDiagScale__remoteConnect(_proxy_url, 1, 
217
215
    &_proxy_exception);
218
216
  if (_proxy_exception) {
219
217
    *exception = (ptrdiff_t)_proxy_exception;
242
240
 
243
241
  *retval = 0;
244
242
  if(!connect_loaded) {
245
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructDiagScale",
246
 
      (void*)bHYPRE_SStructDiagScale__IHConnect, &proxy_exception);
 
243
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructDiagScale", (
 
244
      void*)bHYPRE_SStructDiagScale__IHConnect, &proxy_exception);
247
245
    SIDL_CHECK(proxy_exception);
248
246
    connect_loaded = 1;
249
247
  }
285
283
    (struct bHYPRE_SStructDiagScale__object*)
286
284
    (ptrdiff_t)(*self);
287
285
  _proxy_name =
288
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
286
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
289
287
      SIDL_F77_STR_LEN(name));
290
288
  _epv = _proxy_self->d_epv;
291
289
  _proxy_retval = 
331
329
    (struct bHYPRE_SStructDiagScale__object*)
332
330
    (ptrdiff_t)(*self);
333
331
  _proxy_methodName =
334
 
    sidl_copy_fortran_str(SIDL_F77_STR(methodName),
 
332
    sidl_copy_fortran_str(SIDL_F77_STR(methodName),(ptrdiff_t)
335
333
      SIDL_F77_STR_LEN(methodName));
336
334
  _proxy_inArgs =
337
335
    (struct sidl_rmi_Call__object*)
390
388
  else {
391
389
    *exception = (ptrdiff_t)NULL;
392
390
    sidl_copy_c_str(
393
 
      SIDL_F77_STR(retval),
 
391
      SIDL_F77_STR(retval),(size_t)
394
392
      SIDL_F77_STR_LEN(retval),
395
393
      _proxy_retval);
 
394
    if (_proxy_retval) free(_proxy_retval);
396
395
  }
397
 
  free((void *)_proxy_retval);
398
396
}
399
397
 
400
398
 
531
529
}
532
530
 
533
531
/*
534
 
 * Method:  Create[]
 
532
 *  This function is the preferred way to create a SStruct DiagScale solver. 
535
533
 */
536
534
 
537
535
void
712
710
    (struct bHYPRE_SStructDiagScale__object*)
713
711
    (ptrdiff_t)(*self);
714
712
  _proxy_name =
715
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
713
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
716
714
      SIDL_F77_STR_LEN(name));
717
715
  _epv = _proxy_self->d_epv;
718
716
  _proxy_retval = 
1116
1114
    (struct bHYPRE_SStructDiagScale__object*)
1117
1115
    (ptrdiff_t)(*self);
1118
1116
  _proxy_name =
1119
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
1117
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
1120
1118
      SIDL_F77_STR_LEN(name));
1121
1119
  _epv = _proxy_self->d_epv;
1122
1120
  *retval = 
1159
1157
    (struct bHYPRE_SStructDiagScale__object*)
1160
1158
    (ptrdiff_t)(*self);
1161
1159
  _proxy_name =
1162
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
1160
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
1163
1161
      SIDL_F77_STR_LEN(name));
1164
1162
  _epv = _proxy_self->d_epv;
1165
1163
  *retval = 
1205
1203
    (struct bHYPRE_SStructDiagScale__object*)
1206
1204
    (ptrdiff_t)(*self);
1207
1205
  _proxy_name =
1208
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
1206
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
1209
1207
      SIDL_F77_STR_LEN(name));
1210
1208
  _proxy_value =
1211
 
    sidl_copy_fortran_str(SIDL_F77_STR(value),
 
1209
    sidl_copy_fortran_str(SIDL_F77_STR(value),(ptrdiff_t)
1212
1210
      SIDL_F77_STR_LEN(value));
1213
1211
  _epv = _proxy_self->d_epv;
1214
1212
  *retval = 
1256
1254
    (struct bHYPRE_SStructDiagScale__object*)
1257
1255
    (ptrdiff_t)(*self);
1258
1256
  _proxy_name =
1259
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
1257
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
1260
1258
      SIDL_F77_STR_LEN(name));
1261
1259
  value_upper[0] = (*nvalues)-1;
1262
 
  sidl_int__array_init(value, _proxy_value, 1, value_lower, value_upper,
 
1260
  sidl_int__array_init(value, _proxy_value, 1, value_lower, value_upper, 
1263
1261
    value_stride);
1264
1262
  _epv = _proxy_self->d_epv;
1265
1263
  *retval = 
1275
1273
  else {
1276
1274
    *exception = (ptrdiff_t)NULL;
1277
1275
  }
 
1276
#ifdef SIDL_DEBUG_REFCOUNT
 
1277
  sidl__array_deleteRef((struct sidl__array*)_proxy_value);
 
1278
#endif /* SIDL_DEBUG_REFCOUNT */
1278
1279
  free((void *)_proxy_name);
1279
1280
}
1280
1281
 
1303
1304
    (struct bHYPRE_SStructDiagScale__object*)
1304
1305
    (ptrdiff_t)(*self);
1305
1306
  _proxy_name =
1306
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
1307
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
1307
1308
      SIDL_F77_STR_LEN(name));
1308
1309
  _proxy_value =
1309
1310
    (struct sidl_int__array*)
1353
1354
    (struct bHYPRE_SStructDiagScale__object*)
1354
1355
    (ptrdiff_t)(*self);
1355
1356
  _proxy_name =
1356
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
1357
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
1357
1358
      SIDL_F77_STR_LEN(name));
1358
1359
  value_upper[0] = (*nvalues)-1;
1359
 
  sidl_double__array_init(value, _proxy_value, 1, value_lower, value_upper,
 
1360
  sidl_double__array_init(value, _proxy_value, 1, value_lower, value_upper, 
1360
1361
    value_stride);
1361
1362
  _epv = _proxy_self->d_epv;
1362
1363
  *retval = 
1372
1373
  else {
1373
1374
    *exception = (ptrdiff_t)NULL;
1374
1375
  }
 
1376
#ifdef SIDL_DEBUG_REFCOUNT
 
1377
  sidl__array_deleteRef((struct sidl__array*)_proxy_value);
 
1378
#endif /* SIDL_DEBUG_REFCOUNT */
1375
1379
  free((void *)_proxy_name);
1376
1380
}
1377
1381
 
1400
1404
    (struct bHYPRE_SStructDiagScale__object*)
1401
1405
    (ptrdiff_t)(*self);
1402
1406
  _proxy_name =
1403
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
1407
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
1404
1408
      SIDL_F77_STR_LEN(name));
1405
1409
  _proxy_value =
1406
1410
    (struct sidl_double__array*)
1446
1450
    (struct bHYPRE_SStructDiagScale__object*)
1447
1451
    (ptrdiff_t)(*self);
1448
1452
  _proxy_name =
1449
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
1453
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
1450
1454
      SIDL_F77_STR_LEN(name));
1451
1455
  _epv = _proxy_self->d_epv;
1452
1456
  *retval = 
1489
1493
    (struct bHYPRE_SStructDiagScale__object*)
1490
1494
    (ptrdiff_t)(*self);
1491
1495
  _proxy_name =
1492
 
    sidl_copy_fortran_str(SIDL_F77_STR(name),
 
1496
    sidl_copy_fortran_str(SIDL_F77_STR(name),(ptrdiff_t)
1493
1497
      SIDL_F77_STR_LEN(name));
1494
1498
  _epv = _proxy_self->d_epv;
1495
1499
  *retval = 
1702
1706
                  bHYPRE_SStructDiagScale__array_addRef_f)
1703
1707
  (int64_t *array)
1704
1708
{
1705
 
  sidl_interface__array_addRef((struct sidl_interface__array 
1706
 
    *)(ptrdiff_t)*array);
 
1709
  sidl_interface__array_addRef((struct sidl_interface__array *)(
 
1710
    ptrdiff_t)*array);
1707
1711
}
1708
1712
 
1709
1713
void
1712
1716
                  bHYPRE_SStructDiagScale__array_deleteRef_f)
1713
1717
  (int64_t *array)
1714
1718
{
1715
 
  sidl_interface__array_deleteRef((struct sidl_interface__array 
1716
 
    *)(ptrdiff_t)*array);
 
1719
  sidl_interface__array_deleteRef((struct sidl_interface__array *)(
 
1720
    ptrdiff_t)*array);
1717
1721
}
1718
1722
 
1719
1723
void
1725
1729
   int64_t *result)
1726
1730
{
1727
1731
  *result = (ptrdiff_t)
1728
 
    sidl_interface__array_get1((const struct sidl_interface__array 
1729
 
      *)(ptrdiff_t)*array
 
1732
    sidl_interface__array_get1((const struct sidl_interface__array *)(
 
1733
      ptrdiff_t)*array
1730
1734
    , *i1);
1731
1735
}
1732
1736
 
1740
1744
   int64_t *result)
1741
1745
{
1742
1746
  *result = (ptrdiff_t)
1743
 
    sidl_interface__array_get2((const struct sidl_interface__array 
1744
 
      *)(ptrdiff_t)*array
 
1747
    sidl_interface__array_get2((const struct sidl_interface__array *)(
 
1748
      ptrdiff_t)*array
1745
1749
    , *i1, *i2);
1746
1750
}
1747
1751
 
1756
1760
   int64_t *result)
1757
1761
{
1758
1762
  *result = (ptrdiff_t)
1759
 
    sidl_interface__array_get3((const struct sidl_interface__array 
1760
 
      *)(ptrdiff_t)*array
 
1763
    sidl_interface__array_get3((const struct sidl_interface__array *)(
 
1764
      ptrdiff_t)*array
1761
1765
    , *i1, *i2, *i3);
1762
1766
}
1763
1767
 
1773
1777
   int64_t *result)
1774
1778
{
1775
1779
  *result = (ptrdiff_t)
1776
 
    sidl_interface__array_get4((const struct sidl_interface__array 
1777
 
      *)(ptrdiff_t)*array
 
1780
    sidl_interface__array_get4((const struct sidl_interface__array *)(
 
1781
      ptrdiff_t)*array
1778
1782
    , *i1, *i2, *i3, *i4);
1779
1783
}
1780
1784
 
1791
1795
   int64_t *result)
1792
1796
{
1793
1797
  *result = (ptrdiff_t)
1794
 
    sidl_interface__array_get5((const struct sidl_interface__array 
1795
 
      *)(ptrdiff_t)*array
 
1798
    sidl_interface__array_get5((const struct sidl_interface__array *)(
 
1799
      ptrdiff_t)*array
1796
1800
    , *i1, *i2, *i3, *i4, *i5);
1797
1801
}
1798
1802
 
1810
1814
   int64_t *result)
1811
1815
{
1812
1816
  *result = (ptrdiff_t)
1813
 
    sidl_interface__array_get6((const struct sidl_interface__array 
1814
 
      *)(ptrdiff_t)*array
 
1817
    sidl_interface__array_get6((const struct sidl_interface__array *)(
 
1818
      ptrdiff_t)*array
1815
1819
    , *i1, *i2, *i3, *i4, *i5, *i6);
1816
1820
}
1817
1821
 
1830
1834
   int64_t *result)
1831
1835
{
1832
1836
  *result = (ptrdiff_t)
1833
 
    sidl_interface__array_get7((const struct sidl_interface__array 
1834
 
      *)(ptrdiff_t)*array
 
1837
    sidl_interface__array_get7((const struct sidl_interface__array *)(
 
1838
      ptrdiff_t)*array
1835
1839
    , *i1, *i2, *i3, *i4, *i5, *i6, *i7);
1836
1840
}
1837
1841
 
1844
1848
   int64_t *result)
1845
1849
{
1846
1850
  *result = (ptrdiff_t)
1847
 
    sidl_interface__array_get((const struct sidl_interface__array 
1848
 
      *)(ptrdiff_t)*array, indices);
 
1851
    sidl_interface__array_get((const struct sidl_interface__array *)(
 
1852
      ptrdiff_t)*array, indices);
1849
1853
}
1850
1854
 
1851
1855
void
1915
1919
   int64_t *value)
1916
1920
{
1917
1921
  sidl_interface__array_set5((struct sidl_interface__array *)(ptrdiff_t)*array
1918
 
  , *i1, *i2, *i3, *i4, *i5,
1919
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1922
  , *i1, *i2, *i3, *i4, *i5, (struct sidl_BaseInterface__object *)(
 
1923
    ptrdiff_t)*value);
1920
1924
}
1921
1925
 
1922
1926
void
1933
1937
   int64_t *value)
1934
1938
{
1935
1939
  sidl_interface__array_set6((struct sidl_interface__array *)(ptrdiff_t)*array
1936
 
  , *i1, *i2, *i3, *i4, *i5, *i6,
1937
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1940
  , *i1, *i2, *i3, *i4, *i5, *i6, (struct sidl_BaseInterface__object *)(
 
1941
    ptrdiff_t)*value);
1938
1942
}
1939
1943
 
1940
1944
void
1952
1956
   int64_t *value)
1953
1957
{
1954
1958
  sidl_interface__array_set7((struct sidl_interface__array *)(ptrdiff_t)*array
1955
 
  , *i1, *i2, *i3, *i4, *i5, *i6, *i7,
1956
 
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1959
  , *i1, *i2, *i3, *i4, *i5, *i6, *i7, (struct sidl_BaseInterface__object *)(
 
1960
    ptrdiff_t)*value);
1957
1961
}
1958
1962
 
1959
1963
void
1964
1968
  int32_t indices[],
1965
1969
  int64_t *value)
1966
1970
{
1967
 
  sidl_interface__array_set((struct sidl_interface__array *)(ptrdiff_t)*array,
 
1971
  sidl_interface__array_set((struct sidl_interface__array *)(ptrdiff_t)*array, 
1968
1972
    indices, (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
1969
1973
}
1970
1974
 
1975
1979
  (int64_t *array, int32_t *result)
1976
1980
{
1977
1981
  *result =
1978
 
    sidl_interface__array_dimen((struct sidl_interface__array 
1979
 
      *)(ptrdiff_t)*array);
 
1982
    sidl_interface__array_dimen((struct sidl_interface__array *)(
 
1983
      ptrdiff_t)*array);
1980
1984
}
1981
1985
 
1982
1986
void
1988
1992
   int32_t *result)
1989
1993
{
1990
1994
  *result = 
1991
 
    sidl_interface__array_lower((struct sidl_interface__array 
1992
 
      *)(ptrdiff_t)*array, *ind);
 
1995
    sidl_interface__array_lower((struct sidl_interface__array *)(
 
1996
      ptrdiff_t)*array, *ind);
1993
1997
}
1994
1998
 
1995
1999
void
2001
2005
   int32_t *result)
2002
2006
{
2003
2007
  *result = 
2004
 
    sidl_interface__array_upper((struct sidl_interface__array 
2005
 
      *)(ptrdiff_t)*array, *ind);
 
2008
    sidl_interface__array_upper((struct sidl_interface__array *)(
 
2009
      ptrdiff_t)*array, *ind);
2006
2010
}
2007
2011
 
2008
2012
void
2014
2018
   int32_t *result)
2015
2019
{
2016
2020
  *result = 
2017
 
    sidl_interface__array_length((struct sidl_interface__array 
2018
 
      *)(ptrdiff_t)*array, *ind);
 
2021
    sidl_interface__array_length((struct sidl_interface__array *)(
 
2022
      ptrdiff_t)*array, *ind);
2019
2023
}
2020
2024
 
2021
2025
void
2027
2031
   int32_t *result)
2028
2032
{
2029
2033
  *result = 
2030
 
    sidl_interface__array_stride((struct sidl_interface__array 
2031
 
      *)(ptrdiff_t)*array, *ind);
 
2034
    sidl_interface__array_stride((struct sidl_interface__array *)(
 
2035
      ptrdiff_t)*array, *ind);
2032
2036
}
2033
2037
 
2034
2038
void
2049
2053
  (int64_t *array,
2050
2054
   SIDL_F77_Bool *result)
2051
2055
{
2052
 
  *result = sidl_interface__array_isRowOrder((struct sidl_interface__array 
2053
 
    *)(ptrdiff_t)*array);
 
2056
  *result = sidl_interface__array_isRowOrder((struct sidl_interface__array *)(
 
2057
    ptrdiff_t)*array);
2054
2058
}
2055
2059
 
2056
2060
void
2060
2064
  (int64_t *src,
2061
2065
   int64_t *dest)
2062
2066
{
2063
 
  sidl_interface__array_copy((const struct sidl_interface__array 
2064
 
    *)(ptrdiff_t)*src,
 
2067
  sidl_interface__array_copy((const struct sidl_interface__array *)(
 
2068
    ptrdiff_t)*src,
2065
2069
                             (struct sidl_interface__array *)(ptrdiff_t)*dest);
2066
2070
}
2067
2071
 
2071
2075
                  bHYPRE_SStructDiagScale__array_smartCopy_f)
2072
2076
  (int64_t *src)
2073
2077
{
2074
 
  sidl_interface__array_smartCopy((struct sidl_interface__array 
2075
 
    *)(ptrdiff_t)*src);
 
2078
  sidl_interface__array_smartCopy((struct sidl_interface__array *)(
 
2079
    ptrdiff_t)*src);
2076
2080
}
2077
2081
 
2078
2082
void
2102
2106
   int64_t *result)
2103
2107
{
2104
2108
  *result = (ptrdiff_t)
2105
 
    sidl_interface__array_ensure((struct sidl_interface__array 
2106
 
      *)(ptrdiff_t)*src,
 
2109
    sidl_interface__array_ensure((struct sidl_interface__array *)(
 
2110
      ptrdiff_t)*src,
2107
2111
    *dimen, *ordering);
2108
2112
}
2109
2113
 
2158
2162
#endif
2159
2163
 
2160
2164
/* Static variables to hold version of IOR */
2161
 
static const int32_t s_IOR_MAJOR_VERSION = 0;
2162
 
static const int32_t s_IOR_MINOR_VERSION = 10;
 
2165
static const int32_t s_IOR_MAJOR_VERSION = 1;
 
2166
static const int32_t s_IOR_MINOR_VERSION = 0;
2163
2167
 
2164
2168
/* Static variables for managing EPV initialization. */
2165
2169
static int s_remote_initialized = 0;
2196
2200
    cmp1 = strcmp(name, "bHYPRE.SStructDiagScale");
2197
2201
    if (!cmp1) {
2198
2202
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
2199
 
      cast = self;
 
2203
      cast = ((struct bHYPRE_SStructDiagScale__object*)self);
2200
2204
      return cast;
2201
2205
    }
2202
2206
    else if (cmp1 < 0) {
2219
2223
      cmp2 = strcmp(name, "sidl.BaseClass");
2220
2224
      if (!cmp2) {
2221
2225
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
2222
 
        cast = self;
 
2226
        cast = ((struct sidl_BaseClass__object*)self);
2223
2227
        return cast;
2224
2228
      }
2225
2229
    }
2226
2230
  }
2227
2231
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
2228
 
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,
2229
 
      struct sidl_BaseInterface__object**) = 
2230
 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,
2231
 
        struct sidl_BaseInterface__object**)) 
 
2232
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct 
 
2233
      sidl_BaseInterface__object**) = 
 
2234
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct 
 
2235
        sidl_BaseInterface__object**)) 
2232
2236
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
2233
2237
    cast =  (*func)(((struct 
2234
2238
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih, _ex);
2271
2275
  struct sidl_rmi_InstanceHandle__object *_conn = ((struct 
2272
2276
    bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2273
2277
  sidl_rmi_Response _rsvp = NULL;
2274
 
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2278
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2275
2279
    "addRef", _ex ); SIDL_CHECK(*_ex);
2276
2280
  /* send actual RMI request */
2277
2281
  _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
2316
2320
    sidl_rmi_Response _rsvp = NULL;
2317
2321
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2318
2322
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2319
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2323
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2320
2324
      "_set_hooks", _ex ); SIDL_CHECK(*_ex);
2321
2325
 
2322
2326
    /* pack in and inout arguments */
2410
2414
    sidl_bool _retval = FALSE;
2411
2415
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2412
2416
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2413
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2417
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2414
2418
      "isSame", _ex ); SIDL_CHECK(*_ex);
2415
2419
 
2416
2420
    /* pack in and inout arguments */
2417
2421
    if(iobj){
2418
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,
 
2422
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj, 
2419
2423
        _ex);SIDL_CHECK(*_ex);
2420
2424
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(*_ex);
2421
2425
      free((void*)_url);
2436
2440
    }
2437
2441
 
2438
2442
    /* extract return value */
2439
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
2440
 
      _ex);SIDL_CHECK(*_ex);
 
2443
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2444
      *_ex);
2441
2445
 
2442
2446
    /* unpack out and inout arguments */
2443
2447
 
2466
2470
    sidl_bool _retval = FALSE;
2467
2471
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2468
2472
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2469
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2473
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2470
2474
      "isType", _ex ); SIDL_CHECK(*_ex);
2471
2475
 
2472
2476
    /* pack in and inout arguments */
2485
2489
    }
2486
2490
 
2487
2491
    /* extract return value */
2488
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
2489
 
      _ex);SIDL_CHECK(*_ex);
 
2492
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2493
      *_ex);
2490
2494
 
2491
2495
    /* unpack out and inout arguments */
2492
2496
 
2515
2519
    struct sidl_ClassInfo__object* _retval = 0;
2516
2520
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2517
2521
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2518
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2522
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2519
2523
      "getClassInfo", _ex ); SIDL_CHECK(*_ex);
2520
2524
 
2521
2525
    /* pack in and inout arguments */
2533
2537
    }
2534
2538
 
2535
2539
    /* extract return value */
2536
 
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
2537
 
      _ex);SIDL_CHECK(*_ex);
2538
 
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,
2539
 
      _ex);SIDL_CHECK(*_ex);
 
2540
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
2541
      _ex);SIDL_CHECK(*_ex);
 
2542
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
2543
      *_ex);
2540
2544
 
2541
2545
    /* unpack out and inout arguments */
2542
2546
 
2565
2569
    int32_t _retval = 0;
2566
2570
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2567
2571
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2568
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2572
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2569
2573
      "SetOperator", _ex ); SIDL_CHECK(*_ex);
2570
2574
 
2571
2575
    /* pack in and inout arguments */
2572
2576
    if(A){
2573
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)A,
 
2577
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)A, 
2574
2578
        _ex);SIDL_CHECK(*_ex);
2575
2579
      sidl_rmi_Invocation_packString( _inv, "A", _url, _ex);SIDL_CHECK(*_ex);
2576
2580
      free((void*)_url);
2591
2595
    }
2592
2596
 
2593
2597
    /* extract return value */
2594
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2595
 
      _ex);SIDL_CHECK(*_ex);
 
2598
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2599
      *_ex);
2596
2600
 
2597
2601
    /* unpack out and inout arguments */
2598
2602
 
2621
2625
    int32_t _retval = 0;
2622
2626
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2623
2627
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2624
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2628
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2625
2629
      "SetTolerance", _ex ); SIDL_CHECK(*_ex);
2626
2630
 
2627
2631
    /* pack in and inout arguments */
2628
 
    sidl_rmi_Invocation_packDouble( _inv, "tolerance", tolerance,
 
2632
    sidl_rmi_Invocation_packDouble( _inv, "tolerance", tolerance, 
2629
2633
      _ex);SIDL_CHECK(*_ex);
2630
2634
 
2631
2635
    /* send actual RMI request */
2641
2645
    }
2642
2646
 
2643
2647
    /* extract return value */
2644
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2645
 
      _ex);SIDL_CHECK(*_ex);
 
2648
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2649
      *_ex);
2646
2650
 
2647
2651
    /* unpack out and inout arguments */
2648
2652
 
2671
2675
    int32_t _retval = 0;
2672
2676
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2673
2677
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2674
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2678
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2675
2679
      "SetMaxIterations", _ex ); SIDL_CHECK(*_ex);
2676
2680
 
2677
2681
    /* pack in and inout arguments */
2678
 
    sidl_rmi_Invocation_packInt( _inv, "max_iterations", max_iterations,
 
2682
    sidl_rmi_Invocation_packInt( _inv, "max_iterations", max_iterations, 
2679
2683
      _ex);SIDL_CHECK(*_ex);
2680
2684
 
2681
2685
    /* send actual RMI request */
2691
2695
    }
2692
2696
 
2693
2697
    /* extract return value */
2694
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2695
 
      _ex);SIDL_CHECK(*_ex);
 
2698
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2699
      *_ex);
2696
2700
 
2697
2701
    /* unpack out and inout arguments */
2698
2702
 
2721
2725
    int32_t _retval = 0;
2722
2726
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2723
2727
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2724
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2728
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2725
2729
      "SetLogging", _ex ); SIDL_CHECK(*_ex);
2726
2730
 
2727
2731
    /* pack in and inout arguments */
2740
2744
    }
2741
2745
 
2742
2746
    /* extract return value */
2743
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2744
 
      _ex);SIDL_CHECK(*_ex);
 
2747
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2748
      *_ex);
2745
2749
 
2746
2750
    /* unpack out and inout arguments */
2747
2751
 
2770
2774
    int32_t _retval = 0;
2771
2775
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2772
2776
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2773
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2777
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2774
2778
      "SetPrintLevel", _ex ); SIDL_CHECK(*_ex);
2775
2779
 
2776
2780
    /* pack in and inout arguments */
2789
2793
    }
2790
2794
 
2791
2795
    /* extract return value */
2792
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2793
 
      _ex);SIDL_CHECK(*_ex);
 
2796
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2797
      *_ex);
2794
2798
 
2795
2799
    /* unpack out and inout arguments */
2796
2800
 
2819
2823
    int32_t _retval = 0;
2820
2824
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2821
2825
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2822
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2826
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2823
2827
      "GetNumIterations", _ex ); SIDL_CHECK(*_ex);
2824
2828
 
2825
2829
    /* pack in and inout arguments */
2837
2841
    }
2838
2842
 
2839
2843
    /* extract return value */
2840
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2841
 
      _ex);SIDL_CHECK(*_ex);
 
2844
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2845
      *_ex);
2842
2846
 
2843
2847
    /* unpack out and inout arguments */
2844
 
    sidl_rmi_Response_unpackInt( _rsvp, "num_iterations", num_iterations,
 
2848
    sidl_rmi_Response_unpackInt( _rsvp, "num_iterations", num_iterations, 
2845
2849
      _ex);SIDL_CHECK(*_ex);
2846
2850
 
2847
2851
    /* cleanup and return */
2869
2873
    int32_t _retval = 0;
2870
2874
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2871
2875
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2872
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2876
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2873
2877
      "GetRelResidualNorm", _ex ); SIDL_CHECK(*_ex);
2874
2878
 
2875
2879
    /* pack in and inout arguments */
2887
2891
    }
2888
2892
 
2889
2893
    /* extract return value */
2890
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2891
 
      _ex);SIDL_CHECK(*_ex);
 
2894
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2895
      *_ex);
2892
2896
 
2893
2897
    /* unpack out and inout arguments */
2894
2898
    sidl_rmi_Response_unpackDouble( _rsvp, "norm", norm, _ex);SIDL_CHECK(*_ex);
2918
2922
    int32_t _retval = 0;
2919
2923
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2920
2924
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2921
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2925
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2922
2926
      "SetCommunicator", _ex ); SIDL_CHECK(*_ex);
2923
2927
 
2924
2928
    /* pack in and inout arguments */
2925
2929
    if(mpi_comm){
2926
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm,
2927
 
        _ex);SIDL_CHECK(*_ex);
2928
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url,
2929
 
        _ex);SIDL_CHECK(*_ex);
 
2930
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm, 
 
2931
        _ex);SIDL_CHECK(*_ex);
 
2932
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url, _ex);SIDL_CHECK(
 
2933
        *_ex);
2930
2934
      free((void*)_url);
2931
2935
    } else {
2932
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL,
2933
 
        _ex);SIDL_CHECK(*_ex);
 
2936
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL, _ex);SIDL_CHECK(
 
2937
        *_ex);
2934
2938
    }
2935
2939
 
2936
2940
    /* send actual RMI request */
2946
2950
    }
2947
2951
 
2948
2952
    /* extract return value */
2949
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2950
 
      _ex);SIDL_CHECK(*_ex);
 
2953
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2954
      *_ex);
2951
2955
 
2952
2956
    /* unpack out and inout arguments */
2953
2957
 
2974
2978
    sidl_rmi_Response _rsvp = NULL;
2975
2979
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2976
2980
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
2977
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2981
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2978
2982
      "Destroy", _ex ); SIDL_CHECK(*_ex);
2979
2983
 
2980
2984
    /* pack in and inout arguments */
3019
3023
    int32_t _retval = 0;
3020
3024
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3021
3025
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3022
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3026
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3023
3027
      "SetIntParameter", _ex ); SIDL_CHECK(*_ex);
3024
3028
 
3025
3029
    /* pack in and inout arguments */
3039
3043
    }
3040
3044
 
3041
3045
    /* extract return value */
3042
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3043
 
      _ex);SIDL_CHECK(*_ex);
 
3046
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3047
      *_ex);
3044
3048
 
3045
3049
    /* unpack out and inout arguments */
3046
3050
 
3070
3074
    int32_t _retval = 0;
3071
3075
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3072
3076
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3073
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3077
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3074
3078
      "SetDoubleParameter", _ex ); SIDL_CHECK(*_ex);
3075
3079
 
3076
3080
    /* pack in and inout arguments */
3090
3094
    }
3091
3095
 
3092
3096
    /* extract return value */
3093
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3094
 
      _ex);SIDL_CHECK(*_ex);
 
3097
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3098
      *_ex);
3095
3099
 
3096
3100
    /* unpack out and inout arguments */
3097
3101
 
3121
3125
    int32_t _retval = 0;
3122
3126
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3123
3127
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3124
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3128
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3125
3129
      "SetStringParameter", _ex ); SIDL_CHECK(*_ex);
3126
3130
 
3127
3131
    /* pack in and inout arguments */
3141
3145
    }
3142
3146
 
3143
3147
    /* extract return value */
3144
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3145
 
      _ex);SIDL_CHECK(*_ex);
 
3148
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3149
      *_ex);
3146
3150
 
3147
3151
    /* unpack out and inout arguments */
3148
3152
 
3172
3176
    int32_t _retval = 0;
3173
3177
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3174
3178
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3175
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3179
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3176
3180
      "SetIntArray1Parameter", _ex ); SIDL_CHECK(*_ex);
3177
3181
 
3178
3182
    /* pack in and inout arguments */
3193
3197
    }
3194
3198
 
3195
3199
    /* extract return value */
3196
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3197
 
      _ex);SIDL_CHECK(*_ex);
 
3200
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3201
      *_ex);
3198
3202
 
3199
3203
    /* unpack out and inout arguments */
3200
3204
 
3224
3228
    int32_t _retval = 0;
3225
3229
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3226
3230
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3227
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3231
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3228
3232
      "SetIntArray2Parameter", _ex ); SIDL_CHECK(*_ex);
3229
3233
 
3230
3234
    /* pack in and inout arguments */
3245
3249
    }
3246
3250
 
3247
3251
    /* extract return value */
3248
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3249
 
      _ex);SIDL_CHECK(*_ex);
 
3252
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3253
      *_ex);
3250
3254
 
3251
3255
    /* unpack out and inout arguments */
3252
3256
 
3276
3280
    int32_t _retval = 0;
3277
3281
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3278
3282
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3279
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3283
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3280
3284
      "SetDoubleArray1Parameter", _ex ); SIDL_CHECK(*_ex);
3281
3285
 
3282
3286
    /* pack in and inout arguments */
3297
3301
    }
3298
3302
 
3299
3303
    /* extract return value */
3300
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3301
 
      _ex);SIDL_CHECK(*_ex);
 
3304
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3305
      *_ex);
3302
3306
 
3303
3307
    /* unpack out and inout arguments */
3304
3308
 
3328
3332
    int32_t _retval = 0;
3329
3333
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3330
3334
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3331
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3335
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3332
3336
      "SetDoubleArray2Parameter", _ex ); SIDL_CHECK(*_ex);
3333
3337
 
3334
3338
    /* pack in and inout arguments */
3349
3353
    }
3350
3354
 
3351
3355
    /* extract return value */
3352
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3353
 
      _ex);SIDL_CHECK(*_ex);
 
3356
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3357
      *_ex);
3354
3358
 
3355
3359
    /* unpack out and inout arguments */
3356
3360
 
3380
3384
    int32_t _retval = 0;
3381
3385
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3382
3386
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3383
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3387
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3384
3388
      "GetIntValue", _ex ); SIDL_CHECK(*_ex);
3385
3389
 
3386
3390
    /* pack in and inout arguments */
3399
3403
    }
3400
3404
 
3401
3405
    /* extract return value */
3402
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3403
 
      _ex);SIDL_CHECK(*_ex);
 
3406
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3407
      *_ex);
3404
3408
 
3405
3409
    /* unpack out and inout arguments */
3406
3410
    sidl_rmi_Response_unpackInt( _rsvp, "value", value, _ex);SIDL_CHECK(*_ex);
3431
3435
    int32_t _retval = 0;
3432
3436
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3433
3437
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3434
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3438
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3435
3439
      "GetDoubleValue", _ex ); SIDL_CHECK(*_ex);
3436
3440
 
3437
3441
    /* pack in and inout arguments */
3450
3454
    }
3451
3455
 
3452
3456
    /* extract return value */
3453
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3454
 
      _ex);SIDL_CHECK(*_ex);
 
3457
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3458
      *_ex);
3455
3459
 
3456
3460
    /* unpack out and inout arguments */
3457
 
    sidl_rmi_Response_unpackDouble( _rsvp, "value", value,
3458
 
      _ex);SIDL_CHECK(*_ex);
 
3461
    sidl_rmi_Response_unpackDouble( _rsvp, "value", value, _ex);SIDL_CHECK(
 
3462
      *_ex);
3459
3463
 
3460
3464
    /* cleanup and return */
3461
3465
    EXIT:
3483
3487
    int32_t _retval = 0;
3484
3488
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3485
3489
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3486
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3490
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3487
3491
      "Setup", _ex ); SIDL_CHECK(*_ex);
3488
3492
 
3489
3493
    /* pack in and inout arguments */
3490
3494
    if(b){
3491
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
3495
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
3492
3496
        _ex);SIDL_CHECK(*_ex);
3493
3497
      sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
3494
3498
      free((void*)_url);
3496
3500
      sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
3497
3501
    }
3498
3502
    if(x){
3499
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)x,
 
3503
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)x, 
3500
3504
        _ex);SIDL_CHECK(*_ex);
3501
3505
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
3502
3506
      free((void*)_url);
3517
3521
    }
3518
3522
 
3519
3523
    /* extract return value */
3520
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3521
 
      _ex);SIDL_CHECK(*_ex);
 
3524
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3525
      *_ex);
3522
3526
 
3523
3527
    /* unpack out and inout arguments */
3524
3528
 
3549
3553
    int32_t _retval = 0;
3550
3554
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3551
3555
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3552
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3556
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3553
3557
      "Apply", _ex ); SIDL_CHECK(*_ex);
3554
3558
 
3555
3559
    /* pack in and inout arguments */
3556
3560
    if(b){
3557
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
3561
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
3558
3562
        _ex);SIDL_CHECK(*_ex);
3559
3563
      sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
3560
3564
      free((void*)_url);
3562
3566
      sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
3563
3567
    }
3564
3568
    if(*x){
3565
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x,
 
3569
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x, 
3566
3570
        _ex);SIDL_CHECK(*_ex);
3567
3571
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
3568
3572
      free((void*)_url);
3574
3578
      SIDL_CHECK(*_ex);
3575
3579
      (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((
3576
3580
        sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
3577
 
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,
3578
 
        _ex);SIDL_CHECK(*_ex); 
 
3581
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(
 
3582
        *_ex); 
3579
3583
    }
3580
3584
 
3581
3585
    /* send actual RMI request */
3591
3595
    }
3592
3596
 
3593
3597
    /* extract return value */
3594
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3595
 
      _ex);SIDL_CHECK(*_ex);
 
3598
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3599
      *_ex);
3596
3600
 
3597
3601
    /* unpack out and inout arguments */
3598
3602
    sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
3625
3629
    int32_t _retval = 0;
3626
3630
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
3627
3631
      bHYPRE_SStructDiagScale__remote*)self->d_data)->d_ih;
3628
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
3632
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
3629
3633
      "ApplyAdjoint", _ex ); SIDL_CHECK(*_ex);
3630
3634
 
3631
3635
    /* pack in and inout arguments */
3632
3636
    if(b){
3633
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
3637
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
3634
3638
        _ex);SIDL_CHECK(*_ex);
3635
3639
      sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
3636
3640
      free((void*)_url);
3638
3642
      sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
3639
3643
    }
3640
3644
    if(*x){
3641
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x,
 
3645
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x, 
3642
3646
        _ex);SIDL_CHECK(*_ex);
3643
3647
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
3644
3648
      free((void*)_url);
3650
3654
      SIDL_CHECK(*_ex);
3651
3655
      (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((
3652
3656
        sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
3653
 
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,
3654
 
        _ex);SIDL_CHECK(*_ex); 
 
3657
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(
 
3658
        *_ex); 
3655
3659
    }
3656
3660
 
3657
3661
    /* send actual RMI request */
3667
3671
    }
3668
3672
 
3669
3673
    /* extract return value */
3670
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
3671
 
      _ex);SIDL_CHECK(*_ex);
 
3674
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
3675
      *_ex);
3672
3676
 
3673
3677
    /* unpack out and inout arguments */
3674
3678
    sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
3755
3759
 
3756
3760
  e0->f__cast                    = (void* (*)(void*,const char*,
3757
3761
    sidl_BaseInterface*)) epv->f__cast;
3758
 
  e0->f__delete                  = (void (*)(void*,
3759
 
    sidl_BaseInterface*)) epv->f__delete;
3760
 
  e0->f__getURL                  = (char* (*)(void*,
3761
 
    sidl_BaseInterface*)) epv->f__getURL;
3762
 
  e0->f__raddRef                 = (void (*)(void*,
3763
 
    sidl_BaseInterface*)) epv->f__raddRef;
3764
 
  e0->f__isRemote                = (sidl_bool (*)(void*,
3765
 
    sidl_BaseInterface*)) epv->f__isRemote;
3766
 
  e0->f__set_hooks               = (void (*)(void*,int32_t,
 
3762
  e0->f__delete                  = (void (*)(void*,sidl_BaseInterface*)) 
 
3763
    epv->f__delete;
 
3764
  e0->f__getURL                  = (char* (*)(void*,sidl_BaseInterface*)) 
 
3765
    epv->f__getURL;
 
3766
  e0->f__raddRef                 = (void (*)(void*,sidl_BaseInterface*)) 
 
3767
    epv->f__raddRef;
 
3768
  e0->f__isRemote                = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
3769
    epv->f__isRemote;
 
3770
  e0->f__set_hooks               = (void (*)(void*,int32_t, 
3767
3771
    sidl_BaseInterface*)) epv->f__set_hooks;
3768
 
  e0->f__exec                    = (void (*)(void*,const char*,
3769
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
3770
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
3771
 
  e0->f_SetCommunicator          = (int32_t (*)(void*,
3772
 
    struct bHYPRE_MPICommunicator__object*,
3773
 
    struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
3774
 
  e0->f_Destroy                  = (void (*)(void*,
3775
 
    struct sidl_BaseInterface__object **)) epv->f_Destroy;
 
3772
  e0->f__exec                    = (void (*)(void*,const char*,struct 
 
3773
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3774
    sidl_BaseInterface__object **)) epv->f__exec;
 
3775
  e0->f_SetCommunicator          = (int32_t (*)(void*,struct 
 
3776
    bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
3777
    epv->f_SetCommunicator;
 
3778
  e0->f_Destroy                  = (void (*)(void*,struct 
 
3779
    sidl_BaseInterface__object **)) epv->f_Destroy;
3776
3780
  e0->f_SetIntParameter          = (int32_t (*)(void*,const char*,int32_t,
3777
3781
    struct sidl_BaseInterface__object **)) epv->f_SetIntParameter;
3778
 
  e0->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,
3779
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
 
3782
  e0->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,struct 
 
3783
    sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
3780
3784
  e0->f_SetStringParameter       = (int32_t (*)(void*,const char*,const char*,
3781
3785
    struct sidl_BaseInterface__object **)) epv->f_SetStringParameter;
3782
 
  e0->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,
3783
 
    struct sidl_int__array*,
3784
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray1Parameter;
3785
 
  e0->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,
3786
 
    struct sidl_int__array*,
3787
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray2Parameter;
3788
 
  e0->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,
3789
 
    struct sidl_double__array*,
3790
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray1Parameter;
3791
 
  e0->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,
3792
 
    struct sidl_double__array*,
3793
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray2Parameter;
 
3786
  e0->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,struct 
 
3787
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3788
    epv->f_SetIntArray1Parameter;
 
3789
  e0->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,struct 
 
3790
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3791
    epv->f_SetIntArray2Parameter;
 
3792
  e0->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,struct 
 
3793
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3794
    epv->f_SetDoubleArray1Parameter;
 
3795
  e0->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,struct 
 
3796
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3797
    epv->f_SetDoubleArray2Parameter;
3794
3798
  e0->f_GetIntValue              = (int32_t (*)(void*,const char*,int32_t*,
3795
3799
    struct sidl_BaseInterface__object **)) epv->f_GetIntValue;
3796
3800
  e0->f_GetDoubleValue           = (int32_t (*)(void*,const char*,double*,
3797
3801
    struct sidl_BaseInterface__object **)) epv->f_GetDoubleValue;
3798
 
  e0->f_Setup                    = (int32_t (*)(void*,
3799
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,
3800
 
    struct sidl_BaseInterface__object **)) epv->f_Setup;
3801
 
  e0->f_Apply                    = (int32_t (*)(void*,
3802
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3803
 
    struct sidl_BaseInterface__object **)) epv->f_Apply;
3804
 
  e0->f_ApplyAdjoint             = (int32_t (*)(void*,
3805
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3806
 
    struct sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
3807
 
  e0->f_addRef                   = (void (*)(void*,
3808
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3809
 
  e0->f_deleteRef                = (void (*)(void*,
3810
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
3811
 
  e0->f_isSame                   = (sidl_bool (*)(void*,
3812
 
    struct sidl_BaseInterface__object*,
3813
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3814
 
  e0->f_isType                   = (sidl_bool (*)(void*,const char*,
3815
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
3802
  e0->f_Setup                    = (int32_t (*)(void*,struct 
 
3803
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,struct 
 
3804
    sidl_BaseInterface__object **)) epv->f_Setup;
 
3805
  e0->f_Apply                    = (int32_t (*)(void*,struct 
 
3806
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3807
    sidl_BaseInterface__object **)) epv->f_Apply;
 
3808
  e0->f_ApplyAdjoint             = (int32_t (*)(void*,struct 
 
3809
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3810
    sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
 
3811
  e0->f_addRef                   = (void (*)(void*,struct 
 
3812
    sidl_BaseInterface__object **)) epv->f_addRef;
 
3813
  e0->f_deleteRef                = (void (*)(void*,struct 
 
3814
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3815
  e0->f_isSame                   = (sidl_bool (*)(void*,struct 
 
3816
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
3817
    epv->f_isSame;
 
3818
  e0->f_isType                   = (sidl_bool (*)(void*,const char*,struct 
 
3819
    sidl_BaseInterface__object **)) epv->f_isType;
3816
3820
  e0->f_getClassInfo             = (struct sidl_ClassInfo__object* (*)(void*,
3817
3821
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
3818
3822
 
3819
3823
  e1->f__cast                    = (void* (*)(void*,const char*,
3820
3824
    sidl_BaseInterface*)) epv->f__cast;
3821
 
  e1->f__delete                  = (void (*)(void*,
3822
 
    sidl_BaseInterface*)) epv->f__delete;
3823
 
  e1->f__getURL                  = (char* (*)(void*,
3824
 
    sidl_BaseInterface*)) epv->f__getURL;
3825
 
  e1->f__raddRef                 = (void (*)(void*,
3826
 
    sidl_BaseInterface*)) epv->f__raddRef;
3827
 
  e1->f__isRemote                = (sidl_bool (*)(void*,
3828
 
    sidl_BaseInterface*)) epv->f__isRemote;
3829
 
  e1->f__set_hooks               = (void (*)(void*,int32_t,
 
3825
  e1->f__delete                  = (void (*)(void*,sidl_BaseInterface*)) 
 
3826
    epv->f__delete;
 
3827
  e1->f__getURL                  = (char* (*)(void*,sidl_BaseInterface*)) 
 
3828
    epv->f__getURL;
 
3829
  e1->f__raddRef                 = (void (*)(void*,sidl_BaseInterface*)) 
 
3830
    epv->f__raddRef;
 
3831
  e1->f__isRemote                = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
3832
    epv->f__isRemote;
 
3833
  e1->f__set_hooks               = (void (*)(void*,int32_t, 
3830
3834
    sidl_BaseInterface*)) epv->f__set_hooks;
3831
 
  e1->f__exec                    = (void (*)(void*,const char*,
3832
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
3833
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
3834
 
  e1->f_SetOperator              = (int32_t (*)(void*,
3835
 
    struct bHYPRE_Operator__object*,
3836
 
    struct sidl_BaseInterface__object **)) epv->f_SetOperator;
3837
 
  e1->f_SetTolerance             = (int32_t (*)(void*,double,
3838
 
    struct sidl_BaseInterface__object **)) epv->f_SetTolerance;
3839
 
  e1->f_SetMaxIterations         = (int32_t (*)(void*,int32_t,
3840
 
    struct sidl_BaseInterface__object **)) epv->f_SetMaxIterations;
3841
 
  e1->f_SetLogging               = (int32_t (*)(void*,int32_t,
3842
 
    struct sidl_BaseInterface__object **)) epv->f_SetLogging;
3843
 
  e1->f_SetPrintLevel            = (int32_t (*)(void*,int32_t,
3844
 
    struct sidl_BaseInterface__object **)) epv->f_SetPrintLevel;
3845
 
  e1->f_GetNumIterations         = (int32_t (*)(void*,int32_t*,
3846
 
    struct sidl_BaseInterface__object **)) epv->f_GetNumIterations;
3847
 
  e1->f_GetRelResidualNorm       = (int32_t (*)(void*,double*,
3848
 
    struct sidl_BaseInterface__object **)) epv->f_GetRelResidualNorm;
3849
 
  e1->f_SetCommunicator          = (int32_t (*)(void*,
3850
 
    struct bHYPRE_MPICommunicator__object*,
3851
 
    struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
3852
 
  e1->f_Destroy                  = (void (*)(void*,
3853
 
    struct sidl_BaseInterface__object **)) epv->f_Destroy;
 
3835
  e1->f__exec                    = (void (*)(void*,const char*,struct 
 
3836
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3837
    sidl_BaseInterface__object **)) epv->f__exec;
 
3838
  e1->f_SetOperator              = (int32_t (*)(void*,struct 
 
3839
    bHYPRE_Operator__object*,struct sidl_BaseInterface__object **)) 
 
3840
    epv->f_SetOperator;
 
3841
  e1->f_SetTolerance             = (int32_t (*)(void*,double,struct 
 
3842
    sidl_BaseInterface__object **)) epv->f_SetTolerance;
 
3843
  e1->f_SetMaxIterations         = (int32_t (*)(void*,int32_t,struct 
 
3844
    sidl_BaseInterface__object **)) epv->f_SetMaxIterations;
 
3845
  e1->f_SetLogging               = (int32_t (*)(void*,int32_t,struct 
 
3846
    sidl_BaseInterface__object **)) epv->f_SetLogging;
 
3847
  e1->f_SetPrintLevel            = (int32_t (*)(void*,int32_t,struct 
 
3848
    sidl_BaseInterface__object **)) epv->f_SetPrintLevel;
 
3849
  e1->f_GetNumIterations         = (int32_t (*)(void*,int32_t*,struct 
 
3850
    sidl_BaseInterface__object **)) epv->f_GetNumIterations;
 
3851
  e1->f_GetRelResidualNorm       = (int32_t (*)(void*,double*,struct 
 
3852
    sidl_BaseInterface__object **)) epv->f_GetRelResidualNorm;
 
3853
  e1->f_SetCommunicator          = (int32_t (*)(void*,struct 
 
3854
    bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
3855
    epv->f_SetCommunicator;
 
3856
  e1->f_Destroy                  = (void (*)(void*,struct 
 
3857
    sidl_BaseInterface__object **)) epv->f_Destroy;
3854
3858
  e1->f_SetIntParameter          = (int32_t (*)(void*,const char*,int32_t,
3855
3859
    struct sidl_BaseInterface__object **)) epv->f_SetIntParameter;
3856
 
  e1->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,
3857
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
 
3860
  e1->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,struct 
 
3861
    sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
3858
3862
  e1->f_SetStringParameter       = (int32_t (*)(void*,const char*,const char*,
3859
3863
    struct sidl_BaseInterface__object **)) epv->f_SetStringParameter;
3860
 
  e1->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,
3861
 
    struct sidl_int__array*,
3862
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray1Parameter;
3863
 
  e1->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,
3864
 
    struct sidl_int__array*,
3865
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray2Parameter;
3866
 
  e1->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,
3867
 
    struct sidl_double__array*,
3868
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray1Parameter;
3869
 
  e1->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,
3870
 
    struct sidl_double__array*,
3871
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray2Parameter;
 
3864
  e1->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,struct 
 
3865
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3866
    epv->f_SetIntArray1Parameter;
 
3867
  e1->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,struct 
 
3868
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3869
    epv->f_SetIntArray2Parameter;
 
3870
  e1->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,struct 
 
3871
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3872
    epv->f_SetDoubleArray1Parameter;
 
3873
  e1->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,struct 
 
3874
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3875
    epv->f_SetDoubleArray2Parameter;
3872
3876
  e1->f_GetIntValue              = (int32_t (*)(void*,const char*,int32_t*,
3873
3877
    struct sidl_BaseInterface__object **)) epv->f_GetIntValue;
3874
3878
  e1->f_GetDoubleValue           = (int32_t (*)(void*,const char*,double*,
3875
3879
    struct sidl_BaseInterface__object **)) epv->f_GetDoubleValue;
3876
 
  e1->f_Setup                    = (int32_t (*)(void*,
3877
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,
3878
 
    struct sidl_BaseInterface__object **)) epv->f_Setup;
3879
 
  e1->f_Apply                    = (int32_t (*)(void*,
3880
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3881
 
    struct sidl_BaseInterface__object **)) epv->f_Apply;
3882
 
  e1->f_ApplyAdjoint             = (int32_t (*)(void*,
3883
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3884
 
    struct sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
3885
 
  e1->f_addRef                   = (void (*)(void*,
3886
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3887
 
  e1->f_deleteRef                = (void (*)(void*,
3888
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
3889
 
  e1->f_isSame                   = (sidl_bool (*)(void*,
3890
 
    struct sidl_BaseInterface__object*,
3891
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3892
 
  e1->f_isType                   = (sidl_bool (*)(void*,const char*,
3893
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
3880
  e1->f_Setup                    = (int32_t (*)(void*,struct 
 
3881
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,struct 
 
3882
    sidl_BaseInterface__object **)) epv->f_Setup;
 
3883
  e1->f_Apply                    = (int32_t (*)(void*,struct 
 
3884
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3885
    sidl_BaseInterface__object **)) epv->f_Apply;
 
3886
  e1->f_ApplyAdjoint             = (int32_t (*)(void*,struct 
 
3887
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3888
    sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
 
3889
  e1->f_addRef                   = (void (*)(void*,struct 
 
3890
    sidl_BaseInterface__object **)) epv->f_addRef;
 
3891
  e1->f_deleteRef                = (void (*)(void*,struct 
 
3892
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3893
  e1->f_isSame                   = (sidl_bool (*)(void*,struct 
 
3894
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
3895
    epv->f_isSame;
 
3896
  e1->f_isType                   = (sidl_bool (*)(void*,const char*,struct 
 
3897
    sidl_BaseInterface__object **)) epv->f_isType;
3894
3898
  e1->f_getClassInfo             = (struct sidl_ClassInfo__object* (*)(void*,
3895
3899
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
3896
3900
 
3904
3908
    sidl_BaseInterface*)) epv->f__raddRef;
3905
3909
  e2->f__isRemote    = (sidl_bool (*)(struct sidl_BaseClass__object*,
3906
3910
    sidl_BaseInterface*)) epv->f__isRemote;
3907
 
  e2->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t,
 
3911
  e2->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t, 
3908
3912
    sidl_BaseInterface*)) epv->f__set_hooks;
3909
3913
  e2->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,
3910
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
3911
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
3912
 
  e2->f_addRef       = (void (*)(struct sidl_BaseClass__object*,
3913
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3914
 
  e2->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,
3915
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
3916
 
  e2->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,
3917
 
    struct sidl_BaseInterface__object*,
3918
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3919
 
  e2->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,
3920
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
3914
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3915
    sidl_BaseInterface__object **)) epv->f__exec;
 
3916
  e2->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct 
 
3917
    sidl_BaseInterface__object **)) epv->f_addRef;
 
3918
  e2->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct 
 
3919
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3920
  e2->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct 
 
3921
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
3922
    epv->f_isSame;
 
3923
  e2->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const 
 
3924
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
3921
3925
  e2->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
3922
 
    sidl_BaseClass__object*,
3923
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
3926
    sidl_BaseClass__object*,struct sidl_BaseInterface__object **)) 
 
3927
    epv->f_getClassInfo;
3924
3928
 
3925
 
  e3->f__cast        = (void* (*)(void*,const char*,
3926
 
    sidl_BaseInterface*)) epv->f__cast;
 
3929
  e3->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
3930
    epv->f__cast;
3927
3931
  e3->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
3928
3932
  e3->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
3929
3933
  e3->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
3930
 
  e3->f__isRemote    = (sidl_bool (*)(void*,
3931
 
    sidl_BaseInterface*)) epv->f__isRemote;
3932
 
  e3->f__set_hooks   = (void (*)(void*,int32_t,
3933
 
    sidl_BaseInterface*)) epv->f__set_hooks;
3934
 
  e3->f__exec        = (void (*)(void*,const char*,
3935
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
3936
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
3937
 
  e3->f_addRef       = (void (*)(void*,
3938
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3939
 
  e3->f_deleteRef    = (void (*)(void*,
3940
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3934
  e3->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
3935
    epv->f__isRemote;
 
3936
  e3->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
3937
    epv->f__set_hooks;
 
3938
  e3->f__exec        = (void (*)(void*,const char*,struct 
 
3939
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3940
    sidl_BaseInterface__object **)) epv->f__exec;
 
3941
  e3->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
3942
    epv->f_addRef;
 
3943
  e3->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
3944
    epv->f_deleteRef;
3941
3945
  e3->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
3942
3946
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3943
 
  e3->f_isType       = (sidl_bool (*)(void*,const char*,
3944
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
3945
 
  e3->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
3946
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
3947
  e3->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
3948
    sidl_BaseInterface__object **)) epv->f_isType;
 
3949
  e3->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
3950
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
3947
3951
 
3948
3952
  s_remote_initialized = 1;
3949
3953
}
3950
3954
 
3951
3955
/* Create an instance that connects to an existing remote object. */
3952
3956
static struct bHYPRE_SStructDiagScale__object*
3953
 
bHYPRE_SStructDiagScale__remoteConnect(const char *url, sidl_bool ar,
 
3957
bHYPRE_SStructDiagScale__remoteConnect(const char *url, sidl_bool ar, 
3954
3958
  sidl_BaseInterface *_ex)
3955
3959
{
3956
3960
  struct bHYPRE_SStructDiagScale__object* self;
3966
3970
  if(url == NULL) {return NULL;}
3967
3971
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
3968
3972
  if(objectID) {
3969
 
    sidl_BaseInterface bi = 
3970
 
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
3971
 
      objectID, _ex); SIDL_CHECK(*_ex);
 
3973
    sidl_BaseInterface bi = (
 
3974
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(objectID,
 
3975
      _ex); SIDL_CHECK(*_ex);
3972
3976
    return bHYPRE_SStructDiagScale__rmicast(bi,_ex);SIDL_CHECK(*_ex);
3973
3977
  }
3974
 
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar,
3975
 
    _ex ); SIDL_CHECK(*_ex);
 
3978
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex ); 
 
3979
    SIDL_CHECK(*_ex);
3976
3980
  if ( instance == NULL) { return NULL; }
3977
3981
  self =
3978
3982
    (struct bHYPRE_SStructDiagScale__object*) malloc(
4017
4021
/* Create an instance that uses an already existing  */
4018
4022
/* InstanceHandle to connect to an existing remote object. */
4019
4023
static struct bHYPRE_SStructDiagScale__object*
4020
 
bHYPRE_SStructDiagScale__IHConnect(sidl_rmi_InstanceHandle instance,
 
4024
bHYPRE_SStructDiagScale__IHConnect(sidl_rmi_InstanceHandle instance, 
4021
4025
  sidl_BaseInterface *_ex)
4022
4026
{
4023
4027
  struct bHYPRE_SStructDiagScale__object* self;
4078
4082
  struct sidl_BaseClass__object* s1;
4079
4083
 
4080
4084
  struct bHYPRE_SStructDiagScale__remote* r_obj;
4081
 
  sidl_rmi_InstanceHandle instance = 
4082
 
    sidl_rmi_ProtocolFactory_createInstance(url, "bHYPRE.SStructDiagScale",
4083
 
    _ex ); SIDL_CHECK(*_ex);
 
4085
  sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance(
 
4086
    url, "bHYPRE.SStructDiagScale", _ex ); SIDL_CHECK(*_ex);
4084
4087
  if ( instance == NULL) { return NULL; }
4085
4088
  self =
4086
4089
    (struct bHYPRE_SStructDiagScale__object*) malloc(
4120
4123
 
4121
4124
  return self;
4122
4125
  EXIT:
4123
 
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance,
 
4126
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance, 
4124
4127
    &_throwaway_exception); }
4125
4128
  return NULL;
4126
4129
}
4137
4140
 
4138
4141
  *_ex = NULL;
4139
4142
  if(!connect_loaded) {
4140
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructDiagScale",
4141
 
      (void*)bHYPRE_SStructDiagScale__IHConnect, _ex);
 
4143
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructDiagScale", (
 
4144
      void*)bHYPRE_SStructDiagScale__IHConnect, _ex);
4142
4145
    connect_loaded = 1;
4143
4146
  }
4144
4147
  if (obj != NULL) {
4159
4162
 */
4160
4163
 
4161
4164
struct bHYPRE_SStructDiagScale__object*
4162
 
bHYPRE_SStructDiagScale__connectI(const char* url, sidl_bool ar,
4163
 
  struct sidl_BaseInterface__object **_ex)
 
4165
bHYPRE_SStructDiagScale__connectI(const char* url, sidl_bool ar, struct 
 
4166
  sidl_BaseInterface__object **_ex)
4164
4167
{
4165
4168
  return bHYPRE_SStructDiagScale__remoteConnect(url, ar, _ex);
4166
4169
}