← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/babel/bHYPREClient-CX/bHYPRE_IJParCSRMatrix.cxx

  • 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-CX/bHYPRE_IJParCSRMatrix.cxx
2
2
// File:          bHYPRE_IJParCSRMatrix.cxx
3
3
// Symbol:        bHYPRE.IJParCSRMatrix-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.IJParCSRMatrix
7
7
// 
8
8
// WARNING: Automatically generated; changes will be lost
124
124
#endif
125
125
 
126
126
  // Static variables to hold version of IOR
127
 
  static const int32_t s_IOR_MAJOR_VERSION = 0;
128
 
  static const int32_t s_IOR_MINOR_VERSION = 10;
 
127
  static const int32_t s_IOR_MAJOR_VERSION = 1;
 
128
  static const int32_t s_IOR_MINOR_VERSION = 0;
129
129
 
130
130
  // Static variables for managing EPV initialization.
131
131
  static int s_remote_initialized = 0;
171
171
      cmp1 = strcmp(name, "bHYPRE.IJParCSRMatrix");
172
172
      if (!cmp1) {
173
173
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
174
 
        cast = self;
 
174
        cast = ((struct bHYPRE_IJParCSRMatrix__object*)self);
175
175
        return cast;
176
176
      }
177
177
      else if (cmp1 < 0) {
203
203
      cmp1 = strcmp(name, "sidl.BaseClass");
204
204
      if (!cmp1) {
205
205
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
206
 
        cast = self;
 
206
        cast = ((struct sidl_BaseClass__object*)self);
207
207
        return cast;
208
208
      }
209
209
      else if (cmp1 < 0) {
224
224
      }
225
225
    }
226
226
    if ((*self->d_epv->f_isType)(self,name, _ex)) {
227
 
      void* (*func)(struct sidl_rmi_InstanceHandle__object*,
228
 
        struct sidl_BaseInterface__object**) = 
229
 
        (void* (*)(struct sidl_rmi_InstanceHandle__object*,
230
 
          struct sidl_BaseInterface__object**)) 
 
227
      void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct 
 
228
        sidl_BaseInterface__object**) = 
 
229
        (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct 
 
230
          sidl_BaseInterface__object**)) 
231
231
        sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
232
232
      cast =  (*func)(((struct 
233
233
        bHYPRE_IJParCSRMatrix__remote*)self->d_data)->d_ih, _ex);
270
270
    struct sidl_rmi_InstanceHandle__object *_conn = ((struct 
271
271
      bHYPRE_IJParCSRMatrix__remote*)self->d_data)->d_ih;
272
272
    sidl_rmi_Response _rsvp = NULL;
273
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
273
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
274
274
      "addRef", _ex ); SIDL_CHECK(*_ex);
275
275
    // send actual RMI request
276
276
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
393
393
      }
394
394
 
395
395
      // extract return value
396
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
397
 
        _ex);SIDL_CHECK(*_ex);
 
396
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
397
        *_ex);
398
398
 
399
399
      // unpack out and inout arguments
400
400
 
467
467
 
468
468
      // pack in and inout arguments
469
469
      if(iobj){
470
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,
471
 
          _ex);SIDL_CHECK(*_ex);
472
 
        sidl_rmi_Invocation_packString( _inv, "iobj", _url,
473
 
          _ex);SIDL_CHECK(*_ex);
 
470
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj, 
 
471
          _ex);SIDL_CHECK(*_ex);
 
472
        sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(
 
473
          *_ex);
474
474
        free((void*)_url);
475
475
      } else {
476
 
        sidl_rmi_Invocation_packString( _inv, "iobj", NULL,
477
 
          _ex);SIDL_CHECK(*_ex);
 
476
        sidl_rmi_Invocation_packString( _inv, "iobj", NULL, _ex);SIDL_CHECK(
 
477
          *_ex);
478
478
      }
479
479
 
480
480
      // send actual RMI request
490
490
      }
491
491
 
492
492
      // extract return value
493
 
      sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
494
 
        _ex);SIDL_CHECK(*_ex);
 
493
      sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
494
        *_ex);
495
495
 
496
496
      // unpack out and inout arguments
497
497
 
539
539
      }
540
540
 
541
541
      // extract return value
542
 
      sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
543
 
        _ex);SIDL_CHECK(*_ex);
 
542
      sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
543
        *_ex);
544
544
 
545
545
      // unpack out and inout arguments
546
546
 
587
587
      }
588
588
 
589
589
      // extract return value
590
 
      sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
591
 
        _ex);SIDL_CHECK(*_ex);
592
 
      _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,
593
 
        _ex);SIDL_CHECK(*_ex);
 
590
      sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
591
        _ex);SIDL_CHECK(*_ex);
 
592
      _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
593
        *_ex);
594
594
 
595
595
      // unpack out and inout arguments
596
596
 
626
626
        _conn, "SetLocalRange", _ex ); SIDL_CHECK(*_ex);
627
627
 
628
628
      // pack in and inout arguments
629
 
      sidl_rmi_Invocation_packInt( _inv, "ilower", ilower,
630
 
        _ex);SIDL_CHECK(*_ex);
631
 
      sidl_rmi_Invocation_packInt( _inv, "iupper", iupper,
632
 
        _ex);SIDL_CHECK(*_ex);
633
 
      sidl_rmi_Invocation_packInt( _inv, "jlower", jlower,
634
 
        _ex);SIDL_CHECK(*_ex);
635
 
      sidl_rmi_Invocation_packInt( _inv, "jupper", jupper,
636
 
        _ex);SIDL_CHECK(*_ex);
 
629
      sidl_rmi_Invocation_packInt( _inv, "ilower", ilower, _ex);SIDL_CHECK(
 
630
        *_ex);
 
631
      sidl_rmi_Invocation_packInt( _inv, "iupper", iupper, _ex);SIDL_CHECK(
 
632
        *_ex);
 
633
      sidl_rmi_Invocation_packInt( _inv, "jlower", jlower, _ex);SIDL_CHECK(
 
634
        *_ex);
 
635
      sidl_rmi_Invocation_packInt( _inv, "jupper", jupper, _ex);SIDL_CHECK(
 
636
        *_ex);
637
637
 
638
638
      // send actual RMI request
639
639
      _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
648
648
      }
649
649
 
650
650
      // extract return value
651
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
652
 
        _ex);SIDL_CHECK(*_ex);
 
651
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
652
        *_ex);
653
653
 
654
654
      // unpack out and inout arguments
655
655
 
707
707
      }
708
708
 
709
709
      // extract return value
710
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
711
 
        _ex);SIDL_CHECK(*_ex);
 
710
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
711
        *_ex);
712
712
 
713
713
      // unpack out and inout arguments
714
714
 
766
766
      }
767
767
 
768
768
      // extract return value
769
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
770
 
        _ex);SIDL_CHECK(*_ex);
 
769
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
770
        *_ex);
771
771
 
772
772
      // unpack out and inout arguments
773
773
 
817
817
      }
818
818
 
819
819
      // extract return value
820
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
821
 
        _ex);SIDL_CHECK(*_ex);
 
820
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
821
        *_ex);
822
822
 
823
823
      // unpack out and inout arguments
824
 
      sidl_rmi_Response_unpackInt( _rsvp, "ilower", ilower,
825
 
        _ex);SIDL_CHECK(*_ex);
826
 
      sidl_rmi_Response_unpackInt( _rsvp, "iupper", iupper,
827
 
        _ex);SIDL_CHECK(*_ex);
828
 
      sidl_rmi_Response_unpackInt( _rsvp, "jlower", jlower,
829
 
        _ex);SIDL_CHECK(*_ex);
830
 
      sidl_rmi_Response_unpackInt( _rsvp, "jupper", jupper,
831
 
        _ex);SIDL_CHECK(*_ex);
 
824
      sidl_rmi_Response_unpackInt( _rsvp, "ilower", ilower, _ex);SIDL_CHECK(
 
825
        *_ex);
 
826
      sidl_rmi_Response_unpackInt( _rsvp, "iupper", iupper, _ex);SIDL_CHECK(
 
827
        *_ex);
 
828
      sidl_rmi_Response_unpackInt( _rsvp, "jlower", jlower, _ex);SIDL_CHECK(
 
829
        *_ex);
 
830
      sidl_rmi_Response_unpackInt( _rsvp, "jupper", jupper, _ex);SIDL_CHECK(
 
831
        *_ex);
832
832
 
833
833
      // cleanup and return
834
834
      EXIT:
878
878
      }
879
879
 
880
880
      // extract return value
881
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
882
 
        _ex);SIDL_CHECK(*_ex);
 
881
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
882
        *_ex);
883
883
 
884
884
      // unpack out and inout arguments
885
885
      sidl_rmi_Response_unpackIntArray( _rsvp, "ncols", ncols,
939
939
      }
940
940
 
941
941
      // extract return value
942
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
943
 
        _ex);SIDL_CHECK(*_ex);
 
942
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
943
        *_ex);
944
944
 
945
945
      // unpack out and inout arguments
946
946
      sidl_rmi_Response_unpackDoubleArray( _rsvp, "values", values,
991
991
      }
992
992
 
993
993
      // extract return value
994
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
995
 
        _ex);SIDL_CHECK(*_ex);
 
994
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
995
        *_ex);
996
996
 
997
997
      // unpack out and inout arguments
998
998
 
1025
1025
        _conn, "Print", _ex ); SIDL_CHECK(*_ex);
1026
1026
 
1027
1027
      // pack in and inout arguments
1028
 
      sidl_rmi_Invocation_packString( _inv, "filename", filename,
 
1028
      sidl_rmi_Invocation_packString( _inv, "filename", filename, 
1029
1029
        _ex);SIDL_CHECK(*_ex);
1030
1030
 
1031
1031
      // send actual RMI request
1041
1041
      }
1042
1042
 
1043
1043
      // extract return value
1044
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1045
 
        _ex);SIDL_CHECK(*_ex);
 
1044
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1045
        *_ex);
1046
1046
 
1047
1047
      // unpack out and inout arguments
1048
1048
 
1076
1076
        _conn, "Read", _ex ); SIDL_CHECK(*_ex);
1077
1077
 
1078
1078
      // pack in and inout arguments
1079
 
      sidl_rmi_Invocation_packString( _inv, "filename", filename,
 
1079
      sidl_rmi_Invocation_packString( _inv, "filename", filename, 
1080
1080
        _ex);SIDL_CHECK(*_ex);
1081
1081
      if(comm){
1082
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)comm,
1083
 
          _ex);SIDL_CHECK(*_ex);
1084
 
        sidl_rmi_Invocation_packString( _inv, "comm", _url,
1085
 
          _ex);SIDL_CHECK(*_ex);
 
1082
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)comm, 
 
1083
          _ex);SIDL_CHECK(*_ex);
 
1084
        sidl_rmi_Invocation_packString( _inv, "comm", _url, _ex);SIDL_CHECK(
 
1085
          *_ex);
1086
1086
        free((void*)_url);
1087
1087
      } else {
1088
 
        sidl_rmi_Invocation_packString( _inv, "comm", NULL,
1089
 
          _ex);SIDL_CHECK(*_ex);
 
1088
        sidl_rmi_Invocation_packString( _inv, "comm", NULL, _ex);SIDL_CHECK(
 
1089
          *_ex);
1090
1090
      }
1091
1091
 
1092
1092
      // send actual RMI request
1102
1102
      }
1103
1103
 
1104
1104
      // extract return value
1105
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1106
 
        _ex);SIDL_CHECK(*_ex);
 
1105
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1106
        *_ex);
1107
1107
 
1108
1108
      // unpack out and inout arguments
1109
1109
 
1137
1137
 
1138
1138
      // pack in and inout arguments
1139
1139
      if(mpi_comm){
1140
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm,
1141
 
          _ex);SIDL_CHECK(*_ex);
1142
 
        sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url,
1143
 
          _ex);SIDL_CHECK(*_ex);
 
1140
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm, 
 
1141
          _ex);SIDL_CHECK(*_ex);
 
1142
        sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url, _ex);SIDL_CHECK(
 
1143
          *_ex);
1144
1144
        free((void*)_url);
1145
1145
      } else {
1146
 
        sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL,
1147
 
          _ex);SIDL_CHECK(*_ex);
 
1146
        sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL, _ex);SIDL_CHECK(
 
1147
          *_ex);
1148
1148
      }
1149
1149
 
1150
1150
      // send actual RMI request
1160
1160
      }
1161
1161
 
1162
1162
      // extract return value
1163
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1164
 
        _ex);SIDL_CHECK(*_ex);
 
1163
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1164
        *_ex);
1165
1165
 
1166
1166
      // unpack out and inout arguments
1167
1167
 
1249
1249
      }
1250
1250
 
1251
1251
      // extract return value
1252
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1253
 
        _ex);SIDL_CHECK(*_ex);
 
1252
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1253
        *_ex);
1254
1254
 
1255
1255
      // unpack out and inout arguments
1256
1256
 
1296
1296
      }
1297
1297
 
1298
1298
      // extract return value
1299
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1300
 
        _ex);SIDL_CHECK(*_ex);
 
1299
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1300
        *_ex);
1301
1301
 
1302
1302
      // unpack out and inout arguments
1303
1303
 
1347
1347
      }
1348
1348
 
1349
1349
      // extract return value
1350
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1351
 
        _ex);SIDL_CHECK(*_ex);
 
1350
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1351
        *_ex);
1352
1352
 
1353
1353
      // unpack out and inout arguments
1354
1354
 
1383
1383
 
1384
1384
      // pack in and inout arguments
1385
1385
      sidl_rmi_Invocation_packString( _inv, "name", name, _ex);SIDL_CHECK(*_ex);
1386
 
      sidl_rmi_Invocation_packDouble( _inv, "value", value,
1387
 
        _ex);SIDL_CHECK(*_ex);
 
1386
      sidl_rmi_Invocation_packDouble( _inv, "value", value, _ex);SIDL_CHECK(
 
1387
        *_ex);
1388
1388
 
1389
1389
      // send actual RMI request
1390
1390
      _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
1399
1399
      }
1400
1400
 
1401
1401
      // extract return value
1402
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1403
 
        _ex);SIDL_CHECK(*_ex);
 
1402
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1403
        *_ex);
1404
1404
 
1405
1405
      // unpack out and inout arguments
1406
1406
 
1435
1435
 
1436
1436
      // pack in and inout arguments
1437
1437
      sidl_rmi_Invocation_packString( _inv, "name", name, _ex);SIDL_CHECK(*_ex);
1438
 
      sidl_rmi_Invocation_packString( _inv, "value", value,
1439
 
        _ex);SIDL_CHECK(*_ex);
 
1438
      sidl_rmi_Invocation_packString( _inv, "value", value, _ex);SIDL_CHECK(
 
1439
        *_ex);
1440
1440
 
1441
1441
      // send actual RMI request
1442
1442
      _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
1451
1451
      }
1452
1452
 
1453
1453
      // extract return value
1454
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1455
 
        _ex);SIDL_CHECK(*_ex);
 
1454
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1455
        *_ex);
1456
1456
 
1457
1457
      // unpack out and inout arguments
1458
1458
 
1503
1503
      }
1504
1504
 
1505
1505
      // extract return value
1506
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1507
 
        _ex);SIDL_CHECK(*_ex);
 
1506
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1507
        *_ex);
1508
1508
 
1509
1509
      // unpack out and inout arguments
1510
1510
 
1555
1555
      }
1556
1556
 
1557
1557
      // extract return value
1558
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1559
 
        _ex);SIDL_CHECK(*_ex);
 
1558
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1559
        *_ex);
1560
1560
 
1561
1561
      // unpack out and inout arguments
1562
1562
 
1607
1607
      }
1608
1608
 
1609
1609
      // extract return value
1610
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1611
 
        _ex);SIDL_CHECK(*_ex);
 
1610
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1611
        *_ex);
1612
1612
 
1613
1613
      // unpack out and inout arguments
1614
1614
 
1659
1659
      }
1660
1660
 
1661
1661
      // extract return value
1662
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1663
 
        _ex);SIDL_CHECK(*_ex);
 
1662
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1663
        *_ex);
1664
1664
 
1665
1665
      // unpack out and inout arguments
1666
1666
 
1709
1709
      }
1710
1710
 
1711
1711
      // extract return value
1712
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1713
 
        _ex);SIDL_CHECK(*_ex);
 
1712
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1713
        *_ex);
1714
1714
 
1715
1715
      // unpack out and inout arguments
1716
1716
      sidl_rmi_Response_unpackInt( _rsvp, "value", value, _ex);SIDL_CHECK(*_ex);
1760
1760
      }
1761
1761
 
1762
1762
      // extract return value
1763
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1764
 
        _ex);SIDL_CHECK(*_ex);
 
1763
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1764
        *_ex);
1765
1765
 
1766
1766
      // unpack out and inout arguments
1767
 
      sidl_rmi_Response_unpackDouble( _rsvp, "value", value,
1768
 
        _ex);SIDL_CHECK(*_ex);
 
1767
      sidl_rmi_Response_unpackDouble( _rsvp, "value", value, _ex);SIDL_CHECK(
 
1768
        *_ex);
1769
1769
 
