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

« back to all changes in this revision

Viewing changes to src/babel/bHYPREClient-CX/bHYPRE_SStructMatrixView.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:
2
2
// File:          bHYPRE_SStructMatrixView.cxx
3
3
// Symbol:        bHYPRE.SStructMatrixView-v1.0.0
4
4
// Symbol Type:   interface
5
 
// Babel Version: 1.0.0
 
5
// Babel Version: 1.0.4
6
6
// Description:   Client-side glue code for bHYPRE.SStructMatrixView
7
7
// 
8
8
// WARNING: Automatically generated; changes will be lost
121
121
#endif
122
122
 
123
123
  // Static variables to hold version of IOR
124
 
  static const int32_t s_IOR_MAJOR_VERSION = 0;
125
 
  static const int32_t s_IOR_MINOR_VERSION = 10;
 
124
  static const int32_t s_IOR_MAJOR_VERSION = 1;
 
125
  static const int32_t s_IOR_MINOR_VERSION = 0;
126
126
 
127
127
  // Static variables for managing EPV initialization.
128
128
  static int s_remote_initialized = 0;
196
196
        cmp2 = strcmp(name, "bHYPRE._SStructMatrixView");
197
197
        if (!cmp2) {
198
198
          (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
199
 
          cast = self;
 
199
          cast = ((struct bHYPRE__SStructMatrixView__object*)self);
200
200
          return cast;
201
201
        }
202
202
      }
203
203
    }
204
204
    if ((*self->d_epv->f_isType)(self,name, _ex)) {
205
 
      void* (*func)(struct sidl_rmi_InstanceHandle__object*,
206
 
        struct sidl_BaseInterface__object**) = 
207
 
        (void* (*)(struct sidl_rmi_InstanceHandle__object*,
208
 
          struct sidl_BaseInterface__object**)) 
 
205
      void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct 
 
206
        sidl_BaseInterface__object**) = 
 
207
        (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct 
 
208
          sidl_BaseInterface__object**)) 
209
209
        sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
210
210
      cast =  (*func)(((struct 
211
211
        bHYPRE__SStructMatrixView__remote*)self->d_data)->d_ih, _ex);
248
248
    struct sidl_rmi_InstanceHandle__object *_conn = ((struct 
249
249
      bHYPRE__SStructMatrixView__remote*)self->d_data)->d_ih;
250
250
    sidl_rmi_Response _rsvp = NULL;
251
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
251
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
252
252
      "addRef", _ex ); SIDL_CHECK(*_ex);
253
253
    // send actual RMI request
254
254
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
353
353
 
354
354
      // pack in and inout arguments
355
355
      if(graph){
356
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)graph,
357
 
          _ex);SIDL_CHECK(*_ex);
358
 
        sidl_rmi_Invocation_packString( _inv, "graph", _url,
359
 
          _ex);SIDL_CHECK(*_ex);
 
356
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)graph, 
 
357
          _ex);SIDL_CHECK(*_ex);
 
358
        sidl_rmi_Invocation_packString( _inv, "graph", _url, _ex);SIDL_CHECK(
 
359
          *_ex);
360
360
        free((void*)_url);
361
361
      } else {
362
 
        sidl_rmi_Invocation_packString( _inv, "graph", NULL,
363
 
          _ex);SIDL_CHECK(*_ex);
 
362
        sidl_rmi_Invocation_packString( _inv, "graph", NULL, _ex);SIDL_CHECK(
 
363
          *_ex);
364
364
      }
365
365
 
366
366
      // send actual RMI request
376
376
      }
377
377
 
378
378
      // extract return value
379
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
380
 
        _ex);SIDL_CHECK(*_ex);
 
379
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
380
        *_ex);
381
381
 
382
382
      // unpack out and inout arguments
383
383
 
436
436
      }
437
437
 
438
438
      // extract return value
439
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
440
 
        _ex);SIDL_CHECK(*_ex);
 
439
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
440
        *_ex);
441
441
 
442
442
      // unpack out and inout arguments
443
443
 
499
499
      }
500
500
 
501
501
      // extract return value
502
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
503
 
        _ex);SIDL_CHECK(*_ex);
 
502
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
503
        *_ex);
504
504
 
505
505
      // unpack out and inout arguments
506
506
 
559
559
      }
560
560
 
561
561
      // extract return value
562
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
563
 
        _ex);SIDL_CHECK(*_ex);
 
562
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
563
        *_ex);
564
564
 
565
565
      // unpack out and inout arguments
566
566
 
622
622
      }
623
623
 
624
624
      // extract return value
625
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
626
 
        _ex);SIDL_CHECK(*_ex);
 
625
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
626
        *_ex);
627
627
 
628
628
      // unpack out and inout arguments
629
629
 
661
661
      // pack in and inout arguments
662
662
      sidl_rmi_Invocation_packInt( _inv, "part", part, _ex);SIDL_CHECK(*_ex);
663
663
      sidl_rmi_Invocation_packInt( _inv, "var", var, _ex);SIDL_CHECK(*_ex);
664
 
      sidl_rmi_Invocation_packInt( _inv, "to_var", to_var,
665
 
        _ex);SIDL_CHECK(*_ex);
666
 
      sidl_rmi_Invocation_packInt( _inv, "symmetric", symmetric,
 
664
      sidl_rmi_Invocation_packInt( _inv, "to_var", to_var, _ex);SIDL_CHECK(
 
665
        *_ex);
 
666
      sidl_rmi_Invocation_packInt( _inv, "symmetric", symmetric, 
667
667
        _ex);SIDL_CHECK(*_ex);
668
668
 
669
669
      // send actual RMI request
679
679
      }
680
680
 
681
681
      // extract return value
682
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
683
 
        _ex);SIDL_CHECK(*_ex);
 
682
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
683
        *_ex);
684
684
 
685
685
      // unpack out and inout arguments
686
686
 
713
713
        _conn, "SetNSSymmetric", _ex ); SIDL_CHECK(*_ex);
714
714
 
715
715
      // pack in and inout arguments
716
 
      sidl_rmi_Invocation_packInt( _inv, "symmetric", symmetric,
 
716
      sidl_rmi_Invocation_packInt( _inv, "symmetric", symmetric, 
717
717
        _ex);SIDL_CHECK(*_ex);
718
718
 
719
719
      // send actual RMI request
729
729
      }
730
730
 
731
731
      // extract return value
732
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
733
 
        _ex);SIDL_CHECK(*_ex);
 
732
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
733
        *_ex);
734
734
 
735
735
      // unpack out and inout arguments
736
736
 
776
776
      }
777
777
 
778
778
      // extract return value
779
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
780
 
        _ex);SIDL_CHECK(*_ex);
 
779
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
780
        *_ex);
781
781
 
782
782
      // unpack out and inout arguments
783
783
 
811
811
        _conn, "Print", _ex ); SIDL_CHECK(*_ex);
812
812
 
813
813
      // pack in and inout arguments
814
 
      sidl_rmi_Invocation_packString( _inv, "filename", filename,
 
814
      sidl_rmi_Invocation_packString( _inv, "filename", filename, 
815
815
        _ex);SIDL_CHECK(*_ex);
816
816
      sidl_rmi_Invocation_packInt( _inv, "all", all, _ex);SIDL_CHECK(*_ex);
817
817
 
828
828
      }
829
829
 
830
830
      // extract return value
831
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
832
 
        _ex);SIDL_CHECK(*_ex);
 
831
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
832
        *_ex);
833
833
 
834
834
      // unpack out and inout arguments
835
835
 
877
877
      }
878
878
 
879
879
      // extract return value
880
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
881
 
        _ex);SIDL_CHECK(*_ex);
 
880
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
881
        *_ex);
882
882
 
883
883
      // unpack out and inout arguments
884
884
      sidl_rmi_Response_unpackString( _rsvp, "A", &A_str, _ex);SIDL_CHECK(*_ex);
914
914
 
915
915
      // pack in and inout arguments
916
916
      if(mpi_comm){
917
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm,
918
 
          _ex);SIDL_CHECK(*_ex);
919
 
        sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url,
920
 
          _ex);SIDL_CHECK(*_ex);
 
917
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm, 
 
918
          _ex);SIDL_CHECK(*_ex);
 
919
        sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url, _ex);SIDL_CHECK(
 
920
          *_ex);
921
921
        free((void*)_url);
922
922
      } else {
923
 
        sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL,
924
 
          _ex);SIDL_CHECK(*_ex);
 
923
        sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL, _ex);SIDL_CHECK(
 
924
          *_ex);
925
925
      }
926
926
 
927
927
      // send actual RMI request
937
937
      }
938
938
 
939
939
      // extract return value
940
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
941
 
        _ex);SIDL_CHECK(*_ex);
 
940
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
941
        *_ex);
942
942
 
943
943
      // unpack out and inout arguments
944
944
 
1026
1026
      }
1027
1027
 
1028
1028
      // extract return value
1029
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1030
 
        _ex);SIDL_CHECK(*_ex);
 
1029
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1030
        *_ex);
1031
1031
 
1032
1032
      // unpack out and inout arguments
1033
1033
 
1073
1073
      }
1074
1074
 
1075
1075
      // extract return value
1076
 
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1077
 
        _ex);SIDL_CHECK(*_ex);
 
1076
      sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1077
        *_ex);
1078
1078
 
1079
1079
      // unpack out and inout arguments
1080
1080
 
1147
1147
 
1148
1148
      // pack in and inout arguments
1149
1149
      if(iobj){
1150
 
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,
1151
 
          _ex);SIDL_CHECK(*_ex);
1152
 
        sidl_rmi_Invocation_packString( _inv, "iobj", _url,
1153
 
          _ex);SIDL_CHECK(*_ex);
 
1150
        char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj, 
 
1151
          _ex);SIDL_CHECK(*_ex);
 
1152
        sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(
 
1153
          *_ex);
1154
1154
        free((void*)_url);
1155
1155
      } else {
1156
 
        sidl_rmi_Invocation_packString( _inv, "iobj", NULL,
1157
 
          _ex);SIDL_CHECK(*_ex);
 
1156
        sidl_rmi_Invocation_packString( _inv, "iobj", NULL, _ex);SIDL_CHECK(
 
1157
          *_ex);
1158
1158
      }
1159
1159
 
1160
1160
      // send actual RMI request
1170
1170
      }
1171
1171
 
1172
1172
      // extract return value
1173
 
      sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1174
 
        _ex);SIDL_CHECK(*_ex);
 
1173
      sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1174
        *_ex);
1175
1175
 
1176
1176
      // unpack out and inout arguments
1177
1177
 
1219
1219
      }
1220
1220
 
1221
1221
      // extract return value
1222
 
      sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1223
 
        _ex);SIDL_CHECK(*_ex);
 
1222
      sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1223
        *_ex);
1224
1224
 
1225
1225
      // unpack out and inout arguments
1226
1226
 
1267
1267
      }
1268
1268
 
1269
1269
      // extract return value
1270
 
      sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
1271
 
        _ex);SIDL_CHECK(*_ex);
1272
 
      _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,
1273
 
        _ex);SIDL_CHECK(*_ex);
 
1270
      sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
1271
        _ex);SIDL_CHECK(*_ex);
 
1272
      _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
1273
        *_ex);
1274
1274
 
1275
1275
      // unpack out and inout arguments
1276
1276
 
1332
1332
    epv->f_isType               = remote_bHYPRE__SStructMatrixView_isType;
1333
1333
    epv->f_getClassInfo         = remote_bHYPRE__SStructMatrixView_getClassInfo;
1334
1334
 
1335
 
    e0->f__cast           = (void* (*)(void*,const char*,
1336
 
      sidl_BaseInterface*)) epv->f__cast;
1337
 
    e0->f__delete         = (void (*)(void*,
1338
 
      sidl_BaseInterface*)) epv->f__delete;
1339
 
    e0->f__getURL         = (char* (*)(void*,
1340
 
      sidl_BaseInterface*)) epv->f__getURL;
1341
 
    e0->f__raddRef        = (void (*)(void*,
1342
 
      sidl_BaseInterface*)) epv->f__raddRef;
1343
 
    e0->f__isRemote       = (sidl_bool (*)(void*,
1344
 
      sidl_BaseInterface*)) epv->f__isRemote;
1345
 
    e0->f__set_hooks      = (void (*)(void*,int32_t,
1346
 
      sidl_BaseInterface*)) epv->f__set_hooks;
1347
 
    e0->f__exec           = (void (*)(void*,const char*,
1348
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
1349
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
1350
 
    e0->f_SetCommunicator = (int32_t (*)(void*,
1351
 
      struct bHYPRE_MPICommunicator__object*,
1352
 
      struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
1353
 
    e0->f_Destroy         = (void (*)(void*,
1354
 
      struct sidl_BaseInterface__object **)) epv->f_Destroy;
1355
 
    e0->f_Initialize      = (int32_t (*)(void*,
1356
 
      struct sidl_BaseInterface__object **)) epv->f_Initialize;
1357
 
    e0->f_Assemble        = (int32_t (*)(void*,
1358
 
      struct sidl_BaseInterface__object **)) epv->f_Assemble;
1359
 
    e0->f_addRef          = (void (*)(void*,
1360
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
1361
 
    e0->f_deleteRef       = (void (*)(void*,
1362
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1363
 
    e0->f_isSame          = (sidl_bool (*)(void*,
1364
 
      struct sidl_BaseInterface__object*,
1365
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
1366
 
    e0->f_isType          = (sidl_bool (*)(void*,const char*,
1367
 
      struct sidl_BaseInterface__object **)) epv->f_isType;
1368
 
    e0->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,
1369
 
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
1370
 
 
1371
 
    e1->f__cast           = (void* (*)(void*,const char*,
1372
 
      sidl_BaseInterface*)) epv->f__cast;
1373
 
    e1->f__delete         = (void (*)(void*,
1374
 
      sidl_BaseInterface*)) epv->f__delete;
1375
 
    e1->f__getURL         = (char* (*)(void*,
1376
 
      sidl_BaseInterface*)) epv->f__getURL;
1377
 
    e1->f__raddRef        = (void (*)(void*,
1378
 
      sidl_BaseInterface*)) epv->f__raddRef;
1379
 
    e1->f__isRemote       = (sidl_bool (*)(void*,
1380
 
      sidl_BaseInterface*)) epv->f__isRemote;
1381
 
    e1->f__set_hooks      = (void (*)(void*,int32_t,
1382
 
      sidl_BaseInterface*)) epv->f__set_hooks;
1383
 
    e1->f__exec           = (void (*)(void*,const char*,
1384
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
1385
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
1386
 
    e1->f_SetCommunicator = (int32_t (*)(void*,
1387
 
      struct bHYPRE_MPICommunicator__object*,
1388
 
      struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
1389
 
    e1->f_Destroy         = (void (*)(void*,
1390
 
      struct sidl_BaseInterface__object **)) epv->f_Destroy;
1391
 
    e1->f_Initialize      = (int32_t (*)(void*,
1392
 
      struct sidl_BaseInterface__object **)) epv->f_Initialize;
1393
 
    e1->f_Assemble        = (int32_t (*)(void*,
1394
 
      struct sidl_BaseInterface__object **)) epv->f_Assemble;
1395
 
    e1->f_addRef          = (void (*)(void*,
1396
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
1397
 
    e1->f_deleteRef       = (void (*)(void*,
1398
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1399
 
    e1->f_isSame          = (sidl_bool (*)(void*,
1400
 
      struct sidl_BaseInterface__object*,
1401
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
1402
 
    e1->f_isType          = (sidl_bool (*)(void*,const char*,
1403
 
      struct sidl_BaseInterface__object **)) epv->f_isType;
1404
 
    e1->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,
1405
 
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
1406
 
 
1407
 
    e2->f__cast           = (void* (*)(void*,const char*,
1408
 
      sidl_BaseInterface*)) epv->f__cast;
1409
 
    e2->f__delete         = (void (*)(void*,
1410
 
      sidl_BaseInterface*)) epv->f__delete;
1411
 
    e2->f__getURL         = (char* (*)(void*,
1412
 
      sidl_BaseInterface*)) epv->f__getURL;
1413
 
    e2->f__raddRef        = (void (*)(void*,
1414
 
      sidl_BaseInterface*)) epv->f__raddRef;
1415
 
    e2->f__isRemote       = (sidl_bool (*)(void*,
1416
 
      sidl_BaseInterface*)) epv->f__isRemote;
1417
 
    e2->f__set_hooks      = (void (*)(void*,int32_t,
1418
 
      sidl_BaseInterface*)) epv->f__set_hooks;
1419
 
    e2->f__exec           = (void (*)(void*,const char*,
1420
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
1421
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
1422
 
    e2->f_GetObject       = (int32_t (*)(void*,
1423
 
      struct sidl_BaseInterface__object**,
1424
 
      struct sidl_BaseInterface__object **)) epv->f_GetObject;
1425
 
    e2->f_SetCommunicator = (int32_t (*)(void*,
1426
 
      struct bHYPRE_MPICommunicator__object*,
1427
 
      struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
1428
 
    e2->f_Destroy         = (void (*)(void*,
1429
 
      struct sidl_BaseInterface__object **)) epv->f_Destroy;
1430
 
    e2->f_Initialize      = (int32_t (*)(void*,
1431
 
      struct sidl_BaseInterface__object **)) epv->f_Initialize;
1432
 
    e2->f_Assemble        = (int32_t (*)(void*,
1433
 
      struct sidl_BaseInterface__object **)) epv->f_Assemble;
1434
 
    e2->f_addRef          = (void (*)(void*,
1435
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
1436
 
    e2->f_deleteRef       = (void (*)(void*,
1437
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1438
 
    e2->f_isSame          = (sidl_bool (*)(void*,
1439
 
      struct sidl_BaseInterface__object*,
1440
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
1441
 
    e2->f_isType          = (sidl_bool (*)(void*,const char*,
1442
 
      struct sidl_BaseInterface__object **)) epv->f_isType;
1443
 
    e2->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,
1444
 
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
1445
 
 
1446
 
    e3->f__cast           = (void* (*)(void*,const char*,
1447
 
      sidl_BaseInterface*)) epv->f__cast;
1448
 
    e3->f__delete         = (void (*)(void*,
1449
 
      sidl_BaseInterface*)) epv->f__delete;
1450
 
    e3->f__getURL         = (char* (*)(void*,
1451
 
      sidl_BaseInterface*)) epv->f__getURL;
1452
 
    e3->f__raddRef        = (void (*)(void*,
1453
 
      sidl_BaseInterface*)) epv->f__raddRef;
1454
 
    e3->f__isRemote       = (sidl_bool (*)(void*,
1455
 
      sidl_BaseInterface*)) epv->f__isRemote;
1456
 
    e3->f__set_hooks      = (void (*)(void*,int32_t,
1457
 
      sidl_BaseInterface*)) epv->f__set_hooks;
1458
 
    e3->f__exec           = (void (*)(void*,const char*,
1459
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
1460
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
1461
 
    e3->f_SetGraph        = (int32_t (*)(void*,
1462
 
      struct bHYPRE_SStructGraph__object*,
1463
 
      struct sidl_BaseInterface__object **)) epv->f_SetGraph;
 
1335
    e0->f__cast           = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
1336
      epv->f__cast;
 
1337
    e0->f__delete         = (void (*)(void*,sidl_BaseInterface*)) 
 
1338
      epv->f__delete;
 
1339
    e0->f__getURL         = (char* (*)(void*,sidl_BaseInterface*)) 
 
1340
      epv->f__getURL;
 
1341
    e0->f__raddRef        = (void (*)(void*,sidl_BaseInterface*)) 
 
1342
      epv->f__raddRef;
 
1343
    e0->f__isRemote       = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
1344
      epv->f__isRemote;
 
1345
    e0->f__set_hooks      = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
1346
      epv->f__set_hooks;
 
1347
    e0->f__exec           = (void (*)(void*,const char*,struct 
 
1348
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
1349
      sidl_BaseInterface__object **)) epv->f__exec;
 
1350
    e0->f_SetCommunicator = (int32_t (*)(void*,struct 
 
1351
      bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
1352
      epv->f_SetCommunicator;
 
1353
    e0->f_Destroy         = (void (*)(void*,struct sidl_BaseInterface__object 
 
1354
      **)) epv->f_Destroy;
 
1355
    e0->f_Initialize      = (int32_t (*)(void*,struct 
 
1356
      sidl_BaseInterface__object **)) epv->f_Initialize;
 
1357
    e0->f_Assemble        = (int32_t (*)(void*,struct 
 
1358
      sidl_BaseInterface__object **)) epv->f_Assemble;
 
1359
    e0->f_addRef          = (void (*)(void*,struct sidl_BaseInterface__object 
 
1360
      **)) epv->f_addRef;
 
1361
    e0->f_deleteRef       = (void (*)(void*,struct sidl_BaseInterface__object 
 
1362
      **)) epv->f_deleteRef;
 
1363
    e0->f_isSame          = (sidl_bool (*)(void*,struct 
 
1364
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
1365
      epv->f_isSame;
 
1366
    e0->f_isType          = (sidl_bool (*)(void*,const char*,struct 
 
1367
      sidl_BaseInterface__object **)) epv->f_isType;
 
1368
    e0->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
1369
      sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1370
 
 
1371
    e1->f__cast           = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
1372
      epv->f__cast;
 
1373
    e1->f__delete         = (void (*)(void*,sidl_BaseInterface*)) 
 
1374
      epv->f__delete;
 
1375
    e1->f__getURL         = (char* (*)(void*,sidl_BaseInterface*)) 
 
1376
      epv->f__getURL;
 
1377
    e1->f__raddRef        = (void (*)(void*,sidl_BaseInterface*)) 
 
1378
      epv->f__raddRef;
 
1379
    e1->f__isRemote       = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
1380
      epv->f__isRemote;
 
1381
    e1->f__set_hooks      = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
1382
      epv->f__set_hooks;
 
1383
    e1->f__exec           = (void (*)(void*,const char*,struct 
 
1384
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
1385
      sidl_BaseInterface__object **)) epv->f__exec;
 
1386
    e1->f_SetCommunicator = (int32_t (*)(void*,struct 
 
1387
      bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
1388
      epv->f_SetCommunicator;
 
1389
    e1->f_Destroy         = (void (*)(void*,struct sidl_BaseInterface__object 
 
1390
      **)) epv->f_Destroy;
 
1391
    e1->f_Initialize      = (int32_t (*)(void*,struct 
 
1392
      sidl_BaseInterface__object **)) epv->f_Initialize;
 
1393
    e1->f_Assemble        = (int32_t (*)(void*,struct 
 
1394
      sidl_BaseInterface__object **)) epv->f_Assemble;
 
1395
    e1->f_addRef          = (void (*)(void*,struct sidl_BaseInterface__object 
 
1396
      **)) epv->f_addRef;
 
1397
    e1->f_deleteRef       = (void (*)(void*,struct sidl_BaseInterface__object 
 
1398
      **)) epv->f_deleteRef;
 
1399
    e1->f_isSame          = (sidl_bool (*)(void*,struct 
 
1400
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
1401
      epv->f_isSame;
 
1402
    e1->f_isType          = (sidl_bool (*)(void*,const char*,struct 
 
1403
      sidl_BaseInterface__object **)) epv->f_isType;
 
1404
    e1->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
1405
      sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1406
 
 
1407
    e2->f__cast           = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
1408
      epv->f__cast;
 
1409
    e2->f__delete         = (void (*)(void*,sidl_BaseInterface*)) 
 
1410
      epv->f__delete;
 
1411
    e2->f__getURL         = (char* (*)(void*,sidl_BaseInterface*)) 
 
1412
      epv->f__getURL;
 
1413
    e2->f__raddRef        = (void (*)(void*,sidl_BaseInterface*)) 
 
1414
      epv->f__raddRef;
 
1415
    e2->f__isRemote       = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
1416
      epv->f__isRemote;
 
1417
    e2->f__set_hooks      = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
1418
      epv->f__set_hooks;
 
1419
    e2->f__exec           = (void (*)(void*,const char*,struct 
 
1420
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
1421
      sidl_BaseInterface__object **)) epv->f__exec;
 
1422
    e2->f_GetObject       = (int32_t (*)(void*,struct 
 
1423
      sidl_BaseInterface__object**,struct sidl_BaseInterface__object **)) 
 
1424
      epv->f_GetObject;
 
1425
    e2->f_SetCommunicator = (int32_t (*)(void*,struct 
 
1426
      bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
1427
      epv->f_SetCommunicator;
 
1428
    e2->f_Destroy         = (void (*)(void*,struct sidl_BaseInterface__object 
 
1429
      **)) epv->f_Destroy;
 
1430
    e2->f_Initialize      = (int32_t (*)(void*,struct 
 
1431
      sidl_BaseInterface__object **)) epv->f_Initialize;
 
1432
    e2->f_Assemble        = (int32_t (*)(void*,struct 
 
1433
      sidl_BaseInterface__object **)) epv->f_Assemble;
 
1434
    e2->f_addRef          = (void (*)(void*,struct sidl_BaseInterface__object 
 
1435
      **)) epv->f_addRef;
 
1436
    e2->f_deleteRef       = (void (*)(void*,struct sidl_BaseInterface__object 
 
1437
      **)) epv->f_deleteRef;
 
1438
    e2->f_isSame          = (sidl_bool (*)(void*,struct 
 
1439
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
1440
      epv->f_isSame;
 
1441
    e2->f_isType          = (sidl_bool (*)(void*,const char*,struct 
 
1442
      sidl_BaseInterface__object **)) epv->f_isType;
 
1443
    e2->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
1444
      sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1445
 
 
1446
    e3->f__cast           = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
1447
      epv->f__cast;
 
1448
    e3->f__delete         = (void (*)(void*,sidl_BaseInterface*)) 
 
1449
      epv->f__delete;
 
1450
    e3->f__getURL         = (char* (*)(void*,sidl_BaseInterface*)) 
 
1451
      epv->f__getURL;
 
1452
    e3->f__raddRef        = (void (*)(void*,sidl_BaseInterface*)) 
 
1453
      epv->f__raddRef;
 
1454
    e3->f__isRemote       = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
1455
      epv->f__isRemote;
 
1456
    e3->f__set_hooks      = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
1457
      epv->f__set_hooks;
 
1458
    e3->f__exec           = (void (*)(void*,const char*,struct 
 
1459
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
1460
      sidl_BaseInterface__object **)) epv->f__exec;
 
1461
    e3->f_SetGraph        = (int32_t (*)(void*,struct 
 
1462
      bHYPRE_SStructGraph__object*,struct sidl_BaseInterface__object **)) 
 
1463
      epv->f_SetGraph;
1464
1464
    e3->f_SetValues       = (int32_t (*)(void*,int32_t,struct sidl_int__array*,
1465
 
      int32_t,struct sidl_int__array*,struct sidl_double__array*,
1466
 
      struct sidl_BaseInterface__object **)) epv->f_SetValues;
 
1465
      int32_t,struct sidl_int__array*,struct sidl_double__array*,struct 
 
1466
      sidl_BaseInterface__object **)) epv->f_SetValues;
1467
1467
    e3->f_SetBoxValues    = (int32_t (*)(void*,int32_t,struct sidl_int__array*,
1468
 
      struct sidl_int__array*,int32_t,struct sidl_int__array*,
1469
 
      struct sidl_double__array*,
1470
 
      struct sidl_BaseInterface__object **)) epv->f_SetBoxValues;
 
1468
      struct sidl_int__array*,int32_t,struct sidl_int__array*,struct 
 
1469
      sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
1470
      epv->f_SetBoxValues;
1471
1471
    e3->f_AddToValues     = (int32_t (*)(void*,int32_t,struct sidl_int__array*,
1472
 
      int32_t,struct sidl_int__array*,struct sidl_double__array*,
1473
 
      struct sidl_BaseInterface__object **)) epv->f_AddToValues;
 
1472
      int32_t,struct sidl_int__array*,struct sidl_double__array*,struct 
 
1473
      sidl_BaseInterface__object **)) epv->f_AddToValues;
1474
1474
    e3->f_AddToBoxValues  = (int32_t (*)(void*,int32_t,struct sidl_int__array*,
1475
 
      struct sidl_int__array*,int32_t,struct sidl_int__array*,
1476
 
      struct sidl_double__array*,
1477
 
      struct sidl_BaseInterface__object **)) epv->f_AddToBoxValues;
 
1475
      struct sidl_int__array*,int32_t,struct sidl_int__array*,struct 
 
1476
      sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
1477
      epv->f_AddToBoxValues;
1478
1478
    e3->f_SetSymmetric    = (int32_t (*)(void*,int32_t,int32_t,int32_t,int32_t,
1479
1479
      struct sidl_BaseInterface__object **)) epv->f_SetSymmetric;
1480
 
    e3->f_SetNSSymmetric  = (int32_t (*)(void*,int32_t,
1481
 
      struct sidl_BaseInterface__object **)) epv->f_SetNSSymmetric;
1482
 
    e3->f_SetComplex      = (int32_t (*)(void*,
1483
 
      struct sidl_BaseInterface__object **)) epv->f_SetComplex;
1484
 
    e3->f_Print           = (int32_t (*)(void*,const char*,int32_t,
1485
 
      struct sidl_BaseInterface__object **)) epv->f_Print;
1486
 
    e3->f_GetObject       = (int32_t (*)(void*,
1487
 
      struct sidl_BaseInterface__object**,
1488
 
      struct sidl_BaseInterface__object **)) epv->f_GetObject;
1489
 
    e3->f_SetCommunicator = (int32_t (*)(void*,
1490
 
      struct bHYPRE_MPICommunicator__object*,
1491
 
      struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
1492
 
    e3->f_Destroy         = (void (*)(void*,
1493
 
      struct sidl_BaseInterface__object **)) epv->f_Destroy;
1494
 
    e3->f_Initialize      = (int32_t (*)(void*,
1495
 
      struct sidl_BaseInterface__object **)) epv->f_Initialize;
1496
 
    e3->f_Assemble        = (int32_t (*)(void*,
1497
 
      struct sidl_BaseInterface__object **)) epv->f_Assemble;
1498
 
    e3->f_addRef          = (void (*)(void*,
1499
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
1500
 
    e3->f_deleteRef       = (void (*)(void*,
1501
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1502
 
    e3->f_isSame          = (sidl_bool (*)(void*,
1503
 
      struct sidl_BaseInterface__object*,
1504
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
1505
 
    e3->f_isType          = (sidl_bool (*)(void*,const char*,
1506
 
      struct sidl_BaseInterface__object **)) epv->f_isType;
1507
 
    e3->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,
1508
 
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1480
    e3->f_SetNSSymmetric  = (int32_t (*)(void*,int32_t,struct 
 
1481
      sidl_BaseInterface__object **)) epv->f_SetNSSymmetric;
 
1482
    e3->f_SetComplex      = (int32_t (*)(void*,struct 
 
1483
      sidl_BaseInterface__object **)) epv->f_SetComplex;
 
1484
    e3->f_Print           = (int32_t (*)(void*,const char*,int32_t,struct 
 
1485
      sidl_BaseInterface__object **)) epv->f_Print;
 
1486
    e3->f_GetObject       = (int32_t (*)(void*,struct 
 
1487
      sidl_BaseInterface__object**,struct sidl_BaseInterface__object **)) 
 
1488
      epv->f_GetObject;
 
1489
    e3->f_SetCommunicator = (int32_t (*)(void*,struct 
 
1490
      bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
1491
      epv->f_SetCommunicator;
 
1492
    e3->f_Destroy         = (void (*)(void*,struct sidl_BaseInterface__object 
 
1493
      **)) epv->f_Destroy;
 
1494
    e3->f_Initialize      = (int32_t (*)(void*,struct 
 
1495
      sidl_BaseInterface__object **)) epv->f_Initialize;
 
1496
    e3->f_Assemble        = (int32_t (*)(void*,struct 
 
1497
      sidl_BaseInterface__object **)) epv->f_Assemble;
 
1498
    e3->f_addRef          = (void (*)(void*,struct sidl_BaseInterface__object 
 
1499
      **)) epv->f_addRef;
 
1500
    e3->f_deleteRef       = (void (*)(void*,struct sidl_BaseInterface__object 
 
1501
      **)) epv->f_deleteRef;
 
1502
    e3->f_isSame          = (sidl_bool (*)(void*,struct 
 
1503
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
1504
      epv->f_isSame;
 
1505
    e3->f_isType          = (sidl_bool (*)(void*,const char*,struct 
 
1506
      sidl_BaseInterface__object **)) epv->f_isType;
 
1507
    e3->f_getClassInfo    = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
1508
      sidl_BaseInterface__object **)) epv->f_getClassInfo;
1509
1509
 
1510
 
    e4->f__cast        = (void* (*)(void*,const char*,
1511
 
      sidl_BaseInterface*)) epv->f__cast;
 
1510
    e4->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
1511
      epv->f__cast;
1512
1512
    e4->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
1513
1513
    e4->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
1514
1514
    e4->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
1515
 
    e4->f__isRemote    = (sidl_bool (*)(void*,
1516
 
      sidl_BaseInterface*)) epv->f__isRemote;
1517
 
    e4->f__set_hooks   = (void (*)(void*,int32_t,
1518
 
      sidl_BaseInterface*)) epv->f__set_hooks;
1519
 
    e4->f__exec        = (void (*)(void*,const char*,
1520
 
      struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
1521
 
      struct sidl_BaseInterface__object **)) epv->f__exec;
1522
 
    e4->f_addRef       = (void (*)(void*,
1523
 
      struct sidl_BaseInterface__object **)) epv->f_addRef;
1524
 
    e4->f_deleteRef    = (void (*)(void*,
1525
 
      struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1526
 
    e4->f_isSame       = (sidl_bool (*)(void*,
1527
 
      struct sidl_BaseInterface__object*,
1528
 
      struct sidl_BaseInterface__object **)) epv->f_isSame;
1529
 
    e4->f_isType       = (sidl_bool (*)(void*,const char*,
1530
 
      struct sidl_BaseInterface__object **)) epv->f_isType;
1531
 
    e4->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
1532
 
      struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1515
    e4->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
1516
      epv->f__isRemote;
 
1517
    e4->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
1518
      epv->f__set_hooks;
 
1519
    e4->f__exec        = (void (*)(void*,const char*,struct 
 
1520
      sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
1521
      sidl_BaseInterface__object **)) epv->f__exec;
 
1522
    e4->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
1523
      epv->f_addRef;
 
1524
    e4->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
1525
      epv->f_deleteRef;
 
1526
    e4->f_isSame       = (sidl_bool (*)(void*,struct 
 
1527
      sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
1528
      epv->f_isSame;
 
1529
    e4->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
1530
      sidl_BaseInterface__object **)) epv->f_isType;
 
1531
    e4->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
1532
      sidl_BaseInterface__object **)) epv->f_getClassInfo;
1533
1533
 
1534
1534
    s_remote_initialized = 1;
1535
1535
  }
1536
1536
 
1537
1537
  // Create an instance that connects to an existing remote object.
1538
1538
  static struct bHYPRE_SStructMatrixView__object*
1539
 
  bHYPRE_SStructMatrixView__remoteConnect(const char *url, sidl_bool ar,
 
1539
  bHYPRE_SStructMatrixView__remoteConnect(const char *url, sidl_bool ar, 
1540
1540
    sidl_BaseInterface *_ex)
1541
1541
  {
1542
1542
    struct bHYPRE__SStructMatrixView__object* self;
1548
1548
    char* objectID = NULL;
1549
1549
    objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
1550
1550
    if(objectID) {
1551
 
      sidl_BaseInterface bi = 
1552
 
        (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
 
1551
      sidl_BaseInterface bi = (
 
1552
        sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
1553
1553
        objectID, _ex);
1554
1554
      if(ar) {
1555
1555
        sidl_BaseInterface_addRef(bi, _ex);
1605
1605
  // Create an instance that uses an already existing 
1606
1606
  // InstanceHandel to connect to an existing remote object.
1607
1607
  static struct bHYPRE_SStructMatrixView__object*
1608
 
  bHYPRE_SStructMatrixView__IHConnect(sidl_rmi_InstanceHandle instance,
 
1608
  bHYPRE_SStructMatrixView__IHConnect(sidl_rmi_InstanceHandle instance, 
1609
1609
    sidl_BaseInterface *_ex)
1610
1610
  {
1611
1611
    struct bHYPRE__SStructMatrixView__object* self;
1670
1670
 
1671
1671
    *_ex = NULL;
1672
1672
    if(!connect_loaded) {
1673
 
      sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructMatrixView",
1674
 
        (void*)bHYPRE_SStructMatrixView__IHConnect, _ex);
 
1673
      sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructMatrixView", (
 
1674
        void*)bHYPRE_SStructMatrixView__IHConnect, _ex);
1675
1675
      connect_loaded = 1;
1676
1676
    }
1677
1677
    if (obj != NULL) {
1691
1691
  // RMI connector function for the class.
1692
1692
  // 
1693
1693
  struct bHYPRE_SStructMatrixView__object*
1694
 
  bHYPRE_SStructMatrixView__connectI(const char* url, sidl_bool ar,
1695
 
    struct sidl_BaseInterface__object **_ex)
 
1694
  bHYPRE_SStructMatrixView__connectI(const char* url, sidl_bool ar, struct 
 
1695
    sidl_BaseInterface__object **_ex)
1696
1696
  {
1697
1697
    return bHYPRE_SStructMatrixView__remoteConnect(url, ar, _ex);
1698
1698
  }
1713
1713
  void * _p = 0;
1714
1714
  struct sidl_BaseInterface__object *throwaway_exception;
1715
1715
 
1716
 
  if ( (_p=(*(_exception->d_epv->f__cast))(_exception->d_object,
 
1716
  if ( (_p=(*(_exception->d_epv->f__cast))(_exception->d_object, 
1717
1717
    "sidl.RuntimeException", &throwaway_exception)) != 0 ) {
1718
1718
    struct sidl_RuntimeException__object * _realtype = reinterpret_cast< struct 
1719
1719
      sidl_RuntimeException__object*>(_p);
1720
 
    (*_exception->d_epv->f_deleteRef)(_exception->d_object,
 
1720
    (*_exception->d_epv->f_deleteRef)(_exception->d_object, 
1721
1721
      &throwaway_exception);
1722
1722
    // Note: alternate constructor does not increment refcount.
1723
1723
    ::sidl::RuntimeException _resolved_exception = ::sidl::RuntimeException( 
1748
1748
 
1749
1749
{
1750
1750
  int32_t _result;
1751
 
  ior_t* const loc_self = (ior_t*) 
1752
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
1753
 
  struct bHYPRE_SStructGraph__object* _local_graph = graph._get_ior();
1754
 
  sidl_BaseInterface__object * _exception;
1755
 
  /*pack args to dispatch to ior*/
1756
 
  _result = (*(loc_self->d_epv->f_SetGraph))(loc_self->d_object,
1757
 
    /* in */ _local_graph, &_exception );
1758
 
  /*dispatch to ior*/
1759
 
  if (_exception != 0 ) {
1760
 
    throwException0(_exception);
1761
 
  }
1762
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
1763
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
1764
 
  }/*unpack results and cleanup*/
1765
 
  return _result;
1766
 
}
1767
 
 
1768
 
 
1769
 
 
1770
 
/**
1771
 
 * Set matrix coefficients index by index.
1772
 
 * 
1773
 
 * NOTE: Users are required to set values on all processes that
1774
 
 * own the associated variables.  This means that some data will
1775
 
 * be multiply defined.
1776
 
 * 
1777
 
 * NOTE: The entries in this routine must all be of the same
1778
 
 * type: either stencil or non-stencil, but not both.  Also, if
1779
 
 * they are stencil entries, they must all represent couplings
1780
 
 * to the same variable type (there are no such restrictions for
1781
 
 * non-stencil entries).
1782
 
 * 
1783
 
 * If the matrix is complex, then {\tt values} consists of pairs
1784
 
 * of doubles representing the real and imaginary parts of each
1785
 
 * complex value.
1786
 
 */
1787
 
int32_t
1788
 
bHYPRE::SStructMatrixView::SetValues( /* in */int32_t part,
1789
 
  /* in rarray[dim] */int32_t* index, /* in */int32_t dim, /* in */int32_t var,
1790
 
  /* in */int32_t nentries, /* in rarray[nentries] */int32_t* entries,
1791
 
  /* in rarray[nentries] */double* values )
1792
 
 
1793
 
{
1794
 
  int32_t _result;
1795
 
  ior_t* const loc_self = (ior_t*) 
1796
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
1797
 
  int32_t index_lower[1], index_upper[1], index_stride[1];
1798
 
  struct sidl_int__array index_real;
1799
 
  struct sidl_int__array *index_tmp = &index_real;
1800
 
  index_upper[0] = dim-1;
1801
 
  sidl_int__array_init(index, index_tmp, 1, index_lower, index_upper,
1802
 
    index_stride);
1803
 
  int32_t entries_lower[1], entries_upper[1], entries_stride[1];
1804
 
  struct sidl_int__array entries_real;
1805
 
  struct sidl_int__array *entries_tmp = &entries_real;
1806
 
  entries_upper[0] = nentries-1;
1807
 
  sidl_int__array_init(entries, entries_tmp, 1, entries_lower, entries_upper,
1808
 
    entries_stride);
1809
 
  int32_t values_lower[1], values_upper[1], values_stride[1];
1810
 
  struct sidl_double__array values_real;
1811
 
  struct sidl_double__array *values_tmp = &values_real;
1812
 
  values_upper[0] = nentries-1;
1813
 
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper,
1814
 
    values_stride);
1815
 
  sidl_BaseInterface__object * _exception;
1816
 
  /*pack args to dispatch to ior*/
1817
 
  _result = (*(loc_self->d_epv->f_SetValues))(loc_self->d_object, /* in */ part,
1818
 
    /* in rarray[dim] */ index_tmp, /* in */ var,
1819
 
    /* in rarray[nentries] */ entries_tmp, /* in rarray[nentries] */ values_tmp,
1820
 
    &_exception );
1821
 
  /*dispatch to ior*/
1822
 
  if (_exception != 0 ) {
1823
 
    throwException0(_exception);
1824
 
  }
1825
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
1826
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
1827
 
  }/*unpack results and cleanup*/
1828
 
  return _result;
1829
 
}
1830
 
 
1831
 
 
1832
 
 
1833
 
/**
1834
 
 * Set matrix coefficients index by index.
1835
 
 * 
1836
 
 * NOTE: Users are required to set values on all processes that
1837
 
 * own the associated variables.  This means that some data will
1838
 
 * be multiply defined.
1839
 
 * 
1840
 
 * NOTE: The entries in this routine must all be of the same
1841
 
 * type: either stencil or non-stencil, but not both.  Also, if
1842
 
 * they are stencil entries, they must all represent couplings
1843
 
 * to the same variable type (there are no such restrictions for
1844
 
 * non-stencil entries).
1845
 
 * 
1846
 
 * If the matrix is complex, then {\tt values} consists of pairs
1847
 
 * of doubles representing the real and imaginary parts of each
1848
 
 * complex value.
1849
 
 */
1850
 
int32_t
1851
 
bHYPRE::SStructMatrixView::SetValues( /* in */int32_t part,
1852
 
  /* in rarray[dim] */::sidl::array<int32_t> index, /* in */int32_t var,
1853
 
  /* in rarray[nentries] */::sidl::array<int32_t> entries,
1854
 
  /* in rarray[nentries] */::sidl::array<double> values )
1855
 
 
1856
 
{
1857
 
  int32_t _result;
1858
 
  ior_t* const loc_self = (ior_t*) 
1859
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
1860
 
  sidl_BaseInterface__object * _exception;
1861
 
  /*pack args to dispatch to ior*/
1862
 
  _result = (*(loc_self->d_epv->f_SetValues))(loc_self->d_object, /* in */ part,
1863
 
    /* in rarray[dim] */ index._get_ior(), /* in */ var,
1864
 
    /* in rarray[nentries] */ entries._get_ior(),
1865
 
    /* in rarray[nentries] */ values._get_ior(), &_exception );
1866
 
  /*dispatch to ior*/
1867
 
  if (_exception != 0 ) {
1868
 
    throwException0(_exception);
1869
 
  }
1870
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
1871
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
1872
 
  }/*unpack results and cleanup*/
1873
 
  return _result;
1874
 
}
1875
 
 
1876
 
 
1877
 
 
1878
 
/**
1879
 
 * Set matrix coefficients a box at a time.
1880
 
 * 
1881
 
 * NOTE: Users are required to set values on all processes that
1882
 
 * own the associated variables.  This means that some data will
1883
 
 * be multiply defined.
1884
 
 * 
1885
 
 * NOTE: The entries in this routine must all be of the same
1886
 
 * type: either stencil or non-stencil, but not both.  Also, if
1887
 
 * they are stencil entries, they must all represent couplings
1888
 
 * to the same variable type (there are no such restrictions for
1889
 
 * non-stencil entries).
1890
 
 * 
1891
 
 * If the matrix is complex, then {\tt values} consists of pairs
1892
 
 * of doubles representing the real and imaginary parts of each
1893
 
 * complex value.
1894
 
 */
1895
 
int32_t
1896
 
bHYPRE::SStructMatrixView::SetBoxValues( /* in */int32_t part,
1897
 
  /* in rarray[dim] */int32_t* ilower, /* in rarray[dim] */int32_t* iupper,
1898
 
  /* in */int32_t dim, /* in */int32_t var, /* in */int32_t nentries,
1899
 
  /* in rarray[nentries] */int32_t* entries,
1900
 
  /* in rarray[nvalues] */double* values, /* in */int32_t nvalues )
1901
 
 
1902
 
{
1903
 
  int32_t _result;
1904
 
  ior_t* const loc_self = (ior_t*) 
1905
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
1906
 
  int32_t ilower_lower[1], ilower_upper[1], ilower_stride[1];
1907
 
  struct sidl_int__array ilower_real;
1908
 
  struct sidl_int__array *ilower_tmp = &ilower_real;
1909
 
  ilower_upper[0] = dim-1;
1910
 
  sidl_int__array_init(ilower, ilower_tmp, 1, ilower_lower, ilower_upper,
1911
 
    ilower_stride);
1912
 
  int32_t iupper_lower[1], iupper_upper[1], iupper_stride[1];
1913
 
  struct sidl_int__array iupper_real;
1914
 
  struct sidl_int__array *iupper_tmp = &iupper_real;
1915
 
  iupper_upper[0] = dim-1;
1916
 
  sidl_int__array_init(iupper, iupper_tmp, 1, iupper_lower, iupper_upper,
1917
 
    iupper_stride);
1918
 
  int32_t entries_lower[1], entries_upper[1], entries_stride[1];
1919
 
  struct sidl_int__array entries_real;
1920
 
  struct sidl_int__array *entries_tmp = &entries_real;
1921
 
  entries_upper[0] = nentries-1;
1922
 
  sidl_int__array_init(entries, entries_tmp, 1, entries_lower, entries_upper,
1923
 
    entries_stride);
1924
 
  int32_t values_lower[1], values_upper[1], values_stride[1];
1925
 
  struct sidl_double__array values_real;
1926
 
  struct sidl_double__array *values_tmp = &values_real;
1927
 
  values_upper[0] = nvalues-1;
1928
 
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper,
1929
 
    values_stride);
1930
 
  sidl_BaseInterface__object * _exception;
1931
 
  /*pack args to dispatch to ior*/
1932
 
  _result = (*(loc_self->d_epv->f_SetBoxValues))(loc_self->d_object,
1933
 
    /* in */ part, /* in rarray[dim] */ ilower_tmp,
1934
 
    /* in rarray[dim] */ iupper_tmp, /* in */ var,
1935
 
    /* in rarray[nentries] */ entries_tmp, /* in rarray[nvalues] */ values_tmp,
1936
 
    &_exception );
1937
 
  /*dispatch to ior*/
1938
 
  if (_exception != 0 ) {
1939
 
    throwException0(_exception);
1940
 
  }
1941
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
1942
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
1943
 
  }/*unpack results and cleanup*/
1944
 
  return _result;
1945
 
}
1946
 
 
1947
 
 
1948
 
 
1949
 
/**
1950
 
 * Set matrix coefficients a box at a time.
1951
 
 * 
1952
 
 * NOTE: Users are required to set values on all processes that
1953
 
 * own the associated variables.  This means that some data will
1954
 
 * be multiply defined.
1955
 
 * 
1956
 
 * NOTE: The entries in this routine must all be of the same
1957
 
 * type: either stencil or non-stencil, but not both.  Also, if
1958
 
 * they are stencil entries, they must all represent couplings
1959
 
 * to the same variable type (there are no such restrictions for
1960
 
 * non-stencil entries).
1961
 
 * 
1962
 
 * If the matrix is complex, then {\tt values} consists of pairs
1963
 
 * of doubles representing the real and imaginary parts of each
1964
 
 * complex value.
1965
 
 */
1966
 
int32_t
1967
 
bHYPRE::SStructMatrixView::SetBoxValues( /* in */int32_t part,
1968
 
  /* in rarray[dim] */::sidl::array<int32_t> ilower,
1969
 
  /* in rarray[dim] */::sidl::array<int32_t> iupper, /* in */int32_t var,
1970
 
  /* in rarray[nentries] */::sidl::array<int32_t> entries,
1971
 
  /* in rarray[nvalues] */::sidl::array<double> values )
1972
 
 
1973
 
{
1974
 
  int32_t _result;
1975
 
  ior_t* const loc_self = (ior_t*) 
1976
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
1977
 
  sidl_BaseInterface__object * _exception;
1978
 
  /*pack args to dispatch to ior*/
1979
 
  _result = (*(loc_self->d_epv->f_SetBoxValues))(loc_self->d_object,
1980
 
    /* in */ part, /* in rarray[dim] */ ilower._get_ior(),
1981
 
    /* in rarray[dim] */ iupper._get_ior(), /* in */ var,
1982
 
    /* in rarray[nentries] */ entries._get_ior(),
1983
 
    /* in rarray[nvalues] */ values._get_ior(), &_exception );
1984
 
  /*dispatch to ior*/
1985
 
  if (_exception != 0 ) {
1986
 
    throwException0(_exception);
1987
 
  }
1988
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
1989
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
1990
 
  }/*unpack results and cleanup*/
1991
 
  return _result;
1992
 
}
1993
 
 
1994
 
 
1995
 
 
1996
 
/**
1997
 
 * Add to matrix coefficients index by index.
1998
 
 * 
1999
 
 * NOTE: Users are required to set values on all processes that
2000
 
 * own the associated variables.  This means that some data will
2001
 
 * be multiply defined.
2002
 
 * 
2003
 
 * NOTE: The entries in this routine must all be of the same
2004
 
 * type: either stencil or non-stencil, but not both.  Also, if
2005
 
 * they are stencil entries, they must all represent couplings
2006
 
 * to the same variable type.
2007
 
 * 
2008
 
 * If the matrix is complex, then {\tt values} consists of pairs
2009
 
 * of doubles representing the real and imaginary parts of each
2010
 
 * complex value.
2011
 
 */
2012
 
int32_t
2013
 
bHYPRE::SStructMatrixView::AddToValues( /* in */int32_t part,
2014
 
  /* in rarray[dim] */int32_t* index, /* in */int32_t dim, /* in */int32_t var,
2015
 
  /* in */int32_t nentries, /* in rarray[nentries] */int32_t* entries,
2016
 
  /* in rarray[nentries] */double* values )
2017
 
 
2018
 
{
2019
 
  int32_t _result;
2020
 
  ior_t* const loc_self = (ior_t*) 
2021
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
2022
 
  int32_t index_lower[1], index_upper[1], index_stride[1];
2023
 
  struct sidl_int__array index_real;
2024
 
  struct sidl_int__array *index_tmp = &index_real;
2025
 
  index_upper[0] = dim-1;
2026
 
  sidl_int__array_init(index, index_tmp, 1, index_lower, index_upper,
2027
 
    index_stride);
2028
 
  int32_t entries_lower[1], entries_upper[1], entries_stride[1];
2029
 
  struct sidl_int__array entries_real;
2030
 
  struct sidl_int__array *entries_tmp = &entries_real;
2031
 
  entries_upper[0] = nentries-1;
2032
 
  sidl_int__array_init(entries, entries_tmp, 1, entries_lower, entries_upper,
2033
 
    entries_stride);
2034
 
  int32_t values_lower[1], values_upper[1], values_stride[1];
2035
 
  struct sidl_double__array values_real;
2036
 
  struct sidl_double__array *values_tmp = &values_real;
2037
 
  values_upper[0] = nentries-1;
2038
 
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper,
2039
 
    values_stride);
2040
 
  sidl_BaseInterface__object * _exception;
2041
 
  /*pack args to dispatch to ior*/
2042
 
  _result = (*(loc_self->d_epv->f_AddToValues))(loc_self->d_object,
2043
 
    /* in */ part, /* in rarray[dim] */ index_tmp, /* in */ var,
2044
 
    /* in rarray[nentries] */ entries_tmp, /* in rarray[nentries] */ values_tmp,
2045
 
    &_exception );
2046
 
  /*dispatch to ior*/
2047
 
  if (_exception != 0 ) {
2048
 
    throwException0(_exception);
2049
 
  }
2050
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
2051
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
2052
 
  }/*unpack results and cleanup*/
2053
 
  return _result;
2054
 
}
2055
 
 
2056
 
 
2057
 
 
2058
 
/**
2059
 
 * Add to matrix coefficients index by index.
2060
 
 * 
2061
 
 * NOTE: Users are required to set values on all processes that
2062
 
 * own the associated variables.  This means that some data will
2063
 
 * be multiply defined.
2064
 
 * 
2065
 
 * NOTE: The entries in this routine must all be of the same
2066
 
 * type: either stencil or non-stencil, but not both.  Also, if
2067
 
 * they are stencil entries, they must all represent couplings
2068
 
 * to the same variable type.
2069
 
 * 
2070
 
 * If the matrix is complex, then {\tt values} consists of pairs
2071
 
 * of doubles representing the real and imaginary parts of each
2072
 
 * complex value.
2073
 
 */
2074
 
int32_t
2075
 
bHYPRE::SStructMatrixView::AddToValues( /* in */int32_t part,
2076
 
  /* in rarray[dim] */::sidl::array<int32_t> index, /* in */int32_t var,
2077
 
  /* in rarray[nentries] */::sidl::array<int32_t> entries,
2078
 
  /* in rarray[nentries] */::sidl::array<double> values )
2079
 
 
2080
 
{
2081
 
  int32_t _result;
2082
 
  ior_t* const loc_self = (ior_t*) 
2083
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
2084
 
  sidl_BaseInterface__object * _exception;
2085
 
  /*pack args to dispatch to ior*/
2086
 
  _result = (*(loc_self->d_epv->f_AddToValues))(loc_self->d_object,
2087
 
    /* in */ part, /* in rarray[dim] */ index._get_ior(), /* in */ var,
2088
 
    /* in rarray[nentries] */ entries._get_ior(),
2089
 
    /* in rarray[nentries] */ values._get_ior(), &_exception );
2090
 
  /*dispatch to ior*/
2091
 
  if (_exception != 0 ) {
2092
 
    throwException0(_exception);
2093
 
  }
2094
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
2095
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
2096
 
  }/*unpack results and cleanup*/
2097
 
  return _result;
2098
 
}
2099
 
 
2100
 
 
2101
 
 
2102
 
/**
2103
 
 * Add to matrix coefficients a box at a time.
2104
 
 * 
2105
 
 * NOTE: Users are required to set values on all processes that
2106
 
 * own the associated variables.  This means that some data will
2107
 
 * be multiply defined.
2108
 
 * 
2109
 
 * NOTE: The entries in this routine must all be of stencil
2110
 
 * type.  Also, they must all represent couplings to the same
2111
 
 * variable type.
2112
 
 * 
2113
 
 * If the matrix is complex, then {\tt values} consists of pairs
2114
 
 * of doubles representing the real and imaginary parts of each
2115
 
 * complex value.
2116
 
 */
2117
 
int32_t
2118
 
bHYPRE::SStructMatrixView::AddToBoxValues( /* in */int32_t part,
2119
 
  /* in rarray[dim] */int32_t* ilower, /* in rarray[dim] */int32_t* iupper,
2120
 
  /* in */int32_t dim, /* in */int32_t var, /* in */int32_t nentries,
2121
 
  /* in rarray[nentries] */int32_t* entries,
2122
 
  /* in rarray[nvalues] */double* values, /* in */int32_t nvalues )
2123
 
 
2124
 
{
2125
 
  int32_t _result;
2126
 
  ior_t* const loc_self = (ior_t*) 
2127
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
2128
 
  int32_t ilower_lower[1], ilower_upper[1], ilower_stride[1];
2129
 
  struct sidl_int__array ilower_real;
2130
 
  struct sidl_int__array *ilower_tmp = &ilower_real;
2131
 
  ilower_upper[0] = dim-1;
2132
 
  sidl_int__array_init(ilower, ilower_tmp, 1, ilower_lower, ilower_upper,
2133
 
    ilower_stride);
2134
 
  int32_t iupper_lower[1], iupper_upper[1], iupper_stride[1];
2135
 
  struct sidl_int__array iupper_real;
2136
 
  struct sidl_int__array *iupper_tmp = &iupper_real;
2137
 
  iupper_upper[0] = dim-1;
2138
 
  sidl_int__array_init(iupper, iupper_tmp, 1, iupper_lower, iupper_upper,
2139
 
    iupper_stride);
2140
 
  int32_t entries_lower[1], entries_upper[1], entries_stride[1];
2141
 
  struct sidl_int__array entries_real;
2142
 
  struct sidl_int__array *entries_tmp = &entries_real;
2143
 
  entries_upper[0] = nentries-1;
2144
 
  sidl_int__array_init(entries, entries_tmp, 1, entries_lower, entries_upper,
2145
 
    entries_stride);
2146
 
  int32_t values_lower[1], values_upper[1], values_stride[1];
2147
 
  struct sidl_double__array values_real;
2148
 
  struct sidl_double__array *values_tmp = &values_real;
2149
 
  values_upper[0] = nvalues-1;
2150
 
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper,
2151
 
    values_stride);
2152
 
  sidl_BaseInterface__object * _exception;
2153
 
  /*pack args to dispatch to ior*/
2154
 
  _result = (*(loc_self->d_epv->f_AddToBoxValues))(loc_self->d_object,
2155
 
    /* in */ part, /* in rarray[dim] */ ilower_tmp,
2156
 
    /* in rarray[dim] */ iupper_tmp, /* in */ var,
2157
 
    /* in rarray[nentries] */ entries_tmp, /* in rarray[nvalues] */ values_tmp,
2158
 
    &_exception );
2159
 
  /*dispatch to ior*/
2160
 
  if (_exception != 0 ) {
2161
 
    throwException0(_exception);
2162
 
  }
2163
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
2164
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
2165
 
  }/*unpack results and cleanup*/
2166
 
  return _result;
2167
 
}
2168
 
 
2169
 
 
2170
 
 
2171
 
/**
2172
 
 * Add to matrix coefficients a box at a time.
2173
 
 * 
2174
 
 * NOTE: Users are required to set values on all processes that
2175
 
 * own the associated variables.  This means that some data will
2176
 
 * be multiply defined.
2177
 
 * 
2178
 
 * NOTE: The entries in this routine must all be of stencil
2179
 
 * type.  Also, they must all represent couplings to the same
2180
 
 * variable type.
2181
 
 * 
2182
 
 * If the matrix is complex, then {\tt values} consists of pairs
2183
 
 * of doubles representing the real and imaginary parts of each
2184
 
 * complex value.
2185
 
 */
2186
 
int32_t
2187
 
bHYPRE::SStructMatrixView::AddToBoxValues( /* in */int32_t part,
2188
 
  /* in rarray[dim] */::sidl::array<int32_t> ilower,
2189
 
  /* in rarray[dim] */::sidl::array<int32_t> iupper, /* in */int32_t var,
2190
 
  /* in rarray[nentries] */::sidl::array<int32_t> entries,
2191
 
  /* in rarray[nvalues] */::sidl::array<double> values )
2192
 
 
2193
 
{
2194
 
  int32_t _result;
2195
 
  ior_t* const loc_self = (ior_t*) 
2196
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
2197
 
  sidl_BaseInterface__object * _exception;
2198
 
  /*pack args to dispatch to ior*/
2199
 
  _result = (*(loc_self->d_epv->f_AddToBoxValues))(loc_self->d_object,
2200
 
    /* in */ part, /* in rarray[dim] */ ilower._get_ior(),
2201
 
    /* in rarray[dim] */ iupper._get_ior(), /* in */ var,
2202
 
    /* in rarray[nentries] */ entries._get_ior(),
2203
 
    /* in rarray[nvalues] */ values._get_ior(), &_exception );
2204
 
  /*dispatch to ior*/
2205
 
  if (_exception != 0 ) {
2206
 
    throwException0(_exception);
2207
 
  }
2208
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
2209
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
2210
 
  }/*unpack results and cleanup*/
 
1751
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
1752
    ::bHYPRE::SStructMatrixView::_get_ior();
 
1753
  struct bHYPRE_SStructGraph__object* _local_graph = (struct 
 
1754
    bHYPRE_SStructGraph__object*) graph.::bHYPRE::SStructGraph::_get_ior();
 
1755
  sidl_BaseInterface__object * _exception;
 
1756
  /*pack args to dispatch to ior*/
 
1757
  _result = (*(loc_self->d_epv->f_SetGraph))(loc_self->d_object, /* in */ 
 
1758
    _local_graph, &_exception );
 
1759
  /*dispatch to ior*/
 
1760
  if (_exception != 0 ) {
 
1761
 
 
1762
    throwException0(_exception);
 
1763
  }
 
1764
  /*unpack results and cleanup*/
 
1765
  return _result;
 
1766
}
 
1767
 
 
1768
 
 
1769
 
 
1770
/**
 
1771
 * Set matrix coefficients index by index.
 
1772
 * 
 
1773
 * NOTE: Users are required to set values on all processes that
 
1774
 * own the associated variables.  This means that some data will
 
1775
 * be multiply defined.
 
1776
 * 
 
1777
 * NOTE: The entries in this routine must all be of the same
 
1778
 * type: either stencil or non-stencil, but not both.  Also, if
 
1779
 * they are stencil entries, they must all represent couplings
 
1780
 * to the same variable type (there are no such restrictions for
 
1781
 * non-stencil entries).
 
1782
 * 
 
1783
 * If the matrix is complex, then {\tt values} consists of pairs
 
1784
 * of doubles representing the real and imaginary parts of each
 
1785
 * complex value.
 
1786
 */
 
1787
int32_t
 
1788
bHYPRE::SStructMatrixView::SetValues( /* in */int32_t part, /* in rarray[dim] 
 
1789
  */int32_t* index, /* in */int32_t dim, /* in */int32_t var, /* in */int32_t 
 
1790
  nentries, /* in rarray[nentries] */int32_t* entries, /* in rarray[nentries] 
 
1791
  */double* values )
 
1792
 
 
1793
{
 
1794
  int32_t _result;
 
1795
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
1796
    ::bHYPRE::SStructMatrixView::_get_ior();
 
1797
  int32_t index_lower[1], index_upper[1], index_stride[1];
 
1798
  struct sidl_int__array index_real;
 
1799
  struct sidl_int__array *index_tmp = &index_real;
 
1800
  index_upper[0] = dim-1;
 
1801
  sidl_int__array_init(index, index_tmp, 1, index_lower, index_upper, 
 
1802
    index_stride);
 
1803
  int32_t entries_lower[1], entries_upper[1], entries_stride[1];
 
1804
  struct sidl_int__array entries_real;
 
1805
  struct sidl_int__array *entries_tmp = &entries_real;
 
1806
  entries_upper[0] = nentries-1;
 
1807
  sidl_int__array_init(entries, entries_tmp, 1, entries_lower, entries_upper, 
 
1808
    entries_stride);
 
1809
  int32_t values_lower[1], values_upper[1], values_stride[1];
 
1810
  struct sidl_double__array values_real;
 
1811
  struct sidl_double__array *values_tmp = &values_real;
 
1812
  values_upper[0] = nentries-1;
 
1813
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper, 
 
1814
    values_stride);
 
1815
  sidl_BaseInterface__object * _exception;
 
1816
  /*pack args to dispatch to ior*/
 
1817
  _result = (*(loc_self->d_epv->f_SetValues))(loc_self->d_object, /* in */ part,
 
1818
    /* in rarray[dim] */ index_tmp, /* in */ var, /* in rarray[nentries] */ 
 
1819
    entries_tmp, /* in rarray[nentries] */ values_tmp, &_exception );
 
1820
  /*dispatch to ior*/
 
1821
  if (_exception != 0 ) {
 
1822
    sidl__array_deleteRef((struct sidl__array *)index_tmp);
 
1823
    sidl__array_deleteRef((struct sidl__array *)entries_tmp);
 
1824
    sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
1825
 
 
1826
    throwException0(_exception);
 
1827
  }
 
1828
  sidl__array_deleteRef((struct sidl__array *)index_tmp);
 
1829
  sidl__array_deleteRef((struct sidl__array *)entries_tmp);
 
1830
  sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
1831
  /*unpack results and cleanup*/
 
1832
  return _result;
 
1833
}
 
1834
 
 
1835
 
 
1836
 
 
1837
/**
 
1838
 * Set matrix coefficients index by index.
 
1839
 * 
 
1840
 * NOTE: Users are required to set values on all processes that
 
1841
 * own the associated variables.  This means that some data will
 
1842
 * be multiply defined.
 
1843
 * 
 
1844
 * NOTE: The entries in this routine must all be of the same
 
1845
 * type: either stencil or non-stencil, but not both.  Also, if
 
1846
 * they are stencil entries, they must all represent couplings
 
1847
 * to the same variable type (there are no such restrictions for
 
1848
 * non-stencil entries).
 
1849
 * 
 
1850
 * If the matrix is complex, then {\tt values} consists of pairs
 
1851
 * of doubles representing the real and imaginary parts of each
 
1852
 * complex value.
 
1853
 */
 
1854
int32_t
 
1855
bHYPRE::SStructMatrixView::SetValues( /* in */int32_t part, /* in rarray[dim] 
 
1856
  */::sidl::array<int32_t> index, /* in */int32_t var, /* in rarray[nentries] 
 
1857
  */::sidl::array<int32_t> entries, /* in rarray[nentries] 
 
1858
  */::sidl::array<double> values )
 
1859
 
 
1860
{
 
1861
  int32_t _result;
 
1862
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
1863
    ::bHYPRE::SStructMatrixView::_get_ior();
 
1864
  sidl_BaseInterface__object * _exception;
 
1865
  /*pack args to dispatch to ior*/
 
1866
  _result = (*(loc_self->d_epv->f_SetValues))(loc_self->d_object, /* in */ part,
 
1867
    /* in rarray[dim] */ index._get_ior(), /* in */ var, /* in rarray[nentries] 
 
1868
    */ entries._get_ior(), /* in rarray[nentries] */ values._get_ior(), 
 
1869
    &_exception );
 
1870
  /*dispatch to ior*/
 
1871
  if (_exception != 0 ) {
 
1872
 
 
1873
    throwException0(_exception);
 
1874
  }
 
1875
  /*unpack results and cleanup*/
 
1876
  return _result;
 
1877
}
 
1878
 
 
1879
 
 
1880
 
 
1881
/**
 
1882
 * Set matrix coefficients a box at a time.
 
1883
 * 
 
1884
 * NOTE: Users are required to set values on all processes that
 
1885
 * own the associated variables.  This means that some data will
 
1886
 * be multiply defined.
 
1887
 * 
 
1888
 * NOTE: The entries in this routine must all be of the same
 
1889
 * type: either stencil or non-stencil, but not both.  Also, if
 
1890
 * they are stencil entries, they must all represent couplings
 
1891
 * to the same variable type (there are no such restrictions for
 
1892
 * non-stencil entries).
 
1893
 * 
 
1894
 * If the matrix is complex, then {\tt values} consists of pairs
 
1895
 * of doubles representing the real and imaginary parts of each
 
1896
 * complex value.
 
1897
 */
 
1898
int32_t
 
1899
bHYPRE::SStructMatrixView::SetBoxValues( /* in */int32_t part, /* in 
 
1900
  rarray[dim] */int32_t* ilower, /* in rarray[dim] */int32_t* iupper, /* in 
 
1901
  */int32_t dim, /* in */int32_t var, /* in */int32_t nentries, /* in 
 
1902
  rarray[nentries] */int32_t* entries, /* in rarray[nvalues] */double* values, 
 
1903
  /* in */int32_t nvalues )
 
1904
 
 
1905
{
 
1906
  int32_t _result;
 
1907
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
1908
    ::bHYPRE::SStructMatrixView::_get_ior();
 
1909
  int32_t ilower_lower[1], ilower_upper[1], ilower_stride[1];
 
1910
  struct sidl_int__array ilower_real;
 
1911
  struct sidl_int__array *ilower_tmp = &ilower_real;
 
1912
  ilower_upper[0] = dim-1;
 
1913
  sidl_int__array_init(ilower, ilower_tmp, 1, ilower_lower, ilower_upper, 
 
1914
    ilower_stride);
 
1915
  int32_t iupper_lower[1], iupper_upper[1], iupper_stride[1];
 
1916
  struct sidl_int__array iupper_real;
 
1917
  struct sidl_int__array *iupper_tmp = &iupper_real;
 
1918
  iupper_upper[0] = dim-1;
 
1919
  sidl_int__array_init(iupper, iupper_tmp, 1, iupper_lower, iupper_upper, 
 
1920
    iupper_stride);
 
1921
  int32_t entries_lower[1], entries_upper[1], entries_stride[1];
 
1922
  struct sidl_int__array entries_real;
 
1923
  struct sidl_int__array *entries_tmp = &entries_real;
 
1924
  entries_upper[0] = nentries-1;
 
1925
  sidl_int__array_init(entries, entries_tmp, 1, entries_lower, entries_upper, 
 
1926
    entries_stride);
 
1927
  int32_t values_lower[1], values_upper[1], values_stride[1];
 
1928
  struct sidl_double__array values_real;
 
1929
  struct sidl_double__array *values_tmp = &values_real;
 
1930
  values_upper[0] = nvalues-1;
 
1931
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper, 
 
1932
    values_stride);
 
1933
  sidl_BaseInterface__object * _exception;
 
1934
  /*pack args to dispatch to ior*/
 
1935
  _result = (*(loc_self->d_epv->f_SetBoxValues))(loc_self->d_object, /* in */ 
 
1936
    part, /* in rarray[dim] */ ilower_tmp, /* in rarray[dim] */ iupper_tmp, /* 
 
1937
    in */ var, /* in rarray[nentries] */ entries_tmp, /* in rarray[nvalues] */ 
 
1938
    values_tmp, &_exception );
 
1939
  /*dispatch to ior*/
 
1940
  if (_exception != 0 ) {
 
1941
    sidl__array_deleteRef((struct sidl__array *)ilower_tmp);
 
1942
    sidl__array_deleteRef((struct sidl__array *)iupper_tmp);
 
1943
    sidl__array_deleteRef((struct sidl__array *)entries_tmp);
 
1944
    sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
1945
 
 
1946
    throwException0(_exception);
 
1947
  }
 
1948
  sidl__array_deleteRef((struct sidl__array *)ilower_tmp);
 
1949
  sidl__array_deleteRef((struct sidl__array *)iupper_tmp);
 
1950
  sidl__array_deleteRef((struct sidl__array *)entries_tmp);
 
1951
  sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
1952
  /*unpack results and cleanup*/
 
1953
  return _result;
 
1954
}
 
1955
 
 
1956
 
 
1957
 
 
1958
/**
 
1959
 * Set matrix coefficients a box at a time.
 
1960
 * 
 
1961
 * NOTE: Users are required to set values on all processes that
 
1962
 * own the associated variables.  This means that some data will
 
1963
 * be multiply defined.
 
1964
 * 
 
1965
 * NOTE: The entries in this routine must all be of the same
 
1966
 * type: either stencil or non-stencil, but not both.  Also, if
 
1967
 * they are stencil entries, they must all represent couplings
 
1968
 * to the same variable type (there are no such restrictions for
 
1969
 * non-stencil entries).
 
1970
 * 
 
1971
 * If the matrix is complex, then {\tt values} consists of pairs
 
1972
 * of doubles representing the real and imaginary parts of each
 
1973
 * complex value.
 
1974
 */
 
1975
int32_t
 
1976
bHYPRE::SStructMatrixView::SetBoxValues( /* in */int32_t part, /* in 
 
1977
  rarray[dim] */::sidl::array<int32_t> ilower, /* in rarray[dim] 
 
1978
  */::sidl::array<int32_t> iupper, /* in */int32_t var, /* in rarray[nentries] 
 
1979
  */::sidl::array<int32_t> entries, /* in rarray[nvalues] 
 
1980
  */::sidl::array<double> values )
 
1981
 
 
1982
{
 
1983
  int32_t _result;
 
1984
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
1985
    ::bHYPRE::SStructMatrixView::_get_ior();
 
1986
  sidl_BaseInterface__object * _exception;
 
1987
  /*pack args to dispatch to ior*/
 
1988
  _result = (*(loc_self->d_epv->f_SetBoxValues))(loc_self->d_object, /* in */ 
 
1989
    part, /* in rarray[dim] */ ilower._get_ior(), /* in rarray[dim] */ 
 
1990
    iupper._get_ior(), /* in */ var, /* in rarray[nentries] */ entries._get_ior(
 
1991
    ), /* in rarray[nvalues] */ values._get_ior(), &_exception );
 
1992
  /*dispatch to ior*/
 
1993
  if (_exception != 0 ) {
 
1994
 
 
1995
    throwException0(_exception);
 
1996
  }
 
1997
  /*unpack results and cleanup*/
 
1998
  return _result;
 
1999
}
 
2000
 
 
2001
 
 
2002
 
 
2003
/**
 
2004
 * Add to matrix coefficients index by index.
 
2005
 * 
 
2006
 * NOTE: Users are required to set values on all processes that
 
2007
 * own the associated variables.  This means that some data will
 
2008
 * be multiply defined.
 
2009
 * 
 
2010
 * NOTE: The entries in this routine must all be of the same
 
2011
 * type: either stencil or non-stencil, but not both.  Also, if
 
2012
 * they are stencil entries, they must all represent couplings
 
2013
 * to the same variable type.
 
2014
 * 
 
2015
 * If the matrix is complex, then {\tt values} consists of pairs
 
2016
 * of doubles representing the real and imaginary parts of each
 
2017
 * complex value.
 
2018
 */
 
2019
int32_t
 
2020
bHYPRE::SStructMatrixView::AddToValues( /* in */int32_t part, /* in rarray[dim] 
 
2021
  */int32_t* index, /* in */int32_t dim, /* in */int32_t var, /* in */int32_t 
 
2022
  nentries, /* in rarray[nentries] */int32_t* entries, /* in rarray[nentries] 
 
2023
  */double* values )
 
2024
 
 
2025
{
 
2026
  int32_t _result;
 
2027
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2028
    ::bHYPRE::SStructMatrixView::_get_ior();
 
2029
  int32_t index_lower[1], index_upper[1], index_stride[1];
 
2030
  struct sidl_int__array index_real;
 
2031
  struct sidl_int__array *index_tmp = &index_real;
 
2032
  index_upper[0] = dim-1;
 
2033
  sidl_int__array_init(index, index_tmp, 1, index_lower, index_upper, 
 
2034
    index_stride);
 
2035
  int32_t entries_lower[1], entries_upper[1], entries_stride[1];
 
2036
  struct sidl_int__array entries_real;
 
2037
  struct sidl_int__array *entries_tmp = &entries_real;
 
2038
  entries_upper[0] = nentries-1;
 
2039
  sidl_int__array_init(entries, entries_tmp, 1, entries_lower, entries_upper, 
 
2040
    entries_stride);
 
2041
  int32_t values_lower[1], values_upper[1], values_stride[1];
 
2042
  struct sidl_double__array values_real;
 
2043
  struct sidl_double__array *values_tmp = &values_real;
 
2044
  values_upper[0] = nentries-1;
 
2045
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper, 
 
2046
    values_stride);
 
2047
  sidl_BaseInterface__object * _exception;
 
2048
  /*pack args to dispatch to ior*/
 
2049
  _result = (*(loc_self->d_epv->f_AddToValues))(loc_self->d_object, /* in */ 
 
2050
    part, /* in rarray[dim] */ index_tmp, /* in */ var, /* in rarray[nentries] 
 
2051
    */ entries_tmp, /* in rarray[nentries] */ values_tmp, &_exception );
 
2052
  /*dispatch to ior*/
 
2053
  if (_exception != 0 ) {
 
2054
    sidl__array_deleteRef((struct sidl__array *)index_tmp);
 
2055
    sidl__array_deleteRef((struct sidl__array *)entries_tmp);
 
2056
    sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
2057
 
 
2058
    throwException0(_exception);
 
2059
  }
 
2060
  sidl__array_deleteRef((struct sidl__array *)index_tmp);
 
2061
  sidl__array_deleteRef((struct sidl__array *)entries_tmp);
 
2062
  sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
2063
  /*unpack results and cleanup*/
 
2064
  return _result;
 
2065
}
 
2066
 
 
2067
 
 
2068
 
 
2069
/**
 
2070
 * Add to matrix coefficients index by index.
 
2071
 * 
 
2072
 * NOTE: Users are required to set values on all processes that
 
2073
 * own the associated variables.  This means that some data will
 
2074
 * be multiply defined.
 
2075
 * 
 
2076
 * NOTE: The entries in this routine must all be of the same
 
2077
 * type: either stencil or non-stencil, but not both.  Also, if
 
2078
 * they are stencil entries, they must all represent couplings
 
2079
 * to the same variable type.
 
2080
 * 
 
2081
 * If the matrix is complex, then {\tt values} consists of pairs
 
2082
 * of doubles representing the real and imaginary parts of each
 
2083
 * complex value.
 
2084
 */
 
2085
int32_t
 
2086
bHYPRE::SStructMatrixView::AddToValues( /* in */int32_t part, /* in rarray[dim] 
 
2087
  */::sidl::array<int32_t> index, /* in */int32_t var, /* in rarray[nentries] 
 
2088
  */::sidl::array<int32_t> entries, /* in rarray[nentries] 
 
2089
  */::sidl::array<double> values )
 
2090
 
 
2091
{
 
2092
  int32_t _result;
 
2093
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2094
    ::bHYPRE::SStructMatrixView::_get_ior();
 
2095
  sidl_BaseInterface__object * _exception;
 
2096
  /*pack args to dispatch to ior*/
 
2097
  _result = (*(loc_self->d_epv->f_AddToValues))(loc_self->d_object, /* in */ 
 
2098
    part, /* in rarray[dim] */ index._get_ior(), /* in */ var, /* in 
 
2099
    rarray[nentries] */ entries._get_ior(), /* in rarray[nentries] */ 
 
2100
    values._get_ior(), &_exception );
 
2101
  /*dispatch to ior*/
 
2102
  if (_exception != 0 ) {
 
2103
 
 
2104
    throwException0(_exception);
 
2105
  }
 
2106
  /*unpack results and cleanup*/
 
2107
  return _result;
 
2108
}
 
2109
 
 
2110
 
 
2111
 
 
2112
/**
 
2113
 * Add to matrix coefficients a box at a time.
 
2114
 * 
 
2115
 * NOTE: Users are required to set values on all processes that
 
2116
 * own the associated variables.  This means that some data will
 
2117
 * be multiply defined.
 
2118
 * 
 
2119
 * NOTE: The entries in this routine must all be of stencil
 
2120
 * type.  Also, they must all represent couplings to the same
 
2121
 * variable type.
 
2122
 * 
 
2123
 * If the matrix is complex, then {\tt values} consists of pairs
 
2124
 * of doubles representing the real and imaginary parts of each
 
2125
 * complex value.
 
2126
 */
 
2127
int32_t
 
2128
bHYPRE::SStructMatrixView::AddToBoxValues( /* in */int32_t part, /* in 
 
2129
  rarray[dim] */int32_t* ilower, /* in rarray[dim] */int32_t* iupper, /* in 
 
2130
  */int32_t dim, /* in */int32_t var, /* in */int32_t nentries, /* in 
 
2131
  rarray[nentries] */int32_t* entries, /* in rarray[nvalues] */double* values, 
 
2132
  /* in */int32_t nvalues )
 
2133
 
 
2134
{
 
2135
  int32_t _result;
 
2136
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2137
    ::bHYPRE::SStructMatrixView::_get_ior();
 
2138
  int32_t ilower_lower[1], ilower_upper[1], ilower_stride[1];
 
2139
  struct sidl_int__array ilower_real;
 
2140
  struct sidl_int__array *ilower_tmp = &ilower_real;
 
2141
  ilower_upper[0] = dim-1;
 
2142
  sidl_int__array_init(ilower, ilower_tmp, 1, ilower_lower, ilower_upper, 
 
2143
    ilower_stride);
 
2144
  int32_t iupper_lower[1], iupper_upper[1], iupper_stride[1];
 
2145
  struct sidl_int__array iupper_real;
 
2146
  struct sidl_int__array *iupper_tmp = &iupper_real;
 
2147
  iupper_upper[0] = dim-1;
 
2148
  sidl_int__array_init(iupper, iupper_tmp, 1, iupper_lower, iupper_upper, 
 
2149
    iupper_stride);
 
2150
  int32_t entries_lower[1], entries_upper[1], entries_stride[1];
 
2151
  struct sidl_int__array entries_real;
 
2152
  struct sidl_int__array *entries_tmp = &entries_real;
 
2153
  entries_upper[0] = nentries-1;
 
2154
  sidl_int__array_init(entries, entries_tmp, 1, entries_lower, entries_upper, 
 
2155
    entries_stride);
 
2156
  int32_t values_lower[1], values_upper[1], values_stride[1];
 
2157
  struct sidl_double__array values_real;
 
2158
  struct sidl_double__array *values_tmp = &values_real;
 
2159
  values_upper[0] = nvalues-1;
 
2160
  sidl_double__array_init(values, values_tmp, 1, values_lower, values_upper, 
 
2161
    values_stride);
 
2162
  sidl_BaseInterface__object * _exception;
 
2163
  /*pack args to dispatch to ior*/
 
2164
  _result = (*(loc_self->d_epv->f_AddToBoxValues))(loc_self->d_object, /* in */ 
 
2165
    part, /* in rarray[dim] */ ilower_tmp, /* in rarray[dim] */ iupper_tmp, /* 
 
2166
    in */ var, /* in rarray[nentries] */ entries_tmp, /* in rarray[nvalues] */ 
 
2167
    values_tmp, &_exception );
 
2168
  /*dispatch to ior*/
 
2169
  if (_exception != 0 ) {
 
2170
    sidl__array_deleteRef((struct sidl__array *)ilower_tmp);
 
2171
    sidl__array_deleteRef((struct sidl__array *)iupper_tmp);
 
2172
    sidl__array_deleteRef((struct sidl__array *)entries_tmp);
 
2173
    sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
2174
 
 
2175
    throwException0(_exception);
 
2176
  }
 
2177
  sidl__array_deleteRef((struct sidl__array *)ilower_tmp);
 
2178
  sidl__array_deleteRef((struct sidl__array *)iupper_tmp);
 
2179
  sidl__array_deleteRef((struct sidl__array *)entries_tmp);
 
2180
  sidl__array_deleteRef((struct sidl__array *)values_tmp);
 
2181
  /*unpack results and cleanup*/
 
2182
  return _result;
 
2183
}
 
2184
 
 
2185
 
 
2186
 
 
2187
/**
 
2188
 * Add to matrix coefficients a box at a time.
 
2189
 * 
 
2190
 * NOTE: Users are required to set values on all processes that
 
2191
 * own the associated variables.  This means that some data will
 
2192
 * be multiply defined.
 
2193
 * 
 
2194
 * NOTE: The entries in this routine must all be of stencil
 
2195
 * type.  Also, they must all represent couplings to the same
 
2196
 * variable type.
 
2197
 * 
 
2198
 * If the matrix is complex, then {\tt values} consists of pairs
 
2199
 * of doubles representing the real and imaginary parts of each
 
2200
 * complex value.
 
2201
 */
 
2202
int32_t
 
2203
bHYPRE::SStructMatrixView::AddToBoxValues( /* in */int32_t part, /* in 
 
2204
  rarray[dim] */::sidl::array<int32_t> ilower, /* in rarray[dim] 
 
2205
  */::sidl::array<int32_t> iupper, /* in */int32_t var, /* in rarray[nentries] 
 
2206
  */::sidl::array<int32_t> entries, /* in rarray[nvalues] 
 
2207
  */::sidl::array<double> values )
 
2208
 
 
2209
{
 
2210
  int32_t _result;
 
2211
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2212
    ::bHYPRE::SStructMatrixView::_get_ior();
 
2213
  sidl_BaseInterface__object * _exception;
 
2214
  /*pack args to dispatch to ior*/
 
2215
  _result = (*(loc_self->d_epv->f_AddToBoxValues))(loc_self->d_object, /* in */ 
 
2216
    part, /* in rarray[dim] */ ilower._get_ior(), /* in rarray[dim] */ 
 
2217
    iupper._get_ior(), /* in */ var, /* in rarray[nentries] */ entries._get_ior(
 
2218
    ), /* in rarray[nvalues] */ values._get_ior(), &_exception );
 
2219
  /*dispatch to ior*/
 
2220
  if (_exception != 0 ) {
 
2221
 
 
2222
    throwException0(_exception);
 
2223
  }
 
2224
  /*unpack results and cleanup*/
2211
2225
  return _result;
2212
2226
}
2213
2227
 
2229
2243
 * symmetric.
2230
2244
 */
2231
2245
int32_t
2232
 
bHYPRE::SStructMatrixView::SetSymmetric( /* in */int32_t part,
2233
 
  /* in */int32_t var, /* in */int32_t to_var, /* in */int32_t symmetric )
 
2246
bHYPRE::SStructMatrixView::SetSymmetric( /* in */int32_t part, /* in */int32_t 
 
2247
  var, /* in */int32_t to_var, /* in */int32_t symmetric )
2234
2248
 
2235
2249
{
2236
2250
  int32_t _result;
2237
 
  ior_t* const loc_self = (ior_t*) 
2238
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
 
2251
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2252
    ::bHYPRE::SStructMatrixView::_get_ior();
2239
2253
  sidl_BaseInterface__object * _exception;
2240
2254
  /*pack args to dispatch to ior*/
2241
 
  _result = (*(loc_self->d_epv->f_SetSymmetric))(loc_self->d_object,
2242
 
    /* in */ part, /* in */ var, /* in */ to_var, /* in */ symmetric,
2243
 
    &_exception );
 
2255
  _result = (*(loc_self->d_epv->f_SetSymmetric))(loc_self->d_object, /* in */ 
 
2256
    part, /* in */ var, /* in */ to_var, /* in */ symmetric, &_exception );
2244
2257
  /*dispatch to ior*/
2245
2258
  if (_exception != 0 ) {
 
2259
 
2246
2260
    throwException0(_exception);
2247
2261
  }
2248
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
2249
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
2250
 
  }/*unpack results and cleanup*/
 
2262
  /*unpack results and cleanup*/
2251
2263
  return _result;
2252
2264
}
2253
2265
 
2262
2274
 
2263
2275
{
2264
2276
  int32_t _result;
2265
 
  ior_t* const loc_self = (ior_t*) 
2266
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
 
2277
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2278
    ::bHYPRE::SStructMatrixView::_get_ior();
2267
2279
  sidl_BaseInterface__object * _exception;
2268
2280
  /*pack args to dispatch to ior*/
2269
 
  _result = (*(loc_self->d_epv->f_SetNSSymmetric))(loc_self->d_object,
2270
 
    /* in */ symmetric, &_exception );
 
2281
  _result = (*(loc_self->d_epv->f_SetNSSymmetric))(loc_self->d_object, /* in */ 
 
2282
    symmetric, &_exception );
2271
2283
  /*dispatch to ior*/
2272
2284
  if (_exception != 0 ) {
 
2285
 
2273
2286
    throwException0(_exception);
2274
2287
  }
2275
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
2276
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
2277
 
  }/*unpack results and cleanup*/
 
2288
  /*unpack results and cleanup*/
2278
2289
  return _result;
2279
2290
}
2280
2291
 
2288
2299
 
2289
2300
{
2290
2301
  int32_t _result;
2291
 
  ior_t* const loc_self = (ior_t*) 
2292
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
 
2302
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2303
    ::bHYPRE::SStructMatrixView::_get_ior();
2293
2304
  sidl_BaseInterface__object * _exception;
2294
2305
  /*pack args to dispatch to ior*/
2295
 
  _result = (*(loc_self->d_epv->f_SetComplex))(loc_self->d_object,
2296
 
    &_exception );
 
2306
  _result = (*(loc_self->d_epv->f_SetComplex))(loc_self->d_object, &_exception 
 
2307
    );
2297
2308
  /*dispatch to ior*/
2298
2309
  if (_exception != 0 ) {
 
2310
 
2299
2311
    throwException0(_exception);
2300
2312
  }
2301
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
2302
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
2303
 
  }/*unpack results and cleanup*/
 
2313
  /*unpack results and cleanup*/
2304
2314
  return _result;
2305
2315
}
2306
2316
 
2311
2321
 * purposes.
2312
2322
 */
2313
2323
int32_t
2314
 
bHYPRE::SStructMatrixView::Print( /* in */const ::std::string& filename,
2315
 
  /* in */int32_t all )
 
2324
bHYPRE::SStructMatrixView::Print( /* in */const ::std::string& filename, /* in 
 
2325
  */int32_t all )
2316
2326
 
2317
2327
{
2318
2328
  int32_t _result;
2319
 
  ior_t* const loc_self = (ior_t*) 
2320
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
 
2329
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2330
    ::bHYPRE::SStructMatrixView::_get_ior();
2321
2331
  sidl_BaseInterface__object * _exception;
2322
2332
  /*pack args to dispatch to ior*/
2323
 
  _result = (*(loc_self->d_epv->f_Print))(loc_self->d_object,
2324
 
    /* in */ filename.c_str(), /* in */ all, &_exception );
 
2333
  _result = (*(loc_self->d_epv->f_Print))(loc_self->d_object, /* in */ 
 
2334
    filename.c_str(), /* in */ all, &_exception );
2325
2335
  /*dispatch to ior*/
2326
2336
  if (_exception != 0 ) {
 
2337
 
2327
2338
    throwException0(_exception);
2328
2339
  }
2329
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
2330
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
2331
 
  }/*unpack results and cleanup*/
 
2340
  /*unpack results and cleanup*/
2332
2341
  return _result;
2333
2342
}
2334
2343
 
2341
2350
//  Babel's C++ bindings)
2342
2351
// 
2343
2352
 
2344
 
// remote connector 2
 
2353
// remote connector
2345
2354
::bHYPRE::SStructMatrixView
2346
2355
bHYPRE::SStructMatrixView::_connect(const std::string& url, const bool ar ) {
2347
2356
  ior_t* ior_self;
2348
 
  sidl_BaseInterface__object* _ex = 0;
2349
 
  ior_self = bHYPRE_SStructMatrixView__remoteConnect( url.c_str(),
2350
 
    ar?TRUE:FALSE, &_ex );
2351
 
  if (_ex != 0 ) {
2352
 
    ; //TODO: handle exception
 
2357
  struct sidl_BaseInterface__object *_exception;
 
2358
  ior_self = bHYPRE_SStructMatrixView__remoteConnect( url.c_str(), 
 
2359
    ar?TRUE:FALSE, &_exception );
 
2360
  if (_exception != 0 ) {
 
2361
    throwException0(_exception);
2353
2362
  }
2354
2363
  return ::bHYPRE::SStructMatrixView( ior_self, false );
2355
2364
}
2357
2366
// copy constructor
2358
2367
bHYPRE::SStructMatrixView::SStructMatrixView ( const 
2359
2368
  ::bHYPRE::SStructMatrixView& original ) {
2360
 
  d_self = ::bHYPRE::SStructMatrixView::_cast(original._get_ior());
 
2369
  d_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2370
    original.::bHYPRE::SStructMatrixView::_get_ior();
 
2371
  bHYPRE_SStructMatrixView_IORCache = (ior_t*) d_self;
 
2372
  if(d_self) {
 
2373
    addRef();
 
2374
  }
2361
2375
  d_weak_reference = false;
2362
2376
}
2363
2377
 
2368
2382
    if ( d_self != 0 ) {
2369
2383
      deleteRef();
2370
2384
    }
2371
 
    d_self = ::bHYPRE::SStructMatrixView::_cast(rhs._get_ior());
2372
 
    // note _cast incremements the reference count
 
2385
    d_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2386
      rhs.::bHYPRE::SStructMatrixView::_get_ior();
 
2387
    bHYPRE_SStructMatrixView_IORCache = (ior_t*) d_self;
 
2388
    if(d_self) {
 
2389
      addRef();
 
2390
    }
2373
2391
    d_weak_reference = false;
2374
2392
  }
2375
2393
  return *this;
2378
2396
// conversion from ior to C++ class
2379
2397
bHYPRE::SStructMatrixView::SStructMatrixView ( 
2380
2398
  ::bHYPRE::SStructMatrixView::ior_t* ior ) 
2381
 
   : StubBase(reinterpret_cast< void*>(ior)) { }
 
2399
   : StubBase(reinterpret_cast< void*>(ior)) { 
 
2400
  bHYPRE_SStructMatrixView_IORCache = (ior_t*) d_self;
 
2401
}
2382
2402
 
2383
2403
// Alternate constructor: does not call addRef()
2384
2404
// (sets d_weak_reference=isWeak)
2386
2406
bHYPRE::SStructMatrixView::SStructMatrixView ( 
2387
2407
  ::bHYPRE::SStructMatrixView::ior_t* ior, bool isWeak ) : 
2388
2408
StubBase(reinterpret_cast< void*>(ior), isWeak){ 
 
2409
  bHYPRE_SStructMatrixView_IORCache = (ior_t*) d_self;
2389
2410
}
2390
2411
 
2391
2412
// exec has special argument passing to avoid #include circularities
2412
2433
 
2413
2434
{
2414
2435
  ::std::string _result;
2415
 
  ior_t* const loc_self = (ior_t*) 
2416
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
 
2436
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2437
    ::bHYPRE::SStructMatrixView::_get_ior();
2417
2438
  char * _local_result;
2418
2439
  sidl_BaseInterface__object * _exception;
2419
2440
  /*pack args to dispatch to ior*/
2420
 
  _local_result = (*(loc_self->d_epv->f__getURL))(loc_self->d_object,
 
2441
  _local_result = (*(loc_self->d_epv->f__getURL))(loc_self->d_object, 
2421
2442
    &_exception );
2422
2443
  /*dispatch to ior*/
2423
2444
  if (_exception != 0 ) {
 
2445
 
2424
2446
    throwException0(_exception);
2425
2447
  }
2426
2448
  if (_local_result) {
2427
2449
    _result = _local_result;
2428
2450
    ::sidl_String_free( _local_result );
2429
2451
  }
2430
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
2431
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
2432
 
  }/*unpack results and cleanup*/
 
2452
  /*unpack results and cleanup*/
2433
2453
  return _result;
2434
2454
}
2435
2455
 
2444
2464
 
2445
2465
{
2446
2466
 
2447
 
  ior_t* const loc_self = (ior_t*) 
2448
 
    ::bHYPRE::SStructMatrixView::_cast((void*)(_get_ior()));
 
2467
  ior_t* const loc_self = (struct bHYPRE_SStructMatrixView__object*) 
 
2468
    ::bHYPRE::SStructMatrixView::_get_ior();
2449
2469
  sidl_bool _local_on = on;
2450
2470
  sidl_BaseInterface__object * _exception;
2451
2471
  /*pack args to dispatch to ior*/
2452
 
  (*(loc_self->d_epv->f__set_hooks))(loc_self->d_object, /* in */ _local_on,
 
2472
  (*(loc_self->d_epv->f__set_hooks))(loc_self->d_object, /* in */ _local_on, 
2453
2473
    &_exception );
2454
2474
  /*dispatch to ior*/
2455
2475
  if (_exception != 0 ) {
 
2476
 
2456
2477
    throwException0(_exception);
2457
2478
  }
2458
 
  {  struct sidl_BaseInterface__object *throwaway_exception;  
2459
 
    (*loc_self->d_epv->f_deleteRef)(loc_self->d_object, &throwaway_exception);
2460
 
  }/*unpack results and cleanup*/
 
2479
  /*unpack results and cleanup*/
2461
2480
}
2462
2481
 
2463
2482
// protected method that implements casting
2468
2487
 
2469
2488
  if(!connect_loaded) {
2470
2489
    struct sidl_BaseInterface__object *throwaway_exception;
2471
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructMatrixView",
2472
 
      (void*)bHYPRE_SStructMatrixView__IHConnect, &throwaway_exception);
 
2490
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.SStructMatrixView", (
 
2491
      void*)bHYPRE_SStructMatrixView__IHConnect, &throwaway_exception);
2473
2492
    connect_loaded = 1;
2474
2493
  }
2475
2494
  if ( src != 0 ) {
2478
2497
    struct sidl_BaseInterface__object *throwaway_exception;
2479
2498
    struct sidl_BaseInterface__object * base = reinterpret_cast< struct 
2480
2499
      sidl_BaseInterface__object *>(tmp);
2481
 
    cast = reinterpret_cast< ior_t*>((*base->d_epv->f__cast)(base->d_object,
 
2500
    cast = reinterpret_cast< ior_t*>((*base->d_epv->f__cast)(base->d_object, 
2482
2501
      "bHYPRE.SStructMatrixView", &throwaway_exception));
2483
2502
  }
2484
2503
  return cast;