1770
1770
      // cleanup and return
1771
1771
      EXIT:
1798
1798
 
1799
1799
      // pack in and inout arguments
1800
1800
      if(b){
1801
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
1801
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
1802
1802
          _ex);SIDL_CHECK(*_ex);
1803
1803
        sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
1804
1804
        free((void*)_url);
1806
1806
        sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
1807
1807
      }
1808
1808
      if(x){
1809
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)x,
 
1809
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)x, 
1810
1810
          _ex);SIDL_CHECK(*_ex);
1811
1811
        sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
1812
1812
        free((void*)_url);
1827
1827
      }
1828
1828
 
1829
1829
      // extract return value
1830
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1831
 
        _ex);SIDL_CHECK(*_ex);
 
1830
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1831
        *_ex);
1832
1832
 
1833
1833
      // unpack out and inout arguments
1834
1834
 
1864
1864
 
1865
1865
      // pack in and inout arguments
1866
1866
      if(b){
1867
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
1867
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
1868
1868
          _ex);SIDL_CHECK(*_ex);
1869
1869
        sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
1870
1870
        free((void*)_url);
1872
1872
        sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
1873
1873
      }
1874
1874
      if(*x){
1875
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x,
 
1875
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x, 
1876
1876
          _ex);SIDL_CHECK(*_ex);
1877
1877
        sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
1878
1878
        free((void*)_url);
1884
1884
        SIDL_CHECK(*_ex);
1885
1885
        (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((
1886
1886
          sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
1887
 
        sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,
1888
 
          _ex);SIDL_CHECK(*_ex); 
 
1887
        sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(
 
1888
          *_ex); 
1889
1889
      }
1890
1890
 
1891
1891
      // send actual RMI request
1901
1901
      }
1902
1902
 
1903
1903
      // extract return value
1904
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1905
 
        _ex);SIDL_CHECK(*_ex);
 
1904
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1905
        *_ex);
1906
1906
 
1907
1907
      // unpack out and inout arguments
1908
1908
      sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
1940
1940
 
1941
1941
      // pack in and inout arguments
1942
1942
      if(b){
1943
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
1943
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
1944
1944
          _ex);SIDL_CHECK(*_ex);
1945
1945
        sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
1946
1946
        free((void*)_url);
1948
1948
        sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
1949
1949
      }
1950
1950
      if(*x){
1951
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x,
 
1951
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x, 
1952
1952
          _ex);SIDL_CHECK(*_ex);
1953
1953
        sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
1954
1954
        free((void*)_url);
1960
1960
        SIDL_CHECK(*_ex);
1961
1961
        (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((
1962
1962
          sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
1963
 
        sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,
1964
 
          _ex);SIDL_CHECK(*_ex); 
 
1963
        sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(
 
1964
          *_ex); 
1965
1965
      }
1966
1966
 
1967
1967
      // send actual RMI request
1977
1977
      }
1978
1978
 
1979
1979
      // extract return value
1980
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1981
 
        _ex);SIDL_CHECK(*_ex);
 
1980
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1981
        *_ex);
1982
1982
 
1983
1983
      // unpack out and inout arguments
1984
1984
      sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
2031
2031
      }
2032
2032
 
2033
2033
      // extract return value
2034
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2035
 
        _ex);SIDL_CHECK(*_ex);
 
2034
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2035
        *_ex);
2036
2036
 
2037
2037
      // unpack out and inout arguments
2038
2038
      sidl_rmi_Response_unpackInt( _rsvp, "size", size, _ex);SIDL_CHECK(*_ex);
2135
2135
      remote_bHYPRE_IJParCSRMatrix_ApplyAdjoint;
2136
2136
    epv->f_GetRow                        = remote_bHYPRE_IJParCSRMatrix_GetRow;
2137
2137
 
2138
 
    e0->f__cast        = (void* (*)(void*,const char*,
2139
 
      sidl_BaseInterface*)) epv->f__cast;
 
2138
    e0->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
2139
      epv->f__cast;
2140
2140
    e0->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
2141
2141
    e0->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
2142
2142
    e0->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
2143
 
    e0->f__isRemote    = (sidl_bool (*)(void*,
2144
 
      sidl_BaseInterface*)) epv->f__isRemote;
2145
 
    e0->f__set_hooks   = (void (*)(void*,int32_t,
2146
 
      sidl_BaseInterface*)) epv->f__set_hooks;
2147
 
    e0->f__exec        = (void (*)(void*,const char*,
2148
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2149
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
2150
 
    e0->f_GetRow       = (int32_t (*)(void*,int32_t,int32_t*,
2151
 
      struct sidl_int__array**,struct sidl_double__array**,
2152
 
      struct sidl_BaseInterface__object **)) epv->f_GetRow;
2153
 
    e0->f_addRef       = (void (*)(void*,
2154
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
2155
 
    e0->f_deleteRef    = (void (*)(void*,
2156
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
2157
 
    e0->f_isSame       = (sidl_bool (*)(void*,
2158
 
      struct sidl_BaseInterface__object*,
2159
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
2160
 
    e0->f_isType       = (sidl_bool (*)(void*,const char*,
2161
 
      struct sidl_BaseInterface__object **)) epv->f_isType;
2162
 
    e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
2163
 
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2143
    e0->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
2144
      epv->f__isRemote;
 
2145
    e0->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
2146
      epv->f__set_hooks;
 
2147
    e0->f__exec        = (void (*)(void*,const char*,struct 
 
2148
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2149
      sidl_BaseInterface__object **)) epv->f__exec;
 
2150
    e0->f_GetRow       = (int32_t (*)(void*,int32_t,int32_t*,struct 
 
2151
      sidl_int__array**,struct sidl_double__array**,struct 
 
2152
      sidl_BaseInterface__object **)) epv->f_GetRow;
 
2153
    e0->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2154
      epv->f_addRef;
 
2155
    e0->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2156
      epv->f_deleteRef;
 
2157
    e0->f_isSame       = (sidl_bool (*)(void*,struct 
 
2158
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2159
      epv->f_isSame;
 
2160
    e0->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
2161
      sidl_BaseInterface__object **)) epv->f_isType;
 
2162
    e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2163
      sidl_BaseInterface__object **)) epv->f_getClassInfo;
2164
2164
 
2165
 
    e1->f__cast           = (void* (*)(void*,const char*,
2166
 
      sidl_BaseInterface*)) epv->f__cast;
2167
 
    e1->f__delete         = (void (*)(void*,
2168
 
      sidl_BaseInterface*)) epv->f__delete;
2169
 
    e1->f__getURL         = (char* (*)(void*,
2170
 
      sidl_BaseInterface*)) epv->f__getURL;
2171
 
    e1->f__raddRef        = (void (*)(void*,
2172
 
      sidl_BaseInterface*)) epv->f__raddRef;
2173
 
    e1->f__isRemote       = (sidl_bool (*)(void*,
2174
 
      sidl_BaseInterface*)) epv->f__isRemote;
2175
 
    e1->f__set_hooks      = (void (*)(void*,int32_t,
2176
 
      sidl_BaseInterface*)) epv->f__set_hooks;
2177
 
    e1->f__exec           = (void (*)(void*,const char*,
2178
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2179
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
 
2165
    e1->f__cast           = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
2166
      epv->f__cast;
 
2167
    e1->f__delete         = (void (*)(void*,sidl_BaseInterface*)) 
 
2168
      epv->f__delete;
 
2169
    e1->f__getURL         = (char* (*)(void*,sidl_BaseInterface*)) 
 
2170
      epv->f__getURL;
 
2171
    e1->f__raddRef        = (void (*)(void*,sidl_BaseInterface*)) 
 
2172
      epv->f__raddRef;
 
2173
    e1->f__isRemote       = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
2174
      epv->f__isRemote;
 
2175
    e1->f__set_hooks      = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
2176
      epv->f__set_hooks;
 
2177
    e1->f__exec           = (void (*)(void*,const char*,struct 
 
2178
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2179
      sidl_BaseInterface__object **)) epv->f__exec;
2180
2180
    e1->f_SetLocalRange   = (int32_t (*)(void*,int32_t,int32_t,int32_t,int32_t,
2181
2181
      struct sidl_BaseInterface__object **)) epv->f_SetLocalRange;
2182
 
    e1->f_SetValues       = (int32_t (*)(void*,struct sidl_int__array*,
2183
 
      struct sidl_int__array*,struct sidl_int__array*,
2184
 
      struct sidl_double__array*,
 
2182
    e1->f_SetValues       = (int32_t (*)(void*,struct sidl_int__array*,struct 
 
2183
      sidl_int__array*,struct sidl_int__array*,struct sidl_double__array*,
2185
2184
      struct sidl_BaseInterface__object **)) epv->f_SetValues;
2186
 
    e1->f_AddToValues     = (int32_t (*)(void*,struct sidl_int__array*,
2187
 
      struct sidl_int__array*,struct sidl_int__array*,
2188
 
      struct sidl_double__array*,
 
2185
    e1->f_AddToValues     = (int32_t (*)(void*,struct sidl_int__array*,struct 
 
2186
      sidl_int__array*,struct sidl_int__array*,struct sidl_double__array*,
2189
2187
      struct sidl_BaseInterface__object **)) epv->f_AddToValues;
2190
2188
    e1->f_GetLocalRange   = (int32_t (*)(void*,int32_t*,int32_t*,int32_t*,
2191
2189
      int32_t*,struct sidl_BaseInterface__object **)) epv->f_GetLocalRange;
2192
 
    e1->f_GetRowCounts    = (int32_t (*)(void*,struct sidl_int__array*,
2193
 
      struct sidl_int__array**,
2194
 
      struct sidl_BaseInterface__object **)) epv->f_GetRowCounts;
2195
 
    e1->f_GetValues       = (int32_t (*)(void*,struct sidl_int__array*,
2196
 
      struct sidl_int__array*,struct sidl_int__array*,
2197
 
      struct sidl_double__array**,
 
2190
    e1->f_GetRowCounts    = (int32_t (*)(void*,struct sidl_int__array*,struct 
 
2191
      sidl_int__array**,struct sidl_BaseInterface__object **)) 
 
2192
      epv->f_GetRowCounts;
 
2193
    e1->f_GetValues       = (int32_t (*)(void*,struct sidl_int__array*,struct 
 
2194
      sidl_int__array*,struct sidl_int__array*,struct sidl_double__array**,
2198
2195
      struct sidl_BaseInterface__object **)) epv->f_GetValues;
2199
 
    e1->f_SetRowSizes     = (int32_t (*)(void*,struct sidl_int__array*,
2200
 
      struct sidl_BaseInterface__object **)) epv->f_SetRowSizes;
2201
 
    e1->f_Print           = (int32_t (*)(void*,const char*,
2202
 
      struct sidl_BaseInterface__object **)) epv->f_Print;
2203
 
    e1->f_Read            = (int32_t (*)(void*,const char*,
2204
 
      struct bHYPRE_MPICommunicator__object*,
2205
 
      struct sidl_BaseInterface__object **)) epv->f_Read;
2206
 
    e1->f_SetCommunicator = (int32_t (*)(void*,
2207
 
      struct bHYPRE_MPICommunicator__object*,
2208
 
      struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
2209
 
    e1->f_Destroy         = (void (*)(void*,
2210
 
      struct sidl_BaseInterface__object **)) epv->f_Destroy;
2211
 
    e1->f_Initialize      = (int32_t (*)(void*,
2212
 
      struct sidl_BaseInterface__object **)) epv->f_Initialize;
2213
 
    e1->f_Assemble        = (int32_t (*)(void*,
2214
 
      struct sidl_BaseInterface__object **)) epv->f_Assemble;
2215
 
    e1->f_addRef          = (void (*)(void*,
2216
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
2217
 
    e1->f_deleteRef       = (void (*)(void*,
2218
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
2219
 
    e1->f_isSame          = (sidl_bool (*)(void*,
2220
 
      struct sidl_BaseInterface__object*,
2221
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
2222
 
    e1->f_isType          = (sidl_bool (*)(void*,const char*,
2223
 
      struct sidl_BaseInterface__object **)) epv->f_isType;
2224
 
    e1->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,
2225
 
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2196
    e1->f_SetRowSizes     = (int32_t (*)(void*,struct sidl_int__array*,struct 
 
2197
      sidl_BaseInterface__object **)) epv->f_SetRowSizes;
 
2198
    e1->f_Print           = (int32_t (*)(void*,const char*,struct 
 
2199
      sidl_BaseInterface__object **)) epv->f_Print;
 
2200
    e1->f_Read            = (int32_t (*)(void*,const char*,struct 
 
2201
      bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
2202
      epv->f_Read;
 
2203
    e1->f_SetCommunicator = (int32_t (*)(void*,struct 
 
2204
      bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
2205
      epv->f_SetCommunicator;
 
2206
    e1->f_Destroy         = (void (*)(void*,struct sidl_BaseInterface__object 
 
2207
      **)) epv->f_Destroy;
 
2208
    e1->f_Initialize      = (int32_t (*)(void*,struct 
 
2209
      sidl_BaseInterface__object **)) epv->f_Initialize;
 
2210
    e1->f_Assemble        = (int32_t (*)(void*,struct 
 
2211
      sidl_BaseInterface__object **)) epv->f_Assemble;
 
2212
    e1->f_addRef          = (void (*)(void*,struct sidl_BaseInterface__object 
 
2213
      **)) epv->f_addRef;
 
2214
    e1->f_deleteRef       = (void (*)(void*,struct sidl_BaseInterface__object 
 
2215
      **)) epv->f_deleteRef;
 
2216
    e1->f_isSame          = (sidl_bool (*)(void*,struct 
 
2217
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2218
      epv->f_isSame;
 
2219
    e1->f_isType          = (sidl_bool (*)(void*,const char*,struct 
 
2220
      sidl_BaseInterface__object **)) epv->f_isType;
 
2221
    e1->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2222
      sidl_BaseInterface__object **)) epv->f_getClassInfo;
2226
2223
 
2227
 
    e2->f__cast           = (void* (*)(void*,const char*,
2228
 
      sidl_BaseInterface*)) epv->f__cast;
2229
 
    e2->f__delete         = (void (*)(void*,
2230
 
      sidl_BaseInterface*)) epv->f__delete;
2231
 
    e2->f__getURL         = (char* (*)(void*,
2232
 
      sidl_BaseInterface*)) epv->f__getURL;
2233
 
    e2->f__raddRef        = (void (*)(void*,
2234
 
      sidl_BaseInterface*)) epv->f__raddRef;
2235
 
    e2->f__isRemote       = (sidl_bool (*)(void*,
2236
 
      sidl_BaseInterface*)) epv->f__isRemote;
2237
 
    e2->f__set_hooks      = (void (*)(void*,int32_t,
2238
 
      sidl_BaseInterface*)) epv->f__set_hooks;
2239
 
    e2->f__exec           = (void (*)(void*,const char*,
2240
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2241
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
2242
 
    e2->f_SetCommunicator = (int32_t (*)(void*,
2243
 
      struct bHYPRE_MPICommunicator__object*,
2244
 
      struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
2245
 
    e2->f_Destroy         = (void (*)(void*,
2246
 
      struct sidl_BaseInterface__object **)) epv->f_Destroy;
2247
 
    e2->f_Initialize      = (int32_t (*)(void*,
2248
 
      struct sidl_BaseInterface__object **)) epv->f_Initialize;
2249
 
    e2->f_Assemble        = (int32_t (*)(void*,
2250
 
      struct sidl_BaseInterface__object **)) epv->f_Assemble;
2251
 
    e2->f_addRef          = (void (*)(void*,
2252
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
2253
 
    e2->f_deleteRef       = (void (*)(void*,
2254
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
2255
 
    e2->f_isSame          = (sidl_bool (*)(void*,
2256
 
      struct sidl_BaseInterface__object*,
2257
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
2258
 
    e2->f_isType          = (sidl_bool (*)(void*,const char*,
2259
 
      struct sidl_BaseInterface__object **)) epv->f_isType;
2260
 
    e2->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,
2261
 
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2224
    e2->f__cast           = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
2225
      epv->f__cast;
 
2226
    e2->f__delete         = (void (*)(void*,sidl_BaseInterface*)) 
 
2227
      epv->f__delete;
 
2228
    e2->f__getURL         = (char* (*)(void*,sidl_BaseInterface*)) 
 
2229
      epv->f__getURL;
 
2230
    e2->f__raddRef        = (void (*)(void*,sidl_BaseInterface*)) 
 
2231
      epv->f__raddRef;
 
2232
    e2->f__isRemote       = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
2233
      epv->f__isRemote;
 
2234
    e2->f__set_hooks      = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
2235
      epv->f__set_hooks;
 
2236
    e2->f__exec           = (void (*)(void*,const char*,struct 
 
2237
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2238
      sidl_BaseInterface__object **)) epv->f__exec;
 
2239
    e2->f_SetCommunicator = (int32_t (*)(void*,struct 
 
2240
      bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
2241
      epv->f_SetCommunicator;
 
2242
    e2->f_Destroy         = (void (*)(void*,struct sidl_BaseInterface__object 
 
2243
      **)) epv->f_Destroy;
 
2244
    e2->f_Initialize      = (int32_t (*)(void*,struct 
 
2245
      sidl_BaseInterface__object **)) epv->f_Initialize;
 
2246
    e2->f_Assemble        = (int32_t (*)(void*,struct 
 
2247
      sidl_BaseInterface__object **)) epv->f_Assemble;
 
2248
    e2->f_addRef          = (void (*)(void*,struct sidl_BaseInterface__object 
 
2249
      **)) epv->f_addRef;
 
2250
    e2->f_deleteRef       = (void (*)(void*,struct sidl_BaseInterface__object 
 
2251
      **)) epv->f_deleteRef;
 
2252
    e2->f_isSame          = (sidl_bool (*)(void*,struct 
 
2253
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2254
      epv->f_isSame;
 
2255
    e2->f_isType          = (sidl_bool (*)(void*,const char*,struct 
 
2256
      sidl_BaseInterface__object **)) epv->f_isType;
 
2257
    e2->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2258
      sidl_BaseInterface__object **)) epv->f_getClassInfo;
2262
2259
 
2263
2260
    e3->f__cast                    = (void* (*)(void*,const char*,
2264
2261
      sidl_BaseInterface*)) epv->f__cast;
2265
 
    e3->f__delete                  = (void (*)(void*,
2266
 
      sidl_BaseInterface*)) epv->f__delete;
2267
 
    e3->f__getURL                  = (char* (*)(void*,
2268
 
      sidl_BaseInterface*)) epv->f__getURL;
2269
 
    e3->f__raddRef                 = (void (*)(void*,
2270
 
      sidl_BaseInterface*)) epv->f__raddRef;
2271
 
    e3->f__isRemote                = (sidl_bool (*)(void*,
2272
 
      sidl_BaseInterface*)) epv->f__isRemote;
2273
 
    e3->f__set_hooks               = (void (*)(void*,int32_t,
 
2262
    e3->f__delete                  = (void (*)(void*,sidl_BaseInterface*)) 
 
2263
      epv->f__delete;
 
2264
    e3->f__getURL                  = (char* (*)(void*,sidl_BaseInterface*)) 
 
2265
      epv->f__getURL;
 
2266
    e3->f__raddRef                 = (void (*)(void*,sidl_BaseInterface*)) 
 
2267
      epv->f__raddRef;
 
2268
    e3->f__isRemote                = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
2269
      epv->f__isRemote;
 
2270
    e3->f__set_hooks               = (void (*)(void*,int32_t, 
2274
2271
      sidl_BaseInterface*)) epv->f__set_hooks;
2275
 
    e3->f__exec                    = (void (*)(void*,const char*,
2276
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2277
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
2278
 
    e3->f_SetCommunicator          = (int32_t (*)(void*,
2279
 
      struct bHYPRE_MPICommunicator__object*,
2280
 
      struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
2281
 
    e3->f_Destroy                  = (void (*)(void*,
2282
 
      struct sidl_BaseInterface__object **)) epv->f_Destroy;
 
2272
    e3->f__exec                    = (void (*)(void*,const char*,struct 
 
2273
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2274
      sidl_BaseInterface__object **)) epv->f__exec;
 
2275
    e3->f_SetCommunicator          = (int32_t (*)(void*,struct 
 
2276
      bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
2277
      epv->f_SetCommunicator;
 
2278
    e3->f_Destroy                  = (void (*)(void*,struct 
 
2279
      sidl_BaseInterface__object **)) epv->f_Destroy;
2283
2280
    e3->f_SetIntParameter          = (int32_t (*)(void*,const char*,int32_t,
2284
2281
      struct sidl_BaseInterface__object **)) epv->f_SetIntParameter;
2285
2282
    e3->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,
2286
2283
      struct sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
2287
2284
    e3->f_SetStringParameter       = (int32_t (*)(void*,const char*,const char*,
2288
2285
      struct sidl_BaseInterface__object **)) epv->f_SetStringParameter;
2289
 
    e3->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,
2290
 
      struct sidl_int__array*,
2291
 
      struct sidl_BaseInterface__object **)) epv->f_SetIntArray1Parameter;
2292
 
    e3->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,
2293
 
      struct sidl_int__array*,
2294
 
      struct sidl_BaseInterface__object **)) epv->f_SetIntArray2Parameter;
2295
 
    e3->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,
2296
 
      struct sidl_double__array*,
2297
 
      struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray1Parameter;
2298
 
    e3->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,
2299
 
      struct sidl_double__array*,
2300
 
      struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray2Parameter;
 
2286
    e3->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,struct 
 
2287
      sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
2288
      epv->f_SetIntArray1Parameter;
 
2289
    e3->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,struct 
 
2290
      sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
2291
      epv->f_SetIntArray2Parameter;
 
2292
    e3->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,struct 
 
2293
      sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
2294
      epv->f_SetDoubleArray1Parameter;
 
2295
    e3->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,struct 
 
2296
      sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
2297
      epv->f_SetDoubleArray2Parameter;
2301
2298
    e3->f_GetIntValue              = (int32_t (*)(void*,const char*,int32_t*,
2302
2299
      struct sidl_BaseInterface__object **)) epv->f_GetIntValue;
2303
2300
    e3->f_GetDoubleValue           = (int32_t (*)(void*,const char*,double*,
2304
2301
      struct sidl_BaseInterface__object **)) epv->f_GetDoubleValue;
2305
 
    e3->f_Setup                    = (int32_t (*)(void*,
2306
 
      struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,
2307
 
      struct sidl_BaseInterface__object **)) epv->f_Setup;
2308
 
    e3->f_Apply                    = (int32_t (*)(void*,
2309
 
      struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
2310
 
      struct sidl_BaseInterface__object **)) epv->f_Apply;
2311
 
    e3->f_ApplyAdjoint             = (int32_t (*)(void*,
2312
 
      struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
2313
 
      struct sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
2314
 
    e3->f_addRef                   = (void (*)(void*,
2315
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
2316
 
    e3->f_deleteRef                = (void (*)(void*,
2317
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
2318
 
    e3->f_isSame                   = (sidl_bool (*)(void*,
2319
 
      struct sidl_BaseInterface__object*,
2320
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
2321
 
    e3->f_isType                   = (sidl_bool (*)(void*,const char*,
2322
 
      struct sidl_BaseInterface__object **)) epv->f_isType;
 
2302
    e3->f_Setup                    = (int32_t (*)(void*,struct 
 
2303
      bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,struct 
 
2304
      sidl_BaseInterface__object **)) epv->f_Setup;
 
2305
    e3->f_Apply                    = (int32_t (*)(void*,struct 
 
2306
      bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
2307
      sidl_BaseInterface__object **)) epv->f_Apply;
 
2308
    e3->f_ApplyAdjoint             = (int32_t (*)(void*,struct 
 
2309
      bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
2310
      sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
 
2311
    e3->f_addRef                   = (void (*)(void*,struct 
 
2312
      sidl_BaseInterface__object **)) epv->f_addRef;
 
2313
    e3->f_deleteRef                = (void (*)(void*,struct 
 
2314
      sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2315
    e3->f_isSame                   = (sidl_bool (*)(void*,struct 
 
2316
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2317
      epv->f_isSame;
 
2318
    e3->f_isType                   = (sidl_bool (*)(void*,const char*,struct 
 
2319
      sidl_BaseInterface__object **)) epv->f_isType;
2323
2320
    e3->f_getClassInfo             = (struct sidl_ClassInfo__object* (*)(void*,
2324
2321
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
2325
2322
 
2326
 
    e4->f__cast           = (void* (*)(void*,const char*,
2327
 
      sidl_BaseInterface*)) epv->f__cast;
2328
 
    e4->f__delete         = (void (*)(void*,
2329
 
      sidl_BaseInterface*)) epv->f__delete;
2330
 
    e4->f__getURL         = (char* (*)(void*,
2331
 
      sidl_BaseInterface*)) epv->f__getURL;
2332
 
    e4->f__raddRef        = (void (*)(void*,
2333
 
      sidl_BaseInterface*)) epv->f__raddRef;
2334
 
    e4->f__isRemote       = (sidl_bool (*)(void*,
2335
 
      sidl_BaseInterface*)) epv->f__isRemote;
2336
 
    e4->f__set_hooks      = (void (*)(void*,int32_t,
2337
 
      sidl_BaseInterface*)) epv->f__set_hooks;
2338
 
    e4->f__exec           = (void (*)(void*,const char*,
2339
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2340
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
2341
 
    e4->f_SetCommunicator = (int32_t (*)(void*,
2342
 
      struct bHYPRE_MPICommunicator__object*,
2343
 
      struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
2344
 
    e4->f_Destroy         = (void (*)(void*,
2345
 
      struct sidl_BaseInterface__object **)) epv->f_Destroy;
2346
 
    e4->f_Initialize      = (int32_t (*)(void*,
2347
 
      struct sidl_BaseInterface__object **)) epv->f_Initialize;
2348
 
    e4->f_Assemble        = (int32_t (*)(void*,
2349
 
      struct sidl_BaseInterface__object **)) epv->f_Assemble;
2350
 
    e4->f_addRef          = (void (*)(void*,
2351
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
2352
 
    e4->f_deleteRef       = (void (*)(void*,
2353
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
2354
 
    e4->f_isSame          = (sidl_bool (*)(void*,
2355
 
      struct sidl_BaseInterface__object*,
2356
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
2357
 
    e4->f_isType          = (sidl_bool (*)(void*,const char*,
2358
 
      struct sidl_BaseInterface__object **)) epv->f_isType;
2359
 
    e4->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,
2360
 
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2323
    e4->f__cast           = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
2324
      epv->f__cast;
 
2325
    e4->f__delete         = (void (*)(void*,sidl_BaseInterface*)) 
 
2326
      epv->f__delete;
 
2327
    e4->f__getURL         = (char* (*)(void*,sidl_BaseInterface*)) 
 
2328
      epv->f__getURL;
 
2329
    e4->f__raddRef        = (void (*)(void*,sidl_BaseInterface*)) 
 
2330
      epv->f__raddRef;
 
2331
    e4->f__isRemote       = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
2332
      epv->f__isRemote;
 
2333
    e4->f__set_hooks      = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
2334
      epv->f__set_hooks;
 
2335
    e4->f__exec           = (void (*)(void*,const char*,struct 
 
2336
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2337
      sidl_BaseInterface__object **)) epv->f__exec;
 
2338
    e4->f_SetCommunicator = (int32_t (*)(void*,struct 
 
2339
      bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
2340
      epv->f_SetCommunicator;
 
2341
    e4->f_Destroy         = (void (*)(void*,struct sidl_BaseInterface__object 
 
2342
      **)) epv->f_Destroy;
 
2343
    e4->f_Initialize      = (int32_t (*)(void*,struct 
 
2344
      sidl_BaseInterface__object **)) epv->f_Initialize;
 
2345
    e4->f_Assemble        = (int32_t (*)(void*,struct 
 
2346
      sidl_BaseInterface__object **)) epv->f_Assemble;
 
2347
    e4->f_addRef          = (void (*)(void*,struct sidl_BaseInterface__object 
 
2348
      **)) epv->f_addRef;
 
2349
    e4->f_deleteRef       = (void (*)(void*,struct sidl_BaseInterface__object 
 
2350
      **)) epv->f_deleteRef;
 
2351
    e4->f_isSame          = (sidl_bool (*)(void*,struct 
 
2352
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2353
      epv->f_isSame;
 
2354
    e4->f_isType          = (sidl_bool (*)(void*,const char*,struct 
 
2355
      sidl_BaseInterface__object **)) epv->f_isType;
 
2356
    e4->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2357
      sidl_BaseInterface__object **)) epv->f_getClassInfo;
2361
2358
 
2362
2359
    e5->f__cast        = (void* (*)(struct sidl_BaseClass__object*,const char*,
2363
2360
      sidl_BaseInterface*)) epv->f__cast;
2369
2366
      sidl_BaseInterface*)) epv->f__raddRef;
2370
2367
    e5->f__isRemote    = (sidl_bool (*)(struct sidl_BaseClass__object*,
2371
2368
      sidl_BaseInterface*)) epv->f__isRemote;
2372
 
    e5->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t,
 
2369
    e5->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t, 
2373
2370
      sidl_BaseInterface*)) epv->f__set_hooks;
2374
2371
    e5->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,
2375
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2376
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
2377
 
    e5->f_addRef       = (void (*)(struct sidl_BaseClass__object*,
2378
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
2379
 
    e5->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,
2380
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
2381
 
    e5->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,
2382
 
      struct sidl_BaseInterface__object*,
2383
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
2384
 
    e5->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,
2385
 
      const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
2372
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2373
      sidl_BaseInterface__object **)) epv->f__exec;
 
2374
    e5->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct 
 
2375
      sidl_BaseInterface__object **)) epv->f_addRef;
 
2376
    e5->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct 
 
2377
      sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2378
    e5->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct 
 
2379
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2380
      epv->f_isSame;
 
2381
    e5->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const 
 
2382
      char*,struct sidl_BaseInterface__object **)) epv->f_isType;
2386
2383
    e5->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
2387
 
      sidl_BaseClass__object*,
2388
 
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2384
      sidl_BaseClass__object*,struct sidl_BaseInterface__object **)) 
 
2385
      epv->f_getClassInfo;
2389
2386
 
2390
 
    e6->f__cast        = (void* (*)(void*,const char*,
2391
 
      sidl_BaseInterface*)) epv->f__cast;
 
2387
    e6->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
2388
      epv->f__cast;
2392
2389
    e6->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
2393
2390
    e6->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
2394
2391
    e6->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
2395
 
    e6->f__isRemote    = (sidl_bool (*)(void*,
2396
 
      sidl_BaseInterface*)) epv->f__isRemote;
2397
 
    e6->f__set_hooks   = (void (*)(void*,int32_t,
2398
 
      sidl_BaseInterface*)) epv->f__set_hooks;
2399
 
    e6->f__exec        = (void (*)(void*,const char*,
2400
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2401
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
2402
 
    e6->f_addRef       = (void (*)(void*,
2403
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
2404
 
    e6->f_deleteRef    = (void (*)(void*,
2405
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
2406
 
    e6->f_isSame       = (sidl_bool (*)(void*,
2407
 
      struct sidl_BaseInterface__object*,
2408
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
2409
 
    e6->f_isType       = (sidl_bool (*)(void*,const char*,
2410
 
      struct sidl_BaseInterface__object **)) epv->f_isType;
2411
 
    e6->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
2412
 
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2392
    e6->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
2393
      epv->f__isRemote;
 
2394
    e6->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
2395
      epv->f__set_hooks;
 
2396
    e6->f__exec        = (void (*)(void*,const char*,struct 
 
2397
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2398
      sidl_BaseInterface__object **)) epv->f__exec;
 
2399
    e6->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2400
      epv->f_addRef;
 
2401
    e6->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2402
      epv->f_deleteRef;
 
2403
    e6->f_isSame       = (sidl_bool (*)(void*,struct 
 
2404
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2405
      epv->f_isSame;
 
2406
    e6->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
2407
      sidl_BaseInterface__object **)) epv->f_isType;
 
2408
    e6->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2409
      sidl_BaseInterface__object **)) epv->f_getClassInfo;
2413
2410
 
2414
2411
    s_remote_initialized = 1;
2415
2412
  }
2416
2413
 
2417
2414
  // Create an instance that connects to an existing remote object.
2418
2415
  static struct bHYPRE_IJParCSRMatrix__object*
2419
 
  bHYPRE_IJParCSRMatrix__remoteConnect(const char *url, sidl_bool ar,
 
2416
  bHYPRE_IJParCSRMatrix__remoteConnect(const char *url, sidl_bool ar, 
2420
2417
    sidl_BaseInterface *_ex)
2421
2418
  {
2422
2419
    struct bHYPRE_IJParCSRMatrix__object* self;
2432
2429
    if(url == NULL) {return NULL;}
2433
2430
    objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
2434
2431
    if(objectID) {
2435
 
      sidl_BaseInterface bi = 
2436
 
        (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
 
2432
      sidl_BaseInterface bi = (
 
2433
        sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
2437
2434
        objectID, _ex); SIDL_CHECK(*_ex);
2438
2435
      return bHYPRE_IJParCSRMatrix__rmicast(bi,_ex);SIDL_CHECK(*_ex);
2439
2436
    }
2440
 
    instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar,
2441
 
      _ex ); SIDL_CHECK(*_ex);
 
2437
    instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex ); 
 
2438
      SIDL_CHECK(*_ex);
2442
2439
    if ( instance == NULL) { return NULL; }
2443
2440
    self =
2444
2441
      (struct bHYPRE_IJParCSRMatrix__object*) malloc(
2495
2492
  // Create an instance that uses an already existing 
2496
2493
  // InstanceHandle to connect to an existing remote object.
2497
2494
  static struct bHYPRE_IJParCSRMatrix__object*
2498
 
  bHYPRE_IJParCSRMatrix__IHConnect(sidl_rmi_InstanceHandle instance,
 
2495
  bHYPRE_IJParCSRMatrix__IHConnect(sidl_rmi_InstanceHandle instance, 
2499
2496
    sidl_BaseInterface *_ex)
2500
2497
  {
2501
2498
    struct bHYPRE_IJParCSRMatrix__object* self;
2568
2565
    struct sidl_BaseClass__object* s1;
2569
2566
 
2570
2567
    struct bHYPRE_IJParCSRMatrix__remote* r_obj;
2571
 
    sidl_rmi_InstanceHandle instance = 
2572
 
      sidl_rmi_ProtocolFactory_createInstance(url, "bHYPRE.IJParCSRMatrix",
2573
 
      _ex ); SIDL_CHECK(*_ex);
 
2568
    sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance(
 
2569
      url, "bHYPRE.IJParCSRMatrix", _ex ); SIDL_CHECK(*_ex);
2574
2570
    if ( instance == NULL) { return NULL; }
2575
2571
    self =
2576
2572
      (struct bHYPRE_IJParCSRMatrix__object*) malloc(
2622
2618
 
2623
2619
    return self;
2624
2620
    EXIT:
2625
 
    if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance,
 
2621
    if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance, 
2626
2622
      &_throwaway_exception); }
2627
2623
    return NULL;
2628
2624
  }
2638
2634
 
2639
2635
    *_ex = NULL;
2640
2636
    if(!connect_loaded) {
2641
 
      sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.IJParCSRMatrix",
2642
 
        (void*)bHYPRE_IJParCSRMatrix__IHConnect, _ex);
 
2637
      sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.IJParCSRMatrix", (
 
2638
        void*)bHYPRE_IJParCSRMatrix__IHConnect, _ex);
2643
2639
      connect_loaded = 1;
2644
2640
    }
2645
2641
    if (obj != NULL) {
2659
2655
  // RMI connector function for the class.
2660
2656
  // 
2661
2657
  struct bHYPRE_IJParCSRMatrix__object*
2662
 
  bHYPRE_IJParCSRMatrix__connectI(const char* url, sidl_bool ar,
2663
 
    struct sidl_BaseInterface__object **_ex)
 
2658
  bHYPRE_IJParCSRMatrix__connectI(const char* url, sidl_bool ar, struct 
 
2659
    sidl_BaseInterface__object **_ex)
2664
2660
  {
2665
2661
    return bHYPRE_IJParCSRMatrix__remoteConnect(url, ar, _ex);
2666
2662
  }
2681
2677
  void * _p = 0;
2682
2678
  struct sidl_BaseInterface__object *throwaway_exception;
2683
2679
 
2684
 
  if ( (_p=(*(_exception->d_epv->f__cast))(_exception->d_object,
 
2680
  if ( (_p=(*(_exception->d_epv->f__cast))(_exception->d_object, 
2685
2681
    "sidl.RuntimeException", &throwaway_exception)) != 0 ) {
2686
2682
    struct sidl_RuntimeException__object * _realtype = reinterpret_cast< struct 
2687
2683
      sidl_RuntimeException__object*>(_p);
2688
 
    (*_exception->d_epv->f_deleteRef)(_exception->d_object,
 
2684
    (*_exception->d_epv->f_deleteRef)(_exception->d_object, 
2689
2685
      &throwaway_exception);
2690
2686
    // Note: alternate constructor does not increment refcount.
2691
2687
    ::sidl::RuntimeException _resolved_exception = ::sidl::RuntimeException( 
2706
2702
// User Defined Methods
2707
2703
// 
2708
2704
 
 
2705
 
2709
2706
/**
2710
 
 * user defined static method
 
2707
 *  This function is the preferred way to create an IJParCSR Matrix. 
2711
2708
 */
2712
2709
::bHYPRE::IJParCSRMatrix
2713
 
bHYPRE::IJParCSRMatrix::Create( /* in */::bHYPRE::MPICommunicator mpi_comm,
2714
 
  /* in */int32_t ilower, /* in */int32_t iupper, /* in */int32_t jlower,
2715
 
  /* in */int32_t jupper )
 
2710
bHYPRE::IJParCSRMatrix::Create( /* in */::bHYPRE::MPICommunicator mpi_comm, /* 
 
2711
  in */int32_t ilower, /* in */int32_t iupper, /* in */int32_t jlower, /* in 
 
2712
  */int32_t jupper )
2716
2713
 
2717
2714
{
2718
2715
  ::bHYPRE::IJParCSRMatrix _result;
2719
 
  struct bHYPRE_MPICommunicator__object* _local_mpi_comm = mpi_comm._get_ior();
 
2716
  struct bHYPRE_MPICommunicator__object* _local_mpi_comm = (struct 
 
2717
    bHYPRE_MPICommunicator__object*) 
 
2718
    mpi_comm.::bHYPRE::MPICommunicator::_get_ior();
2720
2719
  sidl_BaseInterface__object * _exception;
2721
2720
  /*pack args to dispatch to ior*/
2722
2721
  _result = ::bHYPRE::IJParCSRMatrix( ( _get_sepv()->f_Create)( /* in */ 
2723
 
    _local_mpi_comm, /* in */ ilower, /* in */ iupper, /* in */ jlower,
2724
 
    /* in */ jupper, &_exception ), false);
 
2722
    _local_mpi_comm, /* in */ ilower, /* in */ iupper, /* in */ jlower, /* in 
 
2723
    */ jupper, &_exception ), false);
2725
2724
  /*dispatch to ior*/
2726
2725
  if (_exception != 0 ) {
 
2726
 
2727
2727
    throwException0(_exception);
2728
2728
  }
2729
2729
  /*unpack results and cleanup*/
2736
2736
 */
2737
2737
::bHYPRE::IJParCSRMatrix
2738
2738
bHYPRE::IJParCSRMatrix::GenerateLaplacian( /* in */::bHYPRE::MPICommunicator 
2739
 
  mpi_comm, /* in */int32_t nx, /* in */int32_t ny, /* in */int32_t nz,
2740
 
  /* in */int32_t Px, /* in */int32_t Py, /* in */int32_t Pz, /* in */int32_t p,
2741
 
  /* in */int32_t q, /* in */int32_t r, /* in rarray[nvalues] */double* values,
2742
 
  /* in */int32_t nvalues, /* in */int32_t discretization )
 
2739
  mpi_comm, /* in */int32_t nx, /* in */int32_t ny, /* in */int32_t nz, /* in 
 
2740
  */int32_t Px, /* in */int32_t Py, /* in */int32_t Pz, /* in */int32_t p, /* 
 
2741
  in */int32_t q, /* in */int32_t r, /* in rarray[nvalues] */double* values, /* 
 
2742
  in */int32_t nvalues, /* in */int32_t discretization )
2743
2743
 
2744
2744
{
2745
2745
  ::bHYPRE::IJParCSRMatrix _result;
2746
 
  struct bHYPRE_MPICommunicator__object* _local_mpi_comm = mpi_comm._get_ior();
 
2746
  struct bHYPRE_MPICommunicator__object* _local_mpi_comm = (struct 
 
2747
    bHYPRE_MPICommunicator__object*) 
 
2748
    mpi_comm.::bHYPRE::MPICommunicator::_get_ior();
2747
2749
  int32_t values_lower[1], values_upper[1], values_stride[1];
2748
2750
  struct sidl_double__array values_real;
2749
2751
  struct sidl_double__array *values_tmp = &values_real;
2750
2752
  values_upper[0] = nvalues-1;
2751
 
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper,
 
2753
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper, 
2752
2754
    values_stride);
2753
2755
  sidl_BaseInterface__object * _exception;
2754
2756
  /*pack args to dispatch to ior*/
2755
2757
  _result = ::bHYPRE::IJParCSRMatrix( ( _get_sepv()->f_GenerateLaplacian)( /* 
2756
 
    in */ _local_mpi_comm, /* in */ nx, /* in */ ny, /* in */ nz, /* in */ Px,
2757
 
    /* in */ Py, /* in */ Pz, /* in */ p, /* in */ q, /* in */ r,
2758
 
    /* in rarray[nvalues] */ values_tmp, /* in */ discretization, &_exception ),
 
2758
    in */ _local_mpi_comm, /* in */ nx, /* in */ ny, /* in */ nz, /* in */ Px, 
 
2759
    /* in */ Py, /* in */ Pz, /* in */ p, /* in */ q, /* in */ r, /* in 
 
2760
    rarray[nvalues] */ values_tmp, /* in */ discretization, &_exception ), 
2759
2761
    false);
2760
2762
  /*dispatch to ior*/
2761
2763
  if (_exception != 0 ) {
 
2764
    sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
2765
 
2762
2766
    throwException0(_exception);
2763
2767
  }
 
2768
  sidl__array_deleteRef((struct sidl__array *)values_tmp);
2764
2769
  /*unpack results and cleanup*/
2765
2770
  return _result;
2766
2771
}
2771
2776
 */
2772
2777
::bHYPRE::IJParCSRMatrix
2773
2778
bHYPRE::IJParCSRMatrix::GenerateLaplacian( /* in */::bHYPRE::MPICommunicator 
2774
 
  mpi_comm, /* in */int32_t nx, /* in */int32_t ny, /* in */int32_t nz,
2775
 
  /* in */int32_t Px, /* in */int32_t Py, /* in */int32_t Pz, /* in */int32_t p,
2776
 
  /* in */int32_t q, /* in */int32_t r,
2777
 
  /* in rarray[nvalues] */::sidl::array<double> values,
2778
 
  /* in */int32_t discretization )
 
2779
  mpi_comm, /* in */int32_t nx, /* in */int32_t ny, /* in */int32_t nz, /* in 
 
2780
  */int32_t Px, /* in */int32_t Py, /* in */int32_t Pz, /* in */int32_t p, /* 
 
2781
  in */int32_t q, /* in */int32_t r, /* in rarray[nvalues] 
 
2782
  */::sidl::array<double> values, /* in */int32_t discretization )
2779
2783
 
2780
2784
{
2781
2785
  ::bHYPRE::IJParCSRMatrix _result;
2782
 
  struct bHYPRE_MPICommunicator__object* _local_mpi_comm = mpi_comm._get_ior();
 
2786
  struct bHYPRE_MPICommunicator__object* _local_mpi_comm = (struct 
 
2787
    bHYPRE_MPICommunicator__object*) 
 
2788
    mpi_comm.::bHYPRE::MPICommunicator::_get_ior();
2783
2789
  sidl_BaseInterface__object * _exception;
2784
2790
  /*pack args to dispatch to ior*/
2785
2791
  _result = ::bHYPRE::IJParCSRMatrix( ( _get_sepv()->f_GenerateLaplacian)( /* 
2786
 
    in */ _local_mpi_comm, /* in */ nx, /* in */ ny, /* in */ nz, /* in */ Px,
2787
 
    /* in */ Py, /* in */ Pz, /* in */ p, /* in */ q, /* in */ r,
2788
 
    /* in rarray[nvalues] */ values._get_ior(), /* in */ discretization,
2789
 
    &_exception ), false);
 
2792
    in */ _local_mpi_comm, /* in */ nx, /* in */ ny, /* in */ nz, /* in */ Px, 
 
2793
    /* in */ Py, /* in */ Pz, /* in */ p, /* in */ q, /* in */ r, /* in 
 
2794
    rarray[nvalues] */ values._get_ior(), /* in */ discretization, &_exception 
 
2795
    ), false);
2790
2796
  /*dispatch to ior*/
2791
2797
  if (_exception != 0 ) {
 
2798
 
2792
2799
    throwException0(_exception);
2793
2800
  }
2794
2801
  /*unpack results and cleanup*/
2812
2819
 */
2813
2820
int32_t
2814
2821
bHYPRE::IJParCSRMatrix::SetDiagOffdSizes( /* in rarray[local_nrows] */int32_t* 
2815
 
  diag_sizes, /* in rarray[local_nrows] */int32_t* offdiag_sizes,
2816
 
  /* in */int32_t local_nrows )
 
2822
  diag_sizes, /* in rarray[local_nrows] */int32_t* offdiag_sizes, /* in 
 
2823
  */int32_t local_nrows )
2817
2824
 
2818
2825
{
2819
2826
  int32_t _result;
2820
 
  ior_t* const loc_self = _get_ior();
 
2827
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
2828
    ::bHYPRE::IJParCSRMatrix::_get_ior();
2821
2829
  int32_t diag_sizes_lower[1], diag_sizes_upper[1], diag_sizes_stride[1];
2822
2830
  struct sidl_int__array diag_sizes_real;
2823
2831
  struct sidl_int__array *diag_sizes_tmp = &diag_sizes_real;
2824
2832
  diag_sizes_upper[0] = local_nrows-1;
2825
 
  sidl_int__array_init(diag_sizes, diag_sizes_tmp, 1, diag_sizes_lower,
 
2833
  sidl_int__array_init(diag_sizes, diag_sizes_tmp, 1, diag_sizes_lower, 
2826
2834
    diag_sizes_upper, diag_sizes_stride);
2827
 
  int32_t offdiag_sizes_lower[1], offdiag_sizes_upper[1],
 
2835
  int32_t offdiag_sizes_lower[1], offdiag_sizes_upper[1], 
2828
2836
    offdiag_sizes_stride[1];
2829
2837
  struct sidl_int__array offdiag_sizes_real;
2830
2838
  struct sidl_int__array *offdiag_sizes_tmp = &offdiag_sizes_real;
2833
2841
    offdiag_sizes_upper, offdiag_sizes_stride);
2834
2842
  sidl_BaseInterface__object * _exception;
2835
2843
  /*pack args to dispatch to ior*/
2836
 
  _result = (*(loc_self->d_epv->f_SetDiagOffdSizes))(loc_self,
2837
 
    /* in rarray[local_nrows] */ diag_sizes_tmp,
2838
 
    /* in rarray[local_nrows] */ offdiag_sizes_tmp, &_exception );
 
2844
  _result = (*(loc_self->d_epv->f_SetDiagOffdSizes))(loc_self, /* in 
 
2845
    rarray[local_nrows] */ diag_sizes_tmp, /* in rarray[local_nrows] */ 
 
2846
    offdiag_sizes_tmp, &_exception );
2839
2847
  /*dispatch to ior*/
2840
2848
  if (_exception != 0 ) {
 
2849
    sidl__array_deleteRef((struct sidl__array *)diag_sizes_tmp);
 
2850
    sidl__array_deleteRef((struct sidl__array *)offdiag_sizes_tmp);
 
2851
 
2841
2852
    throwException0(_exception);
2842
2853
  }
 
2854
  sidl__array_deleteRef((struct sidl__array *)diag_sizes_tmp);
 
2855
  sidl__array_deleteRef((struct sidl__array *)offdiag_sizes_tmp);
2843
2856
  /*unpack results and cleanup*/
2844
2857
  return _result;
2845
2858
}
2861
2874
 */
2862
2875
int32_t
2863
2876
bHYPRE::IJParCSRMatrix::SetDiagOffdSizes( /* in rarray[local_nrows] 
2864
 
  */::sidl::array<int32_t> diag_sizes,
2865
 
  /* in rarray[local_nrows] */::sidl::array<int32_t> offdiag_sizes )
 
2877
  */::sidl::array<int32_t> diag_sizes, /* in rarray[local_nrows] 
 
2878
  */::sidl::array<int32_t> offdiag_sizes )
2866
2879
 
2867
2880
{
2868
2881
  int32_t _result;
2869
 
  ior_t* const loc_self = _get_ior();
 
2882
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
2883
    ::bHYPRE::IJParCSRMatrix::_get_ior();
2870
2884
  sidl_BaseInterface__object * _exception;
2871
2885
  /*pack args to dispatch to ior*/
2872
 
  _result = (*(loc_self->d_epv->f_SetDiagOffdSizes))(loc_self,
2873
 
    /* in rarray[local_nrows] */ diag_sizes._get_ior(),
2874
 
    /* in rarray[local_nrows] */ offdiag_sizes._get_ior(), &_exception );
 
2886
  _result = (*(loc_self->d_epv->f_SetDiagOffdSizes))(loc_self, /* in 
 
2887
    rarray[local_nrows] */ diag_sizes._get_ior(), /* in rarray[local_nrows] */ 
 
2888
    offdiag_sizes._get_ior(), &_exception );
2875
2889
  /*dispatch to ior*/
2876
2890
  if (_exception != 0 ) {
 
2891
 
2877
2892
    throwException0(_exception);
2878
2893
  }
2879
2894
  /*unpack results and cleanup*/
2905
2920
 * Collective.
2906
2921
 */
2907
2922
int32_t
2908
 
bHYPRE::IJParCSRMatrix::SetLocalRange( /* in */int32_t ilower,
2909
 
  /* in */int32_t iupper, /* in */int32_t jlower, /* in */int32_t jupper )
 
2923
bHYPRE::IJParCSRMatrix::SetLocalRange( /* in */int32_t ilower, /* in */int32_t 
 
2924
  iupper, /* in */int32_t jlower, /* in */int32_t jupper )
2910
2925
 
2911
2926
{
2912
2927
  int32_t _result;
2913
 
  ior_t* const loc_self = _get_ior();
 
2928
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
2929
    ::bHYPRE::IJParCSRMatrix::_get_ior();
2914
2930
  sidl_BaseInterface__object * _exception;
2915
2931
  /*pack args to dispatch to ior*/
2916
 
  _result = (*(loc_self->d_epv->f_SetLocalRange))(loc_self, /* in */ ilower,
2917
 
    /* in */ iupper, /* in */ jlower, /* in */ jupper, &_exception );
 
2932
  _result = (*(loc_self->d_epv->f_SetLocalRange))(loc_self, /* in */ ilower, /* 
 
2933
    in */ iupper, /* in */ jlower, /* in */ jupper, &_exception );
2918
2934
  /*dispatch to ior*/
2919
2935
  if (_exception != 0 ) {
 
2936
 
2920
2937
    throwException0(_exception);
2921
2938
  }
2922
2939
  /*unpack results and cleanup*/
2942
2959
 * Not collective.
2943
2960
 */
2944
2961
int32_t
2945
 
bHYPRE::IJParCSRMatrix::SetValues( /* in */int32_t nrows,
2946
 
  /* in rarray[nrows] */int32_t* ncols, /* in rarray[nrows] */int32_t* rows,
2947
 
  /* in rarray[nnonzeros] */int32_t* cols,
2948
 
  /* in rarray[nnonzeros] */double* values, /* in */int32_t nnonzeros )
 
2962
bHYPRE::IJParCSRMatrix::SetValues( /* in */int32_t nrows, /* in rarray[nrows] 
 
2963
  */int32_t* ncols, /* in rarray[nrows] */int32_t* rows, /* in 
 
2964
  rarray[nnonzeros] */int32_t* cols, /* in rarray[nnonzeros] */double* values, 
 
2965
  /* in */int32_t nnonzeros )
2949
2966
 
2950
2967
{
2951
2968
  int32_t _result;
2952
 
  ior_t* const loc_self = _get_ior();
 
2969
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
2970
    ::bHYPRE::IJParCSRMatrix::_get_ior();
2953
2971
  int32_t ncols_lower[1], ncols_upper[1], ncols_stride[1];
2954
2972
  struct sidl_int__array ncols_real;
2955
2973
  struct sidl_int__array *ncols_tmp = &ncols_real;
2956
2974
  ncols_upper[0] = nrows-1;
2957
 
  sidl_int__array_init(ncols, ncols_tmp, 1, ncols_lower, ncols_upper,
 
2975
  sidl_int__array_init(ncols, ncols_tmp, 1, ncols_lower, ncols_upper, 
2958
2976
    ncols_stride);
2959
2977
  int32_t rows_lower[1], rows_upper[1], rows_stride[1];
2960
2978
  struct sidl_int__array rows_real;
2970
2988
  struct sidl_double__array values_real;
2971
2989
  struct sidl_double__array *values_tmp = &values_real;
2972
2990
  values_upper[0] = nnonzeros-1;
2973
 
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper,
 
2991
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper, 
2974
2992
    values_stride);
2975
2993
  sidl_BaseInterface__object * _exception;
2976
2994
  /*pack args to dispatch to ior*/
2977
 
  _result = (*(loc_self->d_epv->f_SetValues))(loc_self,
2978
 
    /* in rarray[nrows] */ ncols_tmp, /* in rarray[nrows] */ rows_tmp,
2979
 
    /* in rarray[nnonzeros] */ cols_tmp, /* in rarray[nnonzeros] */ values_tmp,
2980
 
    &_exception );
 
2995
  _result = (*(loc_self->d_epv->f_SetValues))(loc_self, /* in rarray[nrows] */ 
 
2996
    ncols_tmp, /* in rarray[nrows] */ rows_tmp, /* in rarray[nnonzeros] */ 
 
2997
    cols_tmp, /* in rarray[nnonzeros] */ values_tmp, &_exception );
2981
2998
  /*dispatch to ior*/
2982
2999
  if (_exception != 0 ) {
 
3000
    sidl__array_deleteRef((struct sidl__array *)ncols_tmp);
 
3001
    sidl__array_deleteRef((struct sidl__array *)rows_tmp);
 
3002
    sidl__array_deleteRef((struct sidl__array *)cols_tmp);
 
3003
    sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
3004
 
2983
3005
    throwException0(_exception);
2984
3006
  }
 
3007
  sidl__array_deleteRef((struct sidl__array *)ncols_tmp);
 
3008
  sidl__array_deleteRef((struct sidl__array *)rows_tmp);
 
3009
  sidl__array_deleteRef((struct sidl__array *)cols_tmp);
 
3010
  sidl__array_deleteRef((struct sidl__array *)values_tmp);
2985
3011
  /*unpack results and cleanup*/
2986
3012
  return _result;
2987
3013
}
3006
3032
 */
3007
3033
int32_t
3008
3034
bHYPRE::IJParCSRMatrix::SetValues( /* in rarray[nrows] */::sidl::array<int32_t> 
3009
 
  ncols, /* in rarray[nrows] */::sidl::array<int32_t> rows,
3010
 
  /* in rarray[nnonzeros] */::sidl::array<int32_t> cols,
3011
 
  /* in rarray[nnonzeros] */::sidl::array<double> values )
 
3035
  ncols, /* in rarray[nrows] */::sidl::array<int32_t> rows, /* in 
 
3036
  rarray[nnonzeros] */::sidl::array<int32_t> cols, /* in rarray[nnonzeros] 
 
3037
  */::sidl::array<double> values )
3012
3038
 
3013
3039
{
3014
3040
  int32_t _result;
3015
 
  ior_t* const loc_self = _get_ior();
 
3041
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3042
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3016
3043
  sidl_BaseInterface__object * _exception;
3017
3044
  /*pack args to dispatch to ior*/
3018
 
  _result = (*(loc_self->d_epv->f_SetValues))(loc_self,
3019
 
    /* in rarray[nrows] */ ncols._get_ior(),
3020
 
    /* in rarray[nrows] */ rows._get_ior(),
3021
 
    /* in rarray[nnonzeros] */ cols._get_ior(),
3022
 
    /* in rarray[nnonzeros] */ values._get_ior(), &_exception );
 
3045
  _result = (*(loc_self->d_epv->f_SetValues))(loc_self, /* in rarray[nrows] */ 
 
3046
    ncols._get_ior(), /* in rarray[nrows] */ rows._get_ior(), /* in 
 
3047
    rarray[nnonzeros] */ cols._get_ior(), /* in rarray[nnonzeros] */ 
 
3048
    values._get_ior(), &_exception );
3023
3049
  /*dispatch to ior*/
3024
3050
  if (_exception != 0 ) {
 
3051
 
3025
3052
    throwException0(_exception);
3026
3053
  }
3027
3054
  /*unpack results and cleanup*/
3039
3066
 * Not collective.
3040
3067
 */
3041
3068
int32_t
3042
 
bHYPRE::IJParCSRMatrix::AddToValues( /* in */int32_t nrows,
3043
 
  /* in rarray[nrows] */int32_t* ncols, /* in rarray[nrows] */int32_t* rows,
3044
 
  /* in rarray[nnonzeros] */int32_t* cols,
3045
 
  /* in rarray[nnonzeros] */double* values, /* in */int32_t nnonzeros )
 
3069
bHYPRE::IJParCSRMatrix::AddToValues( /* in */int32_t nrows, /* in rarray[nrows] 
 
3070
  */int32_t* ncols, /* in rarray[nrows] */int32_t* rows, /* in 
 
3071
  rarray[nnonzeros] */int32_t* cols, /* in rarray[nnonzeros] */double* values, 
 
3072
  /* in */int32_t nnonzeros )
3046
3073
 
3047
3074
{
3048
3075
  int32_t _result;
3049
 
  ior_t* const loc_self = _get_ior();
 
3076
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3077
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3050
3078
  int32_t ncols_lower[1], ncols_upper[1], ncols_stride[1];
3051
3079
  struct sidl_int__array ncols_real;
3052
3080
  struct sidl_int__array *ncols_tmp = &ncols_real;
3053
3081
  ncols_upper[0] = nrows-1;
3054
 
  sidl_int__array_init(ncols, ncols_tmp, 1, ncols_lower, ncols_upper,
 
3082
  sidl_int__array_init(ncols, ncols_tmp, 1, ncols_lower, ncols_upper, 
3055
3083
    ncols_stride);
3056
3084
  int32_t rows_lower[1], rows_upper[1], rows_stride[1];
3057
3085
  struct sidl_int__array rows_real;
3067
3095
  struct sidl_double__array values_real;
3068
3096
  struct sidl_double__array *values_tmp = &values_real;
3069
3097
  values_upper[0] = nnonzeros-1;
3070
 
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper,
 
3098
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper, 
3071
3099
    values_stride);
3072
3100
  sidl_BaseInterface__object * _exception;
3073
3101
  /*pack args to dispatch to ior*/
3074
 
  _result = (*(loc_self->d_epv->f_AddToValues))(loc_self,
3075
 
    /* in rarray[nrows] */ ncols_tmp, /* in rarray[nrows] */ rows_tmp,
3076
 
    /* in rarray[nnonzeros] */ cols_tmp, /* in rarray[nnonzeros] */ values_tmp,
3077
 
    &_exception );
 
3102
  _result = (*(loc_self->d_epv->f_AddToValues))(loc_self, /* in rarray[nrows] 
 
3103
    */ ncols_tmp, /* in rarray[nrows] */ rows_tmp, /* in rarray[nnonzeros] */ 
 
3104
    cols_tmp, /* in rarray[nnonzeros] */ values_tmp, &_exception );
3078
3105
  /*dispatch to ior*/
3079
3106
  if (_exception != 0 ) {
 
3107
    sidl__array_deleteRef((struct sidl__array *)ncols_tmp);
 
3108
    sidl__array_deleteRef((struct sidl__array *)rows_tmp);
 
3109
    sidl__array_deleteRef((struct sidl__array *)cols_tmp);
 
3110
    sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
3111
 
3080
3112
    throwException0(_exception);
3081
3113
  }
 
3114
  sidl__array_deleteRef((struct sidl__array *)ncols_tmp);
 
3115
  sidl__array_deleteRef((struct sidl__array *)rows_tmp);
 
3116
  sidl__array_deleteRef((struct sidl__array *)cols_tmp);
 
3117
  sidl__array_deleteRef((struct sidl__array *)values_tmp);
3082
3118
  /*unpack results and cleanup*/
3083
3119
  return _result;
3084
3120
}
3095
3131
 */
3096
3132
int32_t
3097
3133
bHYPRE::IJParCSRMatrix::AddToValues( /* in rarray[nrows] 
3098
 
  */::sidl::array<int32_t> ncols,
3099
 
  /* in rarray[nrows] */::sidl::array<int32_t> rows,
3100
 
  /* in rarray[nnonzeros] */::sidl::array<int32_t> cols,
3101
 
  /* in rarray[nnonzeros] */::sidl::array<double> values )
 
3134
  */::sidl::array<int32_t> ncols, /* in rarray[nrows] */::sidl::array<int32_t> 
 
3135
  rows, /* in rarray[nnonzeros] */::sidl::array<int32_t> cols, /* in 
 
3136
  rarray[nnonzeros] */::sidl::array<double> values )
3102
3137
 
3103
3138
{
3104
3139
  int32_t _result;
3105
 
  ior_t* const loc_self = _get_ior();
 
3140
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3141
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3106
3142
  sidl_BaseInterface__object * _exception;
3107
3143
  /*pack args to dispatch to ior*/
3108
 
  _result = (*(loc_self->d_epv->f_AddToValues))(loc_self,
3109
 
    /* in rarray[nrows] */ ncols._get_ior(),
3110
 
    /* in rarray[nrows] */ rows._get_ior(),
3111
 
    /* in rarray[nnonzeros] */ cols._get_ior(),
3112
 
    /* in rarray[nnonzeros] */ values._get_ior(), &_exception );
 
3144
  _result = (*(loc_self->d_epv->f_AddToValues))(loc_self, /* in rarray[nrows] 
 
3145
    */ ncols._get_ior(), /* in rarray[nrows] */ rows._get_ior(), /* in 
 
3146
    rarray[nnonzeros] */ cols._get_ior(), /* in rarray[nnonzeros] */ 
 
3147
    values._get_ior(), &_exception );
3113
3148
  /*dispatch to ior*/
3114
3149
  if (_exception != 0 ) {
 
3150
 
3115
3151
    throwException0(_exception);
3116
3152
  }
3117
3153
  /*unpack results and cleanup*/
3125
3161
 * column partitioning for this processor.
3126
3162
 */
3127
3163
int32_t
3128
 
bHYPRE::IJParCSRMatrix::GetLocalRange( /* out */int32_t& ilower,
3129
 
  /* out */int32_t& iupper, /* out */int32_t& jlower, /* out */int32_t& jupper )
 
3164
bHYPRE::IJParCSRMatrix::GetLocalRange( /* out */int32_t& ilower, /* out 
 
3165
  */int32_t& iupper, /* out */int32_t& jlower, /* out */int32_t& jupper )
3130
3166
 
3131
3167
{
3132
3168
  int32_t _result;
3133
 
  ior_t* const loc_self = _get_ior();
 
3169
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3170
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3134
3171
  sidl_BaseInterface__object * _exception;
3135
3172
  /*pack args to dispatch to ior*/
3136
 
  _result = (*(loc_self->d_epv->f_GetLocalRange))(loc_self, /* out */ &ilower,
 
3173
  _result = (*(loc_self->d_epv->f_GetLocalRange))(loc_self, /* out */ &ilower, 
3137
3174
    /* out */ &iupper, /* out */ &jlower, /* out */ &jupper, &_exception );
3138
3175
  /*dispatch to ior*/
3139
3176
  if (_exception != 0 ) {
 
3177
 
3140
3178
    throwException0(_exception);
3141
3179
  }
3142
3180
  /*unpack results and cleanup*/
3151
3189
 * which needs to be allocated by the user.
3152
3190
 */
3153
3191
int32_t
3154
 
bHYPRE::IJParCSRMatrix::GetRowCounts( /* in */int32_t nrows,
3155
 
  /* in rarray[nrows] */int32_t* rows, /* inout rarray[nrows] */int32_t* ncols )
 
3192
bHYPRE::IJParCSRMatrix::GetRowCounts( /* in */int32_t nrows, /* in 
 
3193
  rarray[nrows] */int32_t* rows, /* inout rarray[nrows] */int32_t* ncols )
3156
3194
 
3157
3195
{
3158
3196
  int32_t _result;
3159
 
  ior_t* const loc_self = _get_ior();
 
3197
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3198
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3160
3199
  int32_t rows_lower[1], rows_upper[1], rows_stride[1];
3161
3200
  struct sidl_int__array rows_real;
3162
3201
  struct sidl_int__array *rows_tmp = &rows_real;
3166
3205
  struct sidl_int__array ncols_real;
3167
3206
  struct sidl_int__array *ncols_tmp = &ncols_real;
3168
3207
  ncols_upper[0] = nrows-1;
3169
 
  sidl_int__array_init(ncols, ncols_tmp, 1, ncols_lower, ncols_upper,
 
3208
  sidl_int__array_init(ncols, ncols_tmp, 1, ncols_lower, ncols_upper, 
3170
3209
    ncols_stride);
3171
3210
  sidl_BaseInterface__object * _exception;
3172
3211
  /*pack args to dispatch to ior*/
3173
 
  _result = (*(loc_self->d_epv->f_GetRowCounts))(loc_self,
3174
 
    /* in rarray[nrows] */ rows_tmp, /* inout rarray[nrows] */ &ncols_tmp,
3175
 
    &_exception );
 
3212
  _result = (*(loc_self->d_epv->f_GetRowCounts))(loc_self, /* in rarray[nrows] 
 
3213
    */ rows_tmp, /* inout rarray[nrows] */ &ncols_tmp, &_exception );
3176
3214
  /*dispatch to ior*/
3177
3215
  if (_exception != 0 ) {
 
3216
    sidl__array_deleteRef((struct sidl__array *)rows_tmp);
 
3217
    sidl__array_deleteRef((struct sidl__array *)ncols_tmp);
 
3218
 
3178
3219
    throwException0(_exception);
3179
3220
  }
 
3221
  sidl__array_deleteRef((struct sidl__array *)rows_tmp);
 
3222
  sidl__array_deleteRef((struct sidl__array *)ncols_tmp);
3180
3223
  /*unpack results and cleanup*/
3181
3224
  return _result;
3182
3225
}
3190
3233
 */
3191
3234
int32_t
3192
3235
bHYPRE::IJParCSRMatrix::GetRowCounts( /* in rarray[nrows] 
3193
 
  */::sidl::array<int32_t> rows,
3194
 
  /* inout rarray[nrows] */::sidl::array<int32_t>& ncols )
 
3236
  */::sidl::array<int32_t> rows, /* inout rarray[nrows] 
 
3237
  */::sidl::array<int32_t>& ncols )
3195
3238
 
3196
3239
{
3197
3240
  int32_t _result;
3198
 
  ior_t* const loc_self = _get_ior();
 
3241
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3242
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3199
3243
  if (ncols) {
3200
3244
    ncols.addRef();
3201
3245
  }
3202
3246
  struct sidl_int__array* _local_ncols = ncols._get_ior();
3203
3247
  sidl_BaseInterface__object * _exception;
3204
3248
  /*pack args to dispatch to ior*/
3205
 
  _result = (*(loc_self->d_epv->f_GetRowCounts))(loc_self,
3206
 
    /* in rarray[nrows] */ rows._get_ior(),
3207
 
    /* inout rarray[nrows] */ &_local_ncols, &_exception );
 
3249
  _result = (*(loc_self->d_epv->f_GetRowCounts))(loc_self, /* in rarray[nrows] 
 
3250
    */ rows._get_ior(), /* inout rarray[nrows] */ &_local_ncols, &_exception );
3208
3251
  /*dispatch to ior*/
3209
3252
  if (_exception != 0 ) {
 
3253
 
3210
3254
    throwException0(_exception);
3211
3255
  }
3212
3256
  ncols._set_ior(_local_ncols);
3221
3265
 * matrix.  Usage details are analogous to {\tt SetValues}.
3222
3266
 */
3223
3267
int32_t
3224
 
bHYPRE::IJParCSRMatrix::GetValues( /* in */int32_t nrows,
3225
 
  /* in rarray[nrows] */int32_t* ncols, /* in rarray[nrows] */int32_t* rows,
3226
 
  /* in rarray[nnonzeros] */int32_t* cols,
3227
 
  /* inout rarray[nnonzeros] */double* values, /* in */int32_t nnonzeros )
 
3268
bHYPRE::IJParCSRMatrix::GetValues( /* in */int32_t nrows, /* in rarray[nrows] 
 
3269
  */int32_t* ncols, /* in rarray[nrows] */int32_t* rows, /* in 
 
3270
  rarray[nnonzeros] */int32_t* cols, /* inout rarray[nnonzeros] */double* 
 
3271
  values, /* in */int32_t nnonzeros )
3228
3272
 
3229
3273
{
3230
3274
  int32_t _result;
3231
 
  ior_t* const loc_self = _get_ior();
 
3275
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3276
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3232
3277
  int32_t ncols_lower[1], ncols_upper[1], ncols_stride[1];
3233
3278
  struct sidl_int__array ncols_real;
3234
3279
  struct sidl_int__array *ncols_tmp = &ncols_real;
3235
3280
  ncols_upper[0] = nrows-1;
3236
 
  sidl_int__array_init(ncols, ncols_tmp, 1, ncols_lower, ncols_upper,
 
3281
  sidl_int__array_init(ncols, ncols_tmp, 1, ncols_lower, ncols_upper, 
3237
3282
    ncols_stride);
3238
3283
  int32_t rows_lower[1], rows_upper[1], rows_stride[1];
3239
3284
  struct sidl_int__array rows_real;
3249
3294
  struct sidl_double__array values_real;
3250
3295
  struct sidl_double__array *values_tmp = &values_real;
3251
3296
  values_upper[0] = nnonzeros-1;
3252
 
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper,
 
3297
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper, 
3253
3298
    values_stride);
3254
3299
  sidl_BaseInterface__object * _exception;
3255
3300
  /*pack args to dispatch to ior*/
3256
 
  _result = (*(loc_self->d_epv->f_GetValues))(loc_self,
3257
 
    /* in rarray[nrows] */ ncols_tmp, /* in rarray[nrows] */ rows_tmp,
3258
 
    /* in rarray[nnonzeros] */ cols_tmp,
3259
 
    /* inout rarray[nnonzeros] */ &values_tmp, &_exception );
 
3301
  _result = (*(loc_self->d_epv->f_GetValues))(loc_self, /* in rarray[nrows] */ 
 
3302
    ncols_tmp, /* in rarray[nrows] */ rows_tmp, /* in rarray[nnonzeros] */ 
 
3303
    cols_tmp, /* inout rarray[nnonzeros] */ &values_tmp, &_exception );
3260
3304
  /*dispatch to ior*/
3261
3305
  if (_exception != 0 ) {
 
3306
    sidl__array_deleteRef((struct sidl__array *)ncols_tmp);
 
3307
    sidl__array_deleteRef((struct sidl__array *)rows_tmp);
 
3308
    sidl__array_deleteRef((struct sidl__array *)cols_tmp);
 
3309
    sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
3310
 
3262
3311
    throwException0(_exception);
3263
3312
  }
 
3313
  sidl__array_deleteRef((struct sidl__array *)ncols_tmp);
 
3314
  sidl__array_deleteRef((struct sidl__array *)rows_tmp);
 
3315
  sidl__array_deleteRef((struct sidl__array *)cols_tmp);
 
3316
  sidl__array_deleteRef((struct sidl__array *)values_tmp);
3264
3317
  /*unpack results and cleanup*/
3265
3318
  return _result;
3266
3319
}
3273
3326
 */
3274
3327
int32_t
3275
3328
bHYPRE::IJParCSRMatrix::GetValues( /* in rarray[nrows] */::sidl::array<int32_t> 
3276
 
  ncols, /* in rarray[nrows] */::sidl::array<int32_t> rows,
3277
 
  /* in rarray[nnonzeros] */::sidl::array<int32_t> cols,
3278
 
  /* inout rarray[nnonzeros] */::sidl::array<double>& values )
 
3329
  ncols, /* in rarray[nrows] */::sidl::array<int32_t> rows, /* in 
 
3330
  rarray[nnonzeros] */::sidl::array<int32_t> cols, /* inout rarray[nnonzeros] 
 
3331
  */::sidl::array<double>& values )
3279
3332
 
3280
3333
{
3281
3334
  int32_t _result;
3282
 
  ior_t* const loc_self = _get_ior();
 
3335
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3336
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3283
3337
  if (values) {
3284
3338
    values.addRef();
3285
3339
  }
3286
3340
  struct sidl_double__array* _local_values = values._get_ior();
3287
3341
  sidl_BaseInterface__object * _exception;
3288
3342
  /*pack args to dispatch to ior*/
3289
 
  _result = (*(loc_self->d_epv->f_GetValues))(loc_self,
3290
 
    /* in rarray[nrows] */ ncols._get_ior(),
3291
 
    /* in rarray[nrows] */ rows._get_ior(),
3292
 
    /* in rarray[nnonzeros] */ cols._get_ior(),
3293
 
    /* inout rarray[nnonzeros] */ &_local_values, &_exception );
 
3343
  _result = (*(loc_self->d_epv->f_GetValues))(loc_self, /* in rarray[nrows] */ 
 
3344
    ncols._get_ior(), /* in rarray[nrows] */ rows._get_ior(), /* in 
 
3345
    rarray[nnonzeros] */ cols._get_ior(), /* inout rarray[nnonzeros] */ 
 
3346
    &_local_values, &_exception );
3294
3347
  /*dispatch to ior*/
3295
3348
  if (_exception != 0 ) {
 
3349
 
3296
3350
    throwException0(_exception);
3297
3351
  }
3298
3352
  values._set_ior(_local_values);
3313
3367
 * Not collective.
3314
3368
 */
3315
3369
int32_t
3316
 
bHYPRE::IJParCSRMatrix::SetRowSizes( /* in rarray[nrows] */int32_t* sizes,
3317
 
  /* in */int32_t nrows )
 
3370
bHYPRE::IJParCSRMatrix::SetRowSizes( /* in rarray[nrows] */int32_t* sizes, /* 
 
3371
  in */int32_t nrows )
3318
3372
 
3319
3373
{
3320
3374
  int32_t _result;
3321
 
  ior_t* const loc_self = _get_ior();
 
3375
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3376
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3322
3377
  int32_t sizes_lower[1], sizes_upper[1], sizes_stride[1];
3323
3378
  struct sidl_int__array sizes_real;
3324
3379
  struct sidl_int__array *sizes_tmp = &sizes_real;
3325
3380
  sizes_upper[0] = nrows-1;
3326
 
  sidl_int__array_init(sizes, sizes_tmp, 1, sizes_lower, sizes_upper,
 
3381
  sidl_int__array_init(sizes, sizes_tmp, 1, sizes_lower, sizes_upper, 
3327
3382
    sizes_stride);
3328
3383
  sidl_BaseInterface__object * _exception;
3329
3384
  /*pack args to dispatch to ior*/
3330
 
  _result = (*(loc_self->d_epv->f_SetRowSizes))(loc_self,
3331
 
    /* in rarray[nrows] */ sizes_tmp, &_exception );
 
3385
  _result = (*(loc_self->d_epv->f_SetRowSizes))(loc_self, /* in rarray[nrows] 
 
3386
    */ sizes_tmp, &_exception );
3332
3387
  /*dispatch to ior*/
3333
3388
  if (_exception != 0 ) {
 
3389
    sidl__array_deleteRef((struct sidl__array *)sizes_tmp);
 
3390
 
3334
3391
    throwException0(_exception);
3335
3392
  }
 
3393
  sidl__array_deleteRef((struct sidl__array *)sizes_tmp);
3336
3394
  /*unpack results and cleanup*/
3337
3395
  return _result;
3338
3396
}
3355
3413
 
3356
3414
{
3357
3415
  int32_t _result;
3358
 
  ior_t* const loc_self = _get_ior();
 
3416
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3417
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3359
3418
  sidl_BaseInterface__object * _exception;
3360
3419
  /*pack args to dispatch to ior*/
3361
 
  _result = (*(loc_self->d_epv->f_SetRowSizes))(loc_self,
3362
 
    /* in rarray[nrows] */ sizes._get_ior(), &_exception );
 
3420
  _result = (*(loc_self->d_epv->f_SetRowSizes))(loc_self, /* in rarray[nrows] 
 
3421
    */ sizes._get_ior(), &_exception );
3363
3422
  /*dispatch to ior*/
3364
3423
  if (_exception != 0 ) {
 
3424
 
3365
3425
    throwException0(_exception);
3366
3426
  }
3367
3427
  /*unpack results and cleanup*/
3379
3439
 
3380
3440
{
3381
3441
  int32_t _result;
3382
 
  ior_t* const loc_self = _get_ior();
 
3442
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3443
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3383
3444
  sidl_BaseInterface__object * _exception;
3384
3445
  /*pack args to dispatch to ior*/
3385
 
  _result = (*(loc_self->d_epv->f_Print))(loc_self, /* in */ filename.c_str(),
 
3446
  _result = (*(loc_self->d_epv->f_Print))(loc_self, /* in */ filename.c_str(), 
3386
3447
    &_exception );
3387
3448
  /*dispatch to ior*/
3388
3449
  if (_exception != 0 ) {
 
3450
 
3389
3451
    throwException0(_exception);
3390
3452
  }
3391
3453
  /*unpack results and cleanup*/
3399
3461
 * purposes.
3400
3462
 */
3401
3463
int32_t
3402
 
bHYPRE::IJParCSRMatrix::Read( /* in */const ::std::string& filename,
3403
 
  /* in */::bHYPRE::MPICommunicator comm )
 
3464
bHYPRE::IJParCSRMatrix::Read( /* in */const ::std::string& filename, /* in 
 
3465
  */::bHYPRE::MPICommunicator comm )
3404
3466
 
3405
3467
{
3406
3468
  int32_t _result;
3407
 
  ior_t* const loc_self = _get_ior();
3408
 
  struct bHYPRE_MPICommunicator__object* _local_comm = comm._get_ior();
 
3469
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3470
    ::bHYPRE::IJParCSRMatrix::_get_ior();
 
3471
  struct bHYPRE_MPICommunicator__object* _local_comm = (struct 
 
3472
    bHYPRE_MPICommunicator__object*) comm.::bHYPRE::MPICommunicator::_get_ior();
3409
3473
  sidl_BaseInterface__object * _exception;
3410
3474
  /*pack args to dispatch to ior*/
3411
 
  _result = (*(loc_self->d_epv->f_Read))(loc_self, /* in */ filename.c_str(),
 
3475
  _result = (*(loc_self->d_epv->f_Read))(loc_self, /* in */ filename.c_str(), 
3412
3476
    /* in */ _local_comm, &_exception );
3413
3477
  /*dispatch to ior*/
3414
3478
  if (_exception != 0 ) {
 
3479
 
3415
3480
    throwException0(_exception);
3416
3481
  }
3417
3482
  /*unpack results and cleanup*/
3429
3494
 
3430
3495
{
3431
3496
  int32_t _result;
3432
 
  ior_t* const loc_self = _get_ior();
3433
 
  struct bHYPRE_MPICommunicator__object* _local_mpi_comm = mpi_comm._get_ior();
 
3497
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3498
    ::bHYPRE::IJParCSRMatrix::_get_ior();
 
3499
  struct bHYPRE_MPICommunicator__object* _local_mpi_comm = (struct 
 
3500
    bHYPRE_MPICommunicator__object*) 
 
3501
    mpi_comm.::bHYPRE::MPICommunicator::_get_ior();
3434
3502
  sidl_BaseInterface__object * _exception;
3435
3503
  /*pack args to dispatch to ior*/
3436
 
  _result = (*(loc_self->d_epv->f_SetCommunicator))(loc_self,
3437
 
    /* in */ _local_mpi_comm, &_exception );
 
3504
  _result = (*(loc_self->d_epv->f_SetCommunicator))(loc_self, /* in */ 
 
3505
    _local_mpi_comm, &_exception );
3438
3506
  /*dispatch to ior*/
3439
3507
  if (_exception != 0 ) {
 
3508
 
3440
3509
    throwException0(_exception);
3441
3510
  }
3442
3511
  /*unpack results and cleanup*/
3456
3525
 
3457
3526
{
3458
3527
 
3459
 
  ior_t* const loc_self = _get_ior();
 
3528
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3529
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3460
3530
  sidl_BaseInterface__object * _exception;
3461
3531
  /*pack args to dispatch to ior*/
3462
3532
  (*(loc_self->d_epv->f_Destroy))(loc_self, &_exception );
3463
3533
  /*dispatch to ior*/
3464
3534
  if (_exception != 0 ) {
 
3535
 
3465
3536
    throwException0(_exception);
3466
3537
  }
3467
3538
  /*unpack results and cleanup*/
3478
3549
 
3479
3550
{
3480
3551
  int32_t _result;
3481
 
  ior_t* const loc_self = _get_ior();
 
3552
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3553
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3482
3554
  sidl_BaseInterface__object * _exception;
3483
3555
  /*pack args to dispatch to ior*/
3484
3556
  _result = (*(loc_self->d_epv->f_Initialize))(loc_self, &_exception );
3485
3557
  /*dispatch to ior*/
3486
3558
  if (_exception != 0 ) {
 
3559
 
3487
3560
    throwException0(_exception);
3488
3561
  }
3489
3562
  /*unpack results and cleanup*/
3504
3577
 
3505
3578
{
3506
3579
  int32_t _result;
3507
 
  ior_t* const loc_self = _get_ior();
 
3580
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3581
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3508
3582
  sidl_BaseInterface__object * _exception;
3509
3583
  /*pack args to dispatch to ior*/
3510
3584
  _result = (*(loc_self->d_epv->f_Assemble))(loc_self, &_exception );
3511
3585
  /*dispatch to ior*/
3512
3586
  if (_exception != 0 ) {
 
3587
 
3513
3588
    throwException0(_exception);
3514
3589
  }
3515
3590
  /*unpack results and cleanup*/
3522
3597
 * Set the int parameter associated with {\tt name}.
3523
3598
 */
3524
3599
int32_t
3525
 
bHYPRE::IJParCSRMatrix::SetIntParameter( /* in */const ::std::string& name,
3526
 
  /* in */int32_t value )
 
3600
bHYPRE::IJParCSRMatrix::SetIntParameter( /* in */const ::std::string& name, /* 
 
3601
  in */int32_t value )
3527
3602
 
3528
3603
{
3529
3604
  int32_t _result;
3530
 
  ior_t* const loc_self = _get_ior();
 
3605
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3606
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3531
3607
  sidl_BaseInterface__object * _exception;
3532
3608
  /*pack args to dispatch to ior*/
3533
 
  _result = (*(loc_self->d_epv->f_SetIntParameter))(loc_self,
3534
 
    /* in */ name.c_str(), /* in */ value, &_exception );
 
3609
  _result = (*(loc_self->d_epv->f_SetIntParameter))(loc_self, /* in */ 
 
3610
    name.c_str(), /* in */ value, &_exception );
3535
3611
  /*dispatch to ior*/
3536
3612
  if (_exception != 0 ) {
 
3613
 
3537
3614
    throwException0(_exception);
3538
3615
  }
3539
3616
  /*unpack results and cleanup*/
3546
3623
 * Set the double parameter associated with {\tt name}.
3547
3624
 */
3548
3625
int32_t
3549
 
bHYPRE::IJParCSRMatrix::SetDoubleParameter( /* in */const ::std::string& name,
 
3626
bHYPRE::IJParCSRMatrix::SetDoubleParameter( /* in */const ::std::string& name, 
3550
3627
  /* in */double value )
3551
3628
 
3552
3629
{
3553
3630
  int32_t _result;
3554
 
  ior_t* const loc_self = _get_ior();
 
3631
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3632
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3555
3633
  sidl_BaseInterface__object * _exception;
3556
3634
  /*pack args to dispatch to ior*/
3557
 
  _result = (*(loc_self->d_epv->f_SetDoubleParameter))(loc_self,
3558
 
    /* in */ name.c_str(), /* in */ value, &_exception );
 
3635
  _result = (*(loc_self->d_epv->f_SetDoubleParameter))(loc_self, /* in */ 
 
3636
    name.c_str(), /* in */ value, &_exception );
3559
3637
  /*dispatch to ior*/
3560
3638
  if (_exception != 0 ) {
 
3639
 
3561
3640
    throwException0(_exception);
3562
3641
  }
3563
3642
  /*unpack results and cleanup*/
3570
3649
 * Set the string parameter associated with {\tt name}.
3571
3650
 */
3572
3651
int32_t
3573
 
bHYPRE::IJParCSRMatrix::SetStringParameter( /* in */const ::std::string& name,
 
3652
bHYPRE::IJParCSRMatrix::SetStringParameter( /* in */const ::std::string& name, 
3574
3653
  /* in */const ::std::string& value )
3575
3654
 
3576
3655
{
3577
3656
  int32_t _result;
3578
 
  ior_t* const loc_self = _get_ior();
 
3657
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3658
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3579
3659
  sidl_BaseInterface__object * _exception;
3580
3660
  /*pack args to dispatch to ior*/
3581
 
  _result = (*(loc_self->d_epv->f_SetStringParameter))(loc_self,
3582
 
    /* in */ name.c_str(), /* in */ value.c_str(), &_exception );
 
3661
  _result = (*(loc_self->d_epv->f_SetStringParameter))(loc_self, /* in */ 
 
3662
    name.c_str(), /* in */ value.c_str(), &_exception );
3583
3663
  /*dispatch to ior*/
3584
3664
  if (_exception != 0 ) {
 
3665
 
3585
3666
    throwException0(_exception);
3586
3667
  }
3587
3668
  /*unpack results and cleanup*/
3599
3680
 
3600
3681
{
3601
3682
  int32_t _result;
3602
 
  ior_t* const loc_self = _get_ior();
 
3683
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3684
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3603
3685
  int32_t value_lower[1], value_upper[1], value_stride[1];
3604
3686
  struct sidl_int__array value_real;
3605
3687
  struct sidl_int__array *value_tmp = &value_real;
3606
3688
  value_upper[0] = nvalues-1;
3607
 
  sidl_int__array_init(value, value_tmp, 1, value_lower, value_upper,
 
3689
  sidl_int__array_init(value, value_tmp, 1, value_lower, value_upper, 
3608
3690
    value_stride);
3609
3691
  sidl_BaseInterface__object * _exception;
3610
3692
  /*pack args to dispatch to ior*/
3611
 
  _result = (*(loc_self->d_epv->f_SetIntArray1Parameter))(loc_self,
3612
 
    /* in */ name.c_str(), /* in rarray[nvalues] */ value_tmp, &_exception );
 
3693
  _result = (*(loc_self->d_epv->f_SetIntArray1Parameter))(loc_self, /* in */ 
 
3694
    name.c_str(), /* in rarray[nvalues] */ value_tmp, &_exception );
3613
3695
  /*dispatch to ior*/
3614
3696
  if (_exception != 0 ) {
 
3697
    sidl__array_deleteRef((struct sidl__array *)value_tmp);
 
3698
 
3615
3699
    throwException0(_exception);
3616
3700
  }
 
3701
  sidl__array_deleteRef((struct sidl__array *)value_tmp);
3617
3702
  /*unpack results and cleanup*/
3618
3703
  return _result;
3619
3704
}
3629
3714
 
3630
3715
{
3631
3716
  int32_t _result;
3632
 
  ior_t* const loc_self = _get_ior();
 
3717
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3718
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3633
3719
  sidl_BaseInterface__object * _exception;
3634
3720
  /*pack args to dispatch to ior*/
3635
 
  _result = (*(loc_self->d_epv->f_SetIntArray1Parameter))(loc_self,
3636
 
    /* in */ name.c_str(), /* in rarray[nvalues] */ value._get_ior(),
3637
 
    &_exception );
 
3721
  _result = (*(loc_self->d_epv->f_SetIntArray1Parameter))(loc_self, /* in */ 
 
3722
    name.c_str(), /* in rarray[nvalues] */ value._get_ior(), &_exception );
3638
3723
  /*dispatch to ior*/
3639
3724
  if (_exception != 0 ) {
 
3725
 
3640
3726
    throwException0(_exception);
3641
3727
  }
3642
3728
  /*unpack results and cleanup*/
3654
3740
 
3655
3741
{
3656
3742
  int32_t _result;
3657
 
  ior_t* const loc_self = _get_ior();
 
3743
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3744
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3658
3745
  sidl_BaseInterface__object * _exception;
3659
3746
  /*pack args to dispatch to ior*/
3660
 
  _result = (*(loc_self->d_epv->f_SetIntArray2Parameter))(loc_self,
3661
 
    /* in */ name.c_str(), /* in array<int,2,column-major> */ value._get_ior(),
 
3747
  _result = (*(loc_self->d_epv->f_SetIntArray2Parameter))(loc_self, /* in */ 
 
3748
    name.c_str(), /* in array<int,2,column-major> */ value._get_ior(), 
3662
3749
    &_exception );
3663
3750
  /*dispatch to ior*/
3664
3751
  if (_exception != 0 ) {
 
3752
 
3665
3753
    throwException0(_exception);
3666
3754
  }
3667
3755
  /*unpack results and cleanup*/
3679
3767
 
3680
3768
{
3681
3769
  int32_t _result;
3682
 
  ior_t* const loc_self = _get_ior();
 
3770
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3771
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3683
3772
  int32_t value_lower[1], value_upper[1], value_stride[1];
3684
3773
  struct sidl_double__array value_real;
3685
3774
  struct sidl_double__array *value_tmp = &value_real;
3686
3775
  value_upper[0] = nvalues-1;
3687
 
  sidl_double__array_init(value, value_tmp, 1, value_lower, value_upper,
 
3776
  sidl_double__array_init(value, value_tmp, 1, value_lower, value_upper, 
3688
3777
    value_stride);
3689
3778
  sidl_BaseInterface__object * _exception;
3690
3779
  /*pack args to dispatch to ior*/
3691
 
  _result = (*(loc_self->d_epv->f_SetDoubleArray1Parameter))(loc_self,
3692
 
    /* in */ name.c_str(), /* in rarray[nvalues] */ value_tmp, &_exception );
 
3780
  _result = (*(loc_self->d_epv->f_SetDoubleArray1Parameter))(loc_self, /* in */ 
 
3781
    name.c_str(), /* in rarray[nvalues] */ value_tmp, &_exception );
3693
3782
  /*dispatch to ior*/
3694
3783
  if (_exception != 0 ) {
 
3784
    sidl__array_deleteRef((struct sidl__array *)value_tmp);
 
3785
 
3695
3786
    throwException0(_exception);
3696
3787
  }
 
3788
  sidl__array_deleteRef((struct sidl__array *)value_tmp);
3697
3789
  /*unpack results and cleanup*/
3698
3790
  return _result;
3699
3791
}
3709
3801
 
3710
3802
{
3711
3803
  int32_t _result;
3712
 
  ior_t* const loc_self = _get_ior();
 
3804
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3805
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3713
3806
  sidl_BaseInterface__object * _exception;
3714
3807
  /*pack args to dispatch to ior*/
3715
 
  _result = (*(loc_self->d_epv->f_SetDoubleArray1Parameter))(loc_self,
3716
 
    /* in */ name.c_str(), /* in rarray[nvalues] */ value._get_ior(),
3717
 
    &_exception );
 
3808
  _result = (*(loc_self->d_epv->f_SetDoubleArray1Parameter))(loc_self, /* in */ 
 
3809
    name.c_str(), /* in rarray[nvalues] */ value._get_ior(), &_exception );
3718
3810
  /*dispatch to ior*/
3719
3811
  if (_exception != 0 ) {
 
3812
 
3720
3813
    throwException0(_exception);
3721
3814
  }
3722
3815
  /*unpack results and cleanup*/
3734
3827
 
3735
3828
{
3736
3829
  int32_t _result;
3737
 
  ior_t* const loc_self = _get_ior();
 
3830
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3831
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3738
3832
  sidl_BaseInterface__object * _exception;
3739
3833
  /*pack args to dispatch to ior*/
3740
 
  _result = (*(loc_self->d_epv->f_SetDoubleArray2Parameter))(loc_self,
3741
 
    /* in */ name.c_str(), /* in array<double,2,
3742
 
    column-major> */ value._get_ior(), &_exception );
 
3834
  _result = (*(loc_self->d_epv->f_SetDoubleArray2Parameter))(loc_self, /* in */ 
 
3835
    name.c_str(), /* in array<double,2,column-major> */ value._get_ior(), 
 
3836
    &_exception );
3743
3837
  /*dispatch to ior*/
3744
3838
  if (_exception != 0 ) {
 
3839
 
3745
3840
    throwException0(_exception);
3746
3841
  }
3747
3842
  /*unpack results and cleanup*/
3754
3849
 * Set the int parameter associated with {\tt name}.
3755
3850
 */
3756
3851
int32_t
3757
 
bHYPRE::IJParCSRMatrix::GetIntValue( /* in */const ::std::string& name,
3758
 
  /* out */int32_t& value )
 
3852
bHYPRE::IJParCSRMatrix::GetIntValue( /* in */const ::std::string& name, /* out 
 
3853
  */int32_t& value )
3759
3854
 
3760
3855
{
3761
3856
  int32_t _result;
3762
 
  ior_t* const loc_self = _get_ior();
 
3857
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3858
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3763
3859
  sidl_BaseInterface__object * _exception;
3764
3860
  /*pack args to dispatch to ior*/
3765
3861
  _result = (*(loc_self->d_epv->f_GetIntValue))(loc_self, /* in */ name.c_str(),
3766
3862
    /* out */ &value, &_exception );
3767
3863
  /*dispatch to ior*/
3768
3864
  if (_exception != 0 ) {
 
3865
 
3769
3866
    throwException0(_exception);
3770
3867
  }
3771
3868
  /*unpack results and cleanup*/
3778
3875
 * Get the double parameter associated with {\tt name}.
3779
3876
 */
3780
3877
int32_t
3781
 
bHYPRE::IJParCSRMatrix::GetDoubleValue( /* in */const ::std::string& name,
3782
 
  /* out */double& value )
 
3878
bHYPRE::IJParCSRMatrix::GetDoubleValue( /* in */const ::std::string& name, /* 
 
3879
  out */double& value )
3783
3880
 
3784
3881
{
3785
3882
  int32_t _result;
3786
 
  ior_t* const loc_self = _get_ior();
 
3883
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3884
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3787
3885
  sidl_BaseInterface__object * _exception;
3788
3886
  /*pack args to dispatch to ior*/
3789
 
  _result = (*(loc_self->d_epv->f_GetDoubleValue))(loc_self,
3790
 
    /* in */ name.c_str(), /* out */ &value, &_exception );
 
3887
  _result = (*(loc_self->d_epv->f_GetDoubleValue))(loc_self, /* in */ 
 
3888
    name.c_str(), /* out */ &value, &_exception );
3791
3889
  /*dispatch to ior*/
3792
3890
  if (_exception != 0 ) {
 
3891
 
3793
3892
    throwException0(_exception);
3794
3893
  }
3795
3894
  /*unpack results and cleanup*/
3803
3902
 * order to execute {\tt Apply}.
3804
3903
 */
3805
3904
int32_t
3806
 
bHYPRE::IJParCSRMatrix::Setup( /* in */::bHYPRE::Vector b,
3807
 
  /* in */::bHYPRE::Vector x )
 
3905
bHYPRE::IJParCSRMatrix::Setup( /* in */::bHYPRE::Vector b, /* in 
 
3906
  */::bHYPRE::Vector x )
3808
3907
 
3809
3908
{
3810
3909
  int32_t _result;
3811
 
  ior_t* const loc_self = _get_ior();
 
3910
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3911
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3812
3912
  struct bHYPRE_Vector__object* _local_b = (struct bHYPRE_Vector__object*) 
3813
 
    ::bHYPRE::Vector::_cast((void*)(b._get_ior()));
 
3913
    b.::bHYPRE::Vector::_get_ior();
3814
3914
  struct bHYPRE_Vector__object* _local_x = (struct bHYPRE_Vector__object*) 
3815
 
    ::bHYPRE::Vector::_cast((void*)(x._get_ior()));
 
3915
    x.::bHYPRE::Vector::_get_ior();
3816
3916
  sidl_BaseInterface__object * _exception;
3817
3917
  /*pack args to dispatch to ior*/
3818
 
  _result = (*(loc_self->d_epv->f_Setup))(loc_self, /* in */ _local_b,
3819
 
    /* in */ _local_x, &_exception );
 
3918
  _result = (*(loc_self->d_epv->f_Setup))(loc_self, /* in */ _local_b, /* in */ 
 
3919
    _local_x, &_exception );
3820
3920
  /*dispatch to ior*/
3821
3921
  if (_exception != 0 ) {
 
3922
 
3822
3923
    throwException0(_exception);
3823
3924
  }
3824
 
  if (_local_b) {
3825
 
    struct sidl_BaseInterface__object *throwaway_exception;  
3826
 
    (_local_b->d_epv->f_deleteRef)(_local_b->d_object, &throwaway_exception);
3827
 
  }
3828
 
  if (_local_x) {
3829
 
    struct sidl_BaseInterface__object *throwaway_exception;  
3830
 
    (_local_x->d_epv->f_deleteRef)(_local_x->d_object, &throwaway_exception);
3831
 
  }
3832
3925
  /*unpack results and cleanup*/
3833
3926
  return _result;
3834
3927
}
3839
3932
 * Apply the operator to {\tt b}, returning {\tt x}.
3840
3933
 */
3841
3934
int32_t
3842
 
bHYPRE::IJParCSRMatrix::Apply( /* in */::bHYPRE::Vector b,
3843
 
  /* inout */::bHYPRE::Vector& x )
 
3935
bHYPRE::IJParCSRMatrix::Apply( /* in */::bHYPRE::Vector b, /* inout 
 
3936
  */::bHYPRE::Vector& x )
3844
3937
 
3845
3938
{
3846
3939
  int32_t _result;
3847
 
  ior_t* const loc_self = _get_ior();
 
3940
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3941
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3848
3942
  struct bHYPRE_Vector__object* _local_b = (struct bHYPRE_Vector__object*) 
3849
 
    ::bHYPRE::Vector::_cast((void*)(b._get_ior()));
 
3943
    b.::bHYPRE::Vector::_get_ior();
3850
3944
  struct bHYPRE_Vector__object* _local_x = (struct bHYPRE_Vector__object*) 
3851
 
    ::bHYPRE::Vector::_cast((void*)(x._get_ior()));
3852
 
  if (x._not_nil()) { x.deleteRef(); }
 
3945
    x.::bHYPRE::Vector::_get_ior();
3853
3946
  sidl_BaseInterface__object * _exception;
3854
3947
  /*pack args to dispatch to ior*/
3855
 
  _result = (*(loc_self->d_epv->f_Apply))(loc_self, /* in */ _local_b,
3856
 
    /* inout */ &_local_x, &_exception );
 
3948
  _result = (*(loc_self->d_epv->f_Apply))(loc_self, /* in */ _local_b, /* inout 
 
3949
    */ &_local_x, &_exception );
3857
3950
  /*dispatch to ior*/
3858
3951
  if (_exception != 0 ) {
 
3952
 
3859
3953
    throwException0(_exception);
3860
3954
  }
3861
 
  if (_local_b) {
3862
 
    struct sidl_BaseInterface__object *throwaway_exception;  
3863
 
    (_local_b->d_epv->f_deleteRef)(_local_b->d_object, &throwaway_exception);
3864
 
  }
3865
3955
  x._set_ior( _local_x);
3866
3956
  /*unpack results and cleanup*/
3867
3957
  return _result;
3873
3963
 * Apply the adjoint of the operator to {\tt b}, returning {\tt x}.
3874
3964
 */
3875
3965
int32_t
3876
 
bHYPRE::IJParCSRMatrix::ApplyAdjoint( /* in */::bHYPRE::Vector b,
3877
 
  /* inout */::bHYPRE::Vector& x )
 
3966
bHYPRE::IJParCSRMatrix::ApplyAdjoint( /* in */::bHYPRE::Vector b, /* inout 
 
3967
  */::bHYPRE::Vector& x )
3878
3968
 
3879
3969
{
3880
3970
  int32_t _result;
3881
 
  ior_t* const loc_self = _get_ior();
 
3971
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
3972
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3882
3973
  struct bHYPRE_Vector__object* _local_b = (struct bHYPRE_Vector__object*) 
3883
 
    ::bHYPRE::Vector::_cast((void*)(b._get_ior()));
 
3974
    b.::bHYPRE::Vector::_get_ior();
3884
3975
  struct bHYPRE_Vector__object* _local_x = (struct bHYPRE_Vector__object*) 
3885
 
    ::bHYPRE::Vector::_cast((void*)(x._get_ior()));
3886
 
  if (x._not_nil()) { x.deleteRef(); }
 
3976
    x.::bHYPRE::Vector::_get_ior();
3887
3977
  sidl_BaseInterface__object * _exception;
3888
3978
  /*pack args to dispatch to ior*/
3889
 
  _result = (*(loc_self->d_epv->f_ApplyAdjoint))(loc_self, /* in */ _local_b,
 
3979
  _result = (*(loc_self->d_epv->f_ApplyAdjoint))(loc_self, /* in */ _local_b, 
3890
3980
    /* inout */ &_local_x, &_exception );
3891
3981
  /*dispatch to ior*/
3892
3982
  if (_exception != 0 ) {
 
3983
 
3893
3984
    throwException0(_exception);
3894
3985
  }
3895
 
  if (_local_b) {
3896
 
    struct sidl_BaseInterface__object *throwaway_exception;  
3897
 
    (_local_b->d_epv->f_deleteRef)(_local_b->d_object, &throwaway_exception);
3898
 
  }
3899
3986
  x._set_ior( _local_x);
3900
3987
  /*unpack results and cleanup*/
3901
3988
  return _result;
3911
3998
 * next GetRow call.
3912
3999
 */
3913
4000
int32_t
3914
 
bHYPRE::IJParCSRMatrix::GetRow( /* in */int32_t row, /* out */int32_t& size,
3915
 
  /* out array<int,column-major> */::sidl::array<int32_t>& col_ind,
3916
 
  /* out array<double,column-major> */::sidl::array<double>& values )
 
4001
bHYPRE::IJParCSRMatrix::GetRow( /* in */int32_t row, /* out */int32_t& size, /* 
 
4002
  out array<int,column-major> */::sidl::array<int32_t>& col_ind, /* out 
 
4003
  array<double,column-major> */::sidl::array<double>& values )
3917
4004
 
3918
4005
{
3919
4006
  int32_t _result;
3920
 
  ior_t* const loc_self = _get_ior();
 
4007
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
4008
    ::bHYPRE::IJParCSRMatrix::_get_ior();
3921
4009
  struct sidl_int__array* _local_col_ind;
3922
4010
  struct sidl_double__array* _local_values;
3923
4011
  sidl_BaseInterface__object * _exception;
3924
4012
  /*pack args to dispatch to ior*/
3925
 
  _result = (*(loc_self->d_epv->f_GetRow))(loc_self, /* in */ row,
3926
 
    /* out */ &size, /* out array<int,column-major> */ &_local_col_ind,
3927
 
    /* out array<double,column-major> */ &_local_values, &_exception );
 
4013
  _result = (*(loc_self->d_epv->f_GetRow))(loc_self, /* in */ row, /* out */ 
 
4014
    &size, /* out array<int,column-major> */ &_local_col_ind, /* out 
 
4015
    array<double,column-major> */ &_local_values, &_exception );
3928
4016
  /*dispatch to ior*/
3929
4017
  if (_exception != 0 ) {
 
4018
 
3930
4019
    throwException0(_exception);
3931
4020
  }
3932
4021
  col_ind._set_ior(_local_col_ind);
3947
4036
// static constructor
3948
4037
::bHYPRE::IJParCSRMatrix
3949
4038
bHYPRE::IJParCSRMatrix::_create() {
3950
 
  struct sidl_BaseInterface__object * _exception, *_throwaway;
3951
 
  ::bHYPRE::IJParCSRMatrix self( (*_get_ext()->createObject)(NULL,&_exception),
 
4039
  struct sidl_BaseInterface__object * _exception;
 
4040
  ::bHYPRE::IJParCSRMatrix self( (*_get_ext()->createObject)(NULL,&_exception), 
3952
4041
    false );
3953
4042
  if (_exception) {
3954
 
    void *_p;
3955
 
    if ( (_p = (*(_exception->d_epv->f__cast))(_exception->d_object,
3956
 
      "sidl.RuntimeException", &_throwaway)) != 0) {
3957
 
    ::sidl::RuntimeException _resolved(reinterpret_cast< struct 
3958
 
      sidl_RuntimeException__object * >(_p), false);
3959
 
    (*(_exception->d_epv->f_deleteRef))(_exception->d_object, &_throwaway);
3960
 
    _resolved.add(__FILE__,__LINE__,"C++ ctor.");
3961
 
    throw _resolved;
 
4043
    throwException0(_exception);
3962
4044
  }
3963
 
}
3964
 
return self;
 
4045
  return self;
3965
4046
}
3966
4047
 
3967
4048
// Internal data wrapping method
3968
4049
::bHYPRE::IJParCSRMatrix::ior_t*
3969
4050
bHYPRE::IJParCSRMatrix::_wrapObj(void* private_data) {
3970
 
  struct sidl_BaseInterface__object *throwaway_exception;
3971
 
  return (*_get_ext()->createObject)(private_data,&throwaway_exception);
 
4051
  struct sidl_BaseInterface__object *_exception;
 
4052
  ::bHYPRE::IJParCSRMatrix::ior_t* returnValue = (*_get_ext()->createObject)(
 
4053
    private_data,&_exception);
 
4054
  if (_exception) {
 
4055
    throwException0(_exception);
 
4056
  }
 
4057
  return returnValue;
3972
4058
}
3973
4059
 
3974
4060
// remote constructor
3975
4061
::bHYPRE::IJParCSRMatrix
3976
4062
bHYPRE::IJParCSRMatrix::_create(const std::string& url) {
3977
4063
  ior_t* ior_self;
3978
 
  sidl_BaseInterface__object* _ex = 0;
3979
 
  ior_self = bHYPRE_IJParCSRMatrix__remoteCreate( url.c_str(), &_ex );
3980
 
  if (_ex != 0 ) {
3981
 
    ; //TODO: handle exception
 
4064
  struct sidl_BaseInterface__object *_exception;
 
4065
  ior_self = bHYPRE_IJParCSRMatrix__remoteCreate( url.c_str(), &_exception );
 
4066
  if (_exception != 0 ) {
 
4067
    throwException0(_exception);
3982
4068
  }
3983
4069
  return ::bHYPRE::IJParCSRMatrix( ior_self, false );
3984
4070
}
3985
4071
 
3986
 
// remote connector 2
 
4072
// remote connector
3987
4073
::bHYPRE::IJParCSRMatrix
3988
4074
bHYPRE::IJParCSRMatrix::_connect(const std::string& url, const bool ar ) {
3989
4075
  ior_t* ior_self;
3990
 
  sidl_BaseInterface__object* _ex = 0;
3991
 
  ior_self = bHYPRE_IJParCSRMatrix__remoteConnect( url.c_str(), ar?TRUE:FALSE,
3992
 
    &_ex );
3993
 
  if (_ex != 0 ) {
3994
 
    ; //TODO: handle exception
 
4076
  struct sidl_BaseInterface__object *_exception;
 
4077
  ior_self = bHYPRE_IJParCSRMatrix__remoteConnect( url.c_str(), ar?TRUE:FALSE, 
 
4078
    &_exception );
 
4079
  if (_exception != 0 ) {
 
4080
    throwException0(_exception);
3995
4081
  }
3996
4082
  return ::bHYPRE::IJParCSRMatrix( ior_self, false );
3997
4083
}
3999
4085
// copy constructor
4000
4086
bHYPRE::IJParCSRMatrix::IJParCSRMatrix ( const ::bHYPRE::IJParCSRMatrix& 
4001
4087
  original ) {
4002
 
  d_self = ::bHYPRE::IJParCSRMatrix::_cast(original._get_ior());
 
4088
  d_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
4089
    original.::bHYPRE::IJParCSRMatrix::_get_ior();
 
4090
  if(d_self) {
 
4091
 
 
4092
    bHYPRE_CoefficientAccess_IORCache = &((*reinterpret_cast< ior_t*>(
 
4093
      d_self)).d_bhypre_coefficientaccess);
 
4094
    bHYPRE_Operator_IORCache = &((*reinterpret_cast< ior_t*>(
 
4095
      d_self)).d_bhypre_operator);
 
4096
    bHYPRE_IJMatrixView_IORCache = &((*reinterpret_cast< ior_t*>(
 
4097
      d_self)).d_bhypre_ijmatrixview);
 
4098
    bHYPRE_ProblemDefinition_IORCache = &((*reinterpret_cast< ior_t*>(
 
4099
      d_self)).d_bhypre_problemdefinition);
 
4100
    bHYPRE_MatrixVectorView_IORCache = &((*reinterpret_cast< ior_t*>(
 
4101
      d_self)).d_bhypre_matrixvectorview);
 
4102
 
 
4103
    addRef();
 
4104
  }
4003
4105
  d_weak_reference = false;
4004
4106
}
4005
4107
 
4010
4112
    if ( d_self != 0 ) {
4011
4113
      deleteRef();
4012
4114
    }
4013
 
    d_self = ::bHYPRE::IJParCSRMatrix::_cast(rhs._get_ior());
4014
 
    // note _cast incremements the reference count
 
4115
    d_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
4116
      rhs.::bHYPRE::IJParCSRMatrix::_get_ior();
 
4117
    if(d_self) {
 
4118
 
 
4119
      bHYPRE_CoefficientAccess_IORCache = &((*reinterpret_cast< ior_t*>(
 
4120
        d_self)).d_bhypre_coefficientaccess);
 
4121
      bHYPRE_Operator_IORCache = &((*reinterpret_cast< ior_t*>(
 
4122
        d_self)).d_bhypre_operator);
 
4123
      bHYPRE_IJMatrixView_IORCache = &((*reinterpret_cast< ior_t*>(
 
4124
        d_self)).d_bhypre_ijmatrixview);
 
4125
      bHYPRE_ProblemDefinition_IORCache = &((*reinterpret_cast< ior_t*>(
 
4126
        d_self)).d_bhypre_problemdefinition);
 
4127
      bHYPRE_MatrixVectorView_IORCache = &((*reinterpret_cast< ior_t*>(
 
4128
        d_self)).d_bhypre_matrixvectorview);
 
4129
 
 
4130
      addRef();
 
4131
    }
4015
4132
    d_weak_reference = false;
4016
4133
  }
4017
4134
  return *this;
4019
4136
 
4020
4137
// conversion from ior to C++ class
4021
4138
bHYPRE::IJParCSRMatrix::IJParCSRMatrix ( ::bHYPRE::IJParCSRMatrix::ior_t* ior ) 
4022
 
   : StubBase(reinterpret_cast< void*>(ior)) { }
 
4139
   : StubBase(reinterpret_cast< void*>(ior)) { 
 
4140
  if(d_self) {
 
4141
 
 
4142
    bHYPRE_CoefficientAccess_IORCache = &((*reinterpret_cast< ior_t*>(
 
4143
      d_self)).d_bhypre_coefficientaccess);
 
4144
    bHYPRE_Operator_IORCache = &((*reinterpret_cast< ior_t*>(
 
4145
      d_self)).d_bhypre_operator);
 
4146
    bHYPRE_IJMatrixView_IORCache = &((*reinterpret_cast< ior_t*>(
 
4147
      d_self)).d_bhypre_ijmatrixview);
 
4148
    bHYPRE_ProblemDefinition_IORCache = &((*reinterpret_cast< ior_t*>(
 
4149
      d_self)).d_bhypre_problemdefinition);
 
4150
    bHYPRE_MatrixVectorView_IORCache = &((*reinterpret_cast< ior_t*>(
 
4151
      d_self)).d_bhypre_matrixvectorview);
 
4152
 
 
4153
  }
 
4154
}
4023
4155
 
4024
4156
// Alternate constructor: does not call addRef()
4025
4157
// (sets d_weak_reference=isWeak)
4026
4158
// For internal use by Impls (fixes bug#275)
4027
 
bHYPRE::IJParCSRMatrix::IJParCSRMatrix ( ::bHYPRE::IJParCSRMatrix::ior_t* ior,
 
4159
bHYPRE::IJParCSRMatrix::IJParCSRMatrix ( ::bHYPRE::IJParCSRMatrix::ior_t* ior, 
4028
4160
  bool isWeak ) : 
4029
4161
StubBase(reinterpret_cast< void*>(ior), isWeak){ 
 
4162
  if(d_self) {
 
4163
 
 
4164
    bHYPRE_CoefficientAccess_IORCache = &((*reinterpret_cast< ior_t*>(
 
4165
      d_self)).d_bhypre_coefficientaccess);
 
4166
    bHYPRE_Operator_IORCache = &((*reinterpret_cast< ior_t*>(
 
4167
      d_self)).d_bhypre_operator);
 
4168
    bHYPRE_IJMatrixView_IORCache = &((*reinterpret_cast< ior_t*>(
 
4169
      d_self)).d_bhypre_ijmatrixview);
 
4170
    bHYPRE_ProblemDefinition_IORCache = &((*reinterpret_cast< ior_t*>(
 
4171
      d_self)).d_bhypre_problemdefinition);
 
4172
    bHYPRE_MatrixVectorView_IORCache = &((*reinterpret_cast< ior_t*>(
 
4173
      d_self)).d_bhypre_matrixvectorview);
 
4174
 
 
4175
  }
4030
4176
}
4031
4177
 
4032
4178
// exec has special argument passing to avoid #include circularities
4053
4199
 
4054
4200
{
4055
4201
  ::std::string _result;
4056
 
  ior_t* const loc_self = _get_ior();
 
4202
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
4203
    ::bHYPRE::IJParCSRMatrix::_get_ior();
4057
4204
  char * _local_result;
4058
4205
  sidl_BaseInterface__object * _exception;
4059
4206
  /*pack args to dispatch to ior*/
4060
4207
  _local_result = (*(loc_self->d_epv->f__getURL))(loc_self, &_exception );
4061
4208
  /*dispatch to ior*/
4062
4209
  if (_exception != 0 ) {
 
4210
 
4063
4211
    throwException0(_exception);
4064
4212
  }
4065
4213
  if (_local_result) {
4081
4229
 
4082
4230
{
4083
4231
 
4084
 
  ior_t* const loc_self = _get_ior();
 
4232
  ior_t* const loc_self = (struct bHYPRE_IJParCSRMatrix__object*) 
 
4233
    ::bHYPRE::IJParCSRMatrix::_get_ior();
4085
4234
  sidl_bool _local_on = on;
4086
4235
  sidl_BaseInterface__object * _exception;
4087
4236
  /*pack args to dispatch to ior*/
4088
 
  (*(loc_self->d_epv->f__set_hooks))(loc_self, /* in */ _local_on,
4089
 
    &_exception );
 
4237
  (*(loc_self->d_epv->f__set_hooks))(loc_self, /* in */ _local_on, &_exception 
 
4238
    );
4090
4239
  /*dispatch to ior*/
4091
4240
  if (_exception != 0 ) {
 
4241
 
4092
4242
    throwException0(_exception);
4093
4243
  }
4094
4244
  /*unpack results and cleanup*/
4111
4261
  ( _get_sepv()->f__set_hooks_static)( /* in */ _local_on, &_exception );
4112
4262
  /*dispatch to ior*/
4113
4263
  if (_exception != 0 ) {
 
4264
 
4114
4265
    throwException0(_exception);
4115
4266
  }
4116
4267
  /*unpack results and cleanup*/
4124
4275
 
4125
4276
  if(!connect_loaded) {
4126
4277
    struct sidl_BaseInterface__object *throwaway_exception;
4127
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.IJParCSRMatrix",
4128
 
      (void*)bHYPRE_IJParCSRMatrix__IHConnect, &throwaway_exception);
 
4278
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.IJParCSRMatrix", (
 
4279
      void*)bHYPRE_IJParCSRMatrix__IHConnect, &throwaway_exception);
4129
4280
    connect_loaded = 1;
4130
4281
  }
4131
4282
  if ( src != 0 ) {
4134
4285
    struct sidl_BaseInterface__object *throwaway_exception;
4135
4286
    struct sidl_BaseInterface__object * base = reinterpret_cast< struct 
4136
4287
      sidl_BaseInterface__object *>(tmp);
4137
 
    cast = reinterpret_cast< ior_t*>((*base->d_epv->f__cast)(base->d_object,
 
4288
    cast = reinterpret_cast< ior_t*>((*base->d_epv->f__cast)(base->d_object, 
4138
4289
      "bHYPRE.IJParCSRMatrix", &throwaway_exception));
4139
4290
  }
4140
4291
  return cast;
4152
4303
#ifdef SIDL_STATIC_LIBRARY
4153
4304
    s_ext = bHYPRE_IJParCSRMatrix__externals();
4154
4305
#else
4155
 
    s_ext = (struct 
4156
 
      bHYPRE_IJParCSRMatrix__external*)sidl_dynamicLoadIOR(
 
4306
    s_ext = (struct bHYPRE_IJParCSRMatrix__external*)sidl_dynamicLoadIOR(
4157
4307
      "bHYPRE.IJParCSRMatrix","bHYPRE_IJParCSRMatrix__externals") ;
4158
4308
#endif
4159
 
    sidl_checkIORVersion("bHYPRE.IJParCSRMatrix", s_ext->d_ior_major_version,
4160
 
      s_ext->d_ior_minor_version, 0, 10);
 
4309
    sidl_checkIORVersion("bHYPRE.IJParCSRMatrix", s_ext->d_ior_major_version, 
 
4310
      s_ext->d_ior_minor_version, 1, 0);
4161
4311
  }
4162
4312
  return s_ext;
4163
4313
}