← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/babel/bHYPREClient-P/bHYPRE/bHYPRE_Solver_Module.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam C. Powell, IV
  • Date: 2009-03-20 11:40:12 UTC
  • mfrom: (4.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20090320114012-132h6ok9w2r6o609
Tags: 2.4.0b-2
Rebuild against new openmpi.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/babel/bHYPREClient-P/bHYPRE/bHYPRE_Solver_Module.c
2
2
 * File:          bHYPRE_Solver_Module.c
3
3
 * Symbol:        bHYPRE.Solver-v1.0.0
4
4
 * Symbol Type:   interface
5
 
 * Babel Version: 1.0.0
 
5
 * Babel Version: 1.0.4
6
6
 * Description:   implement a C extension type for a sidl extendable
7
7
 * 
8
8
 * WARNING: Automatically generated; changes will be lost
139
139
 * RMI connector function for the class. (no addref)
140
140
 */
141
141
struct bHYPRE_Solver__object*
142
 
bHYPRE_Solver__connectI(const char * url, sidl_bool ar,                       \
143
 
  struct sidl_BaseInterface__object **_ex);
 
142
bHYPRE_Solver__connectI(const char * url, sidl_bool ar, struct                \
 
143
  sidl_BaseInterface__object **_ex);
144
144
 
145
145
/* Static variables to hold version of IOR */
146
 
static const int32_t s_IOR_MAJOR_VERSION = 0;
147
 
static const int32_t s_IOR_MINOR_VERSION = 10;
 
146
static const int32_t s_IOR_MAJOR_VERSION = 1;
 
147
static const int32_t s_IOR_MINOR_VERSION = 0;
148
148
 
149
149
/* Static variables for managing EPV initialization. */
150
150
static int s_remote_initialized = 0;
172
172
  cmp0 = strcmp(name, "bHYPRE._Solver");
173
173
  if (!cmp0) {
174
174
    (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
175
 
    cast = self;
 
175
    cast = ((struct bHYPRE__Solver__object*)self);
176
176
    return cast;
177
177
  }
178
178
  else if (cmp0 < 0) {
200
200
    }
201
201
  }
202
202
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
203
 
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,                    \
204
 
      struct sidl_BaseInterface__object**) = 
205
 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,                     \
206
 
        struct sidl_BaseInterface__object**)) 
 
203
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct             \
 
204
      sidl_BaseInterface__object**) = 
 
205
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct              \
 
206
        sidl_BaseInterface__object**)) 
207
207
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
208
208
    cast =  (*func)(((struct bHYPRE__Solver__remote*)self->d_data)->d_ih,     \
209
209
      _ex);
372
372
    }
373
373
 
374
374
    /* extract return value */
375
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
376
 
      _ex);SIDL_CHECK(*_ex);
 
375
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
376
      *_ex);
377
377
 
378
378
    /* unpack out and inout arguments */
379
379
 
422
422
    }
423
423
 
424
424
    /* extract return value */
425
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
426
 
      _ex);SIDL_CHECK(*_ex);
 
425
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
426
      *_ex);
427
427
 
428
428
    /* unpack out and inout arguments */
429
429
 
472
472
    }
473
473
 
474
474
    /* extract return value */
475
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
476
 
      _ex);SIDL_CHECK(*_ex);
 
475
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
476
      *_ex);
477
477
 
478
478
    /* unpack out and inout arguments */
479
479
 
521
521
    }
522
522
 
523
523
    /* extract return value */
524
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
525
 
      _ex);SIDL_CHECK(*_ex);
 
524
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
525
      *_ex);
526
526
 
527
527
    /* unpack out and inout arguments */
528
528
 
570
570
    }
571
571
 
572
572
    /* extract return value */
573
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
574
 
      _ex);SIDL_CHECK(*_ex);
 
573
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
574
      *_ex);
575
575
 
576
576
    /* unpack out and inout arguments */
577
577
 
618
618
    }
619
619
 
620
620
    /* extract return value */
621
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
622
 
      _ex);SIDL_CHECK(*_ex);
 
621
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
622
      *_ex);
623
623
 
624
624
    /* unpack out and inout arguments */
625
625
    sidl_rmi_Response_unpackInt( _rsvp, "num_iterations", num_iterations,     \
668
668
    }
669
669
 
670
670
    /* extract return value */
671
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
672
 
      _ex);SIDL_CHECK(*_ex);
 
671
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
672
      *_ex);
673
673
 
674
674
    /* unpack out and inout arguments */
675
 
    sidl_rmi_Response_unpackDouble( _rsvp, "norm", norm,                      \
676
 
      _ex);SIDL_CHECK(*_ex);
 
675
    sidl_rmi_Response_unpackDouble( _rsvp, "norm", norm, _ex);SIDL_CHECK(     \
 
676
      *_ex);
677
677
 
678
678
    /* cleanup and return */
679
679
    EXIT:
707
707
    if(mpi_comm){
708
708
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm,   \
709
709
        _ex);SIDL_CHECK(*_ex);
710
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url,                 \
711
 
        _ex);SIDL_CHECK(*_ex);
 
710
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url, _ex);SIDL_CHECK(\
 
711
        *_ex);
712
712
      free((void*)_url);
713
713
    } else {
714
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL,                 \
715
 
        _ex);SIDL_CHECK(*_ex);
 
714
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL, _ex);SIDL_CHECK(\
 
715
        *_ex);
716
716
    }
717
717
 
718
718
    /* send actual RMI request */
728
728
    }
729
729
 
730
730
    /* extract return value */
731
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
732
 
      _ex);SIDL_CHECK(*_ex);
 
731
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
732
      *_ex);
733
733
 
734
734
    /* unpack out and inout arguments */
735
735
 
821
821
    }
822
822
 
823
823
    /* extract return value */
824
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
825
 
      _ex);SIDL_CHECK(*_ex);
 
824
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
825
      *_ex);
826
826
 
827
827
    /* unpack out and inout arguments */
828
828
 
857
857
 
858
858
    /* pack in and inout arguments */
859
859
    sidl_rmi_Invocation_packString( _inv, "name", name, _ex);SIDL_CHECK(*_ex);
860
 
    sidl_rmi_Invocation_packDouble( _inv, "value", value,                     \
861
 
      _ex);SIDL_CHECK(*_ex);
 
860
    sidl_rmi_Invocation_packDouble( _inv, "value", value, _ex);SIDL_CHECK(    \
 
861
      *_ex);
862
862
 
863
863
    /* send actual RMI request */
864
864
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
873
873
    }
874
874
 
875
875
    /* extract return value */
876
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
877
 
      _ex);SIDL_CHECK(*_ex);
 
876
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
877
      *_ex);
878
878
 
879
879
    /* unpack out and inout arguments */
880
880
 
909
909
 
910
910
    /* pack in and inout arguments */
911
911
    sidl_rmi_Invocation_packString( _inv, "name", name, _ex);SIDL_CHECK(*_ex);
912
 
    sidl_rmi_Invocation_packString( _inv, "value", value,                     \
913
 
      _ex);SIDL_CHECK(*_ex);
 
912
    sidl_rmi_Invocation_packString( _inv, "value", value, _ex);SIDL_CHECK(    \
 
913
      *_ex);
914
914
 
915
915
    /* send actual RMI request */
916
916
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
925
925
    }
926
926
 
927
927
    /* extract return value */
928
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
929
 
      _ex);SIDL_CHECK(*_ex);
 
928
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
929
      *_ex);
930
930
 
931
931
    /* unpack out and inout arguments */
932
932
 
977
977
    }
978
978
 
979
979
    /* extract return value */
980
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
981
 
      _ex);SIDL_CHECK(*_ex);
 
980
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
981
      *_ex);
982
982
 
983
983
    /* unpack out and inout arguments */
984
984
 
1029
1029
    }
1030
1030
 
1031
1031
    /* extract return value */
1032
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1033
 
      _ex);SIDL_CHECK(*_ex);
 
1032
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1033
      *_ex);
1034
1034
 
1035
1035
    /* unpack out and inout arguments */
1036
1036
 
1081
1081
    }
1082
1082
 
1083
1083
    /* extract return value */
1084
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1085
 
      _ex);SIDL_CHECK(*_ex);
 
1084
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1085
      *_ex);
1086
1086
 
1087
1087
    /* unpack out and inout arguments */
1088
1088
 
1133
1133
    }
1134
1134
 
1135
1135
    /* extract return value */
1136
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1137
 
      _ex);SIDL_CHECK(*_ex);
 
1136
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1137
      *_ex);
1138
1138
 
1139
1139
    /* unpack out and inout arguments */
1140
1140
 
1183
1183
    }
1184
1184
 
1185
1185
    /* extract return value */
1186
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1187
 
      _ex);SIDL_CHECK(*_ex);
 
1186
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1187
      *_ex);
1188
1188
 
1189
1189
    /* unpack out and inout arguments */
1190
1190
    sidl_rmi_Response_unpackInt( _rsvp, "value", value, _ex);SIDL_CHECK(*_ex);
1234
1234
    }
1235
1235
 
1236
1236
    /* extract return value */
1237
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1238
 
      _ex);SIDL_CHECK(*_ex);
 
1237
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1238
      *_ex);
1239
1239
 
1240
1240
    /* unpack out and inout arguments */
1241
 
    sidl_rmi_Response_unpackDouble( _rsvp, "value", value,                    \
1242
 
      _ex);SIDL_CHECK(*_ex);
 
1241
    sidl_rmi_Response_unpackDouble( _rsvp, "value", value, _ex);SIDL_CHECK(   \
 
1242
      *_ex);
1243
1243
 
1244
1244
    /* cleanup and return */
1245
1245
    EXIT:
1301
1301
    }
1302
1302
 
1303
1303
    /* extract return value */
1304
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1305
 
      _ex);SIDL_CHECK(*_ex);
 
1304
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1305
      *_ex);
1306
1306
 
1307
1307
    /* unpack out and inout arguments */
1308
1308
 
1358
1358
      SIDL_CHECK(*_ex);
1359
1359
      (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((                       \
1360
1360
        sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
1361
 
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,                    \
1362
 
        _ex);SIDL_CHECK(*_ex); 
 
1361
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(   \
 
1362
        *_ex); 
1363
1363
    }
1364
1364
 
1365
1365
    /* send actual RMI request */
1375
1375
    }
1376
1376
 
1377
1377
    /* extract return value */
1378
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1379
 
      _ex);SIDL_CHECK(*_ex);
 
1378
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1379
      *_ex);
1380
1380
 
1381
1381
    /* unpack out and inout arguments */
1382
1382
    sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
1434
1434
      SIDL_CHECK(*_ex);
1435
1435
      (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((                       \
1436
1436
        sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
1437
 
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,                    \
1438
 
        _ex);SIDL_CHECK(*_ex); 
 
1437
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(   \
 
1438
        *_ex); 
1439
1439
    }
1440
1440
 
1441
1441
    /* send actual RMI request */
1451
1451
    }
1452
1452
 
1453
1453
    /* extract return value */
1454
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,                  \
1455
 
      _ex);SIDL_CHECK(*_ex);
 
1454
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK( \
 
1455
      *_ex);
1456
1456
 
1457
1457
    /* unpack out and inout arguments */
1458
1458
    sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
1529
1529
    if(iobj){
1530
1530
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,       \
1531
1531
        _ex);SIDL_CHECK(*_ex);
1532
 
      sidl_rmi_Invocation_packString( _inv, "iobj", _url,                     \
1533
 
        _ex);SIDL_CHECK(*_ex);
 
1532
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(    \
 
1533
        *_ex);
1534
1534
      free((void*)_url);
1535
1535
    } else {
1536
 
      sidl_rmi_Invocation_packString( _inv, "iobj", NULL,                     \
1537
 
        _ex);SIDL_CHECK(*_ex);
 
1536
      sidl_rmi_Invocation_packString( _inv, "iobj", NULL, _ex);SIDL_CHECK(    \
 
1537
        *_ex);
1538
1538
    }
1539
1539
 
1540
1540
    /* send actual RMI request */
1550
1550
    }
1551
1551
 
1552
1552
    /* extract return value */
1553
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,                 \
1554
 
      _ex);SIDL_CHECK(*_ex);
 
1553
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
 
1554
      *_ex);
1555
1555
 
1556
1556
    /* unpack out and inout arguments */
1557
1557
 
1599
1599
    }
1600
1600
 
1601
1601
    /* extract return value */
1602
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,                 \
1603
 
      _ex);SIDL_CHECK(*_ex);
 
1602
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(\
 
1603
      *_ex);
1604
1604
 
1605
1605
    /* unpack out and inout arguments */
1606
1606
 
1649
1649
    /* extract return value */
1650
1650
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,           \
1651
1651
      _ex);SIDL_CHECK(*_ex);
1652
 
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,                    \
1653
 
      _ex);SIDL_CHECK(*_ex);
 
1652
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(   \
 
1653
      *_ex);
1654
1654
 
1655
1655
    /* unpack out and inout arguments */
1656
1656
 
1721
1721
 
1722
1722
  e0->f__cast                    = (void* (*)(void*,const char*,              \
1723
1723
    sidl_BaseInterface*)) epv->f__cast;
1724
 
  e0->f__delete                  = (void (*)(void*,                           \
1725
 
    sidl_BaseInterface*)) epv->f__delete;
1726
 
  e0->f__getURL                  = (char* (*)(void*,                          \
1727
 
    sidl_BaseInterface*)) epv->f__getURL;
1728
 
  e0->f__raddRef                 = (void (*)(void*,                           \
1729
 
    sidl_BaseInterface*)) epv->f__raddRef;
1730
 
  e0->f__isRemote                = (sidl_bool (*)(void*,                      \
1731
 
    sidl_BaseInterface*)) epv->f__isRemote;
 
1724
  e0->f__delete                  = (void (*)(void*,sidl_BaseInterface*))      \
 
1725
    epv->f__delete;
 
1726
  e0->f__getURL                  = (char* (*)(void*,sidl_BaseInterface*))     \
 
1727
    epv->f__getURL;
 
1728
  e0->f__raddRef                 = (void (*)(void*,sidl_BaseInterface*))      \
 
1729
    epv->f__raddRef;
 
1730
  e0->f__isRemote                = (sidl_bool (*)(void*,sidl_BaseInterface*)) \
 
1731
    epv->f__isRemote;
1732
1732
  e0->f__set_hooks               = (void (*)(void*,int32_t,                   \
1733
1733
    sidl_BaseInterface*)) epv->f__set_hooks;
1734
 
  e0->f__exec                    = (void (*)(void*,const char*,               \
1735
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1736
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1737
 
  e0->f_SetCommunicator          = (int32_t (*)(void*,                        \
1738
 
    struct bHYPRE_MPICommunicator__object*,                                   \
1739
 
    struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
1740
 
  e0->f_Destroy                  = (void (*)(void*,                           \
1741
 
    struct sidl_BaseInterface__object **)) epv->f_Destroy;
 
1734
  e0->f__exec                    = (void (*)(void*,const char*,struct         \
 
1735
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
 
1736
    sidl_BaseInterface__object **)) epv->f__exec;
 
1737
  e0->f_SetCommunicator          = (int32_t (*)(void*,struct                  \
 
1738
    bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **))    \
 
1739
    epv->f_SetCommunicator;
 
1740
  e0->f_Destroy                  = (void (*)(void*,struct                     \
 
1741
    sidl_BaseInterface__object **)) epv->f_Destroy;
1742
1742
  e0->f_SetIntParameter          = (int32_t (*)(void*,const char*,int32_t,    \
1743
1743
    struct sidl_BaseInterface__object **)) epv->f_SetIntParameter;
1744
1744
  e0->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,     \
1745
1745
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
1746
1746
  e0->f_SetStringParameter       = (int32_t (*)(void*,const char*,const char*,\
1747
1747
    struct sidl_BaseInterface__object **)) epv->f_SetStringParameter;
1748
 
  e0->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,            \
1749
 
    struct sidl_int__array*,                                                  \
1750
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray1Parameter;
1751
 
  e0->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,            \
1752
 
    struct sidl_int__array*,                                                  \
1753
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray2Parameter;
1754
 
  e0->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,            \
1755
 
    struct sidl_double__array*,                                               \
1756
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray1Parameter;
1757
 
  e0->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,            \
1758
 
    struct sidl_double__array*,                                               \
1759
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray2Parameter;
 
1748
  e0->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,struct      \
 
1749
    sidl_int__array*,struct sidl_BaseInterface__object **))                   \
 
1750
    epv->f_SetIntArray1Parameter;
 
1751
  e0->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,struct      \
 
1752
    sidl_int__array*,struct sidl_BaseInterface__object **))                   \
 
1753
    epv->f_SetIntArray2Parameter;
 
1754
  e0->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,struct      \
 
1755
    sidl_double__array*,struct sidl_BaseInterface__object **))                \
 
1756
    epv->f_SetDoubleArray1Parameter;
 
1757
  e0->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,struct      \
 
1758
    sidl_double__array*,struct sidl_BaseInterface__object **))                \
 
1759
    epv->f_SetDoubleArray2Parameter;
1760
1760
  e0->f_GetIntValue              = (int32_t (*)(void*,const char*,int32_t*,   \
1761
1761
    struct sidl_BaseInterface__object **)) epv->f_GetIntValue;
1762
1762
  e0->f_GetDoubleValue           = (int32_t (*)(void*,const char*,double*,    \
1763
1763
    struct sidl_BaseInterface__object **)) epv->f_GetDoubleValue;
1764
 
  e0->f_Setup                    = (int32_t (*)(void*,                        \
1765
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,              \
1766
 
    struct sidl_BaseInterface__object **)) epv->f_Setup;
1767
 
  e0->f_Apply                    = (int32_t (*)(void*,                        \
1768
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,             \
1769
 
    struct sidl_BaseInterface__object **)) epv->f_Apply;
1770
 
  e0->f_ApplyAdjoint             = (int32_t (*)(void*,                        \
1771
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,             \
1772
 
    struct sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
1773
 
  e0->f_addRef                   = (void (*)(void*,                           \
1774
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1775
 
  e0->f_deleteRef                = (void (*)(void*,                           \
1776
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1777
 
  e0->f_isSame                   = (sidl_bool (*)(void*,                      \
1778
 
    struct sidl_BaseInterface__object*,                                       \
1779
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1780
 
  e0->f_isType                   = (sidl_bool (*)(void*,const char*,          \
1781
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
1764
  e0->f_Setup                    = (int32_t (*)(void*,struct                  \
 
1765
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,struct               \
 
1766
    sidl_BaseInterface__object **)) epv->f_Setup;
 
1767
  e0->f_Apply                    = (int32_t (*)(void*,struct                  \
 
1768
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct              \
 
1769
    sidl_BaseInterface__object **)) epv->f_Apply;
 
1770
  e0->f_ApplyAdjoint             = (int32_t (*)(void*,struct                  \
 
1771
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct              \
 
1772
    sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
 
1773
  e0->f_addRef                   = (void (*)(void*,struct                     \
 
1774
    sidl_BaseInterface__object **)) epv->f_addRef;
 
1775
  e0->f_deleteRef                = (void (*)(void*,struct                     \
 
1776
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1777
  e0->f_isSame                   = (sidl_bool (*)(void*,struct                \
 
1778
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1779
    epv->f_isSame;
 
1780
  e0->f_isType                   = (sidl_bool (*)(void*,const char*,struct    \
 
1781
    sidl_BaseInterface__object **)) epv->f_isType;
1782
1782
  e0->f_getClassInfo             = (struct sidl_ClassInfo__object* (*)(void*, \
1783
1783
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
1784
1784
 
1785
1785
  e1->f__cast                    = (void* (*)(void*,const char*,              \
1786
1786
    sidl_BaseInterface*)) epv->f__cast;
1787
 
  e1->f__delete                  = (void (*)(void*,                           \
1788
 
    sidl_BaseInterface*)) epv->f__delete;
1789
 
  e1->f__getURL                  = (char* (*)(void*,                          \
1790
 
    sidl_BaseInterface*)) epv->f__getURL;
1791
 
  e1->f__raddRef                 = (void (*)(void*,                           \
1792
 
    sidl_BaseInterface*)) epv->f__raddRef;
1793
 
  e1->f__isRemote                = (sidl_bool (*)(void*,                      \
1794
 
    sidl_BaseInterface*)) epv->f__isRemote;
 
1787
  e1->f__delete                  = (void (*)(void*,sidl_BaseInterface*))      \
 
1788
    epv->f__delete;
 
1789
  e1->f__getURL                  = (char* (*)(void*,sidl_BaseInterface*))     \
 
1790
    epv->f__getURL;
 
1791
  e1->f__raddRef                 = (void (*)(void*,sidl_BaseInterface*))      \
 
1792
    epv->f__raddRef;
 
1793
  e1->f__isRemote                = (sidl_bool (*)(void*,sidl_BaseInterface*)) \
 
1794
    epv->f__isRemote;
1795
1795
  e1->f__set_hooks               = (void (*)(void*,int32_t,                   \
1796
1796
    sidl_BaseInterface*)) epv->f__set_hooks;
1797
 
  e1->f__exec                    = (void (*)(void*,const char*,               \
1798
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1799
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1800
 
  e1->f_SetOperator              = (int32_t (*)(void*,                        \
1801
 
    struct bHYPRE_Operator__object*,                                          \
1802
 
    struct sidl_BaseInterface__object **)) epv->f_SetOperator;
1803
 
  e1->f_SetTolerance             = (int32_t (*)(void*,double,                 \
1804
 
    struct sidl_BaseInterface__object **)) epv->f_SetTolerance;
1805
 
  e1->f_SetMaxIterations         = (int32_t (*)(void*,int32_t,                \
1806
 
    struct sidl_BaseInterface__object **)) epv->f_SetMaxIterations;
1807
 
  e1->f_SetLogging               = (int32_t (*)(void*,int32_t,                \
1808
 
    struct sidl_BaseInterface__object **)) epv->f_SetLogging;
1809
 
  e1->f_SetPrintLevel            = (int32_t (*)(void*,int32_t,                \
1810
 
    struct sidl_BaseInterface__object **)) epv->f_SetPrintLevel;
1811
 
  e1->f_GetNumIterations         = (int32_t (*)(void*,int32_t*,               \
1812
 
    struct sidl_BaseInterface__object **)) epv->f_GetNumIterations;
1813
 
  e1->f_GetRelResidualNorm       = (int32_t (*)(void*,double*,                \
1814
 
    struct sidl_BaseInterface__object **)) epv->f_GetRelResidualNorm;
1815
 
  e1->f_SetCommunicator          = (int32_t (*)(void*,                        \
1816
 
    struct bHYPRE_MPICommunicator__object*,                                   \
1817
 
    struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
1818
 
  e1->f_Destroy                  = (void (*)(void*,                           \
1819
 
    struct sidl_BaseInterface__object **)) epv->f_Destroy;
 
1797
  e1->f__exec                    = (void (*)(void*,const char*,struct         \
 
1798
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
 
1799
    sidl_BaseInterface__object **)) epv->f__exec;
 
1800
  e1->f_SetOperator              = (int32_t (*)(void*,struct                  \
 
1801
    bHYPRE_Operator__object*,struct sidl_BaseInterface__object **))           \
 
1802
    epv->f_SetOperator;
 
1803
  e1->f_SetTolerance             = (int32_t (*)(void*,double,struct           \
 
1804
    sidl_BaseInterface__object **)) epv->f_SetTolerance;
 
1805
  e1->f_SetMaxIterations         = (int32_t (*)(void*,int32_t,struct          \
 
1806
    sidl_BaseInterface__object **)) epv->f_SetMaxIterations;
 
1807
  e1->f_SetLogging               = (int32_t (*)(void*,int32_t,struct          \
 
1808
    sidl_BaseInterface__object **)) epv->f_SetLogging;
 
1809
  e1->f_SetPrintLevel            = (int32_t (*)(void*,int32_t,struct          \
 
1810
    sidl_BaseInterface__object **)) epv->f_SetPrintLevel;
 
1811
  e1->f_GetNumIterations         = (int32_t (*)(void*,int32_t*,struct         \
 
1812
    sidl_BaseInterface__object **)) epv->f_GetNumIterations;
 
1813
  e1->f_GetRelResidualNorm       = (int32_t (*)(void*,double*,struct          \
 
1814
    sidl_BaseInterface__object **)) epv->f_GetRelResidualNorm;
 
1815
  e1->f_SetCommunicator          = (int32_t (*)(void*,struct                  \
 
1816
    bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **))    \
 
1817
    epv->f_SetCommunicator;
 
1818
  e1->f_Destroy                  = (void (*)(void*,struct                     \
 
1819
    sidl_BaseInterface__object **)) epv->f_Destroy;
1820
1820
  e1->f_SetIntParameter          = (int32_t (*)(void*,const char*,int32_t,    \
1821
1821
    struct sidl_BaseInterface__object **)) epv->f_SetIntParameter;
1822
1822
  e1->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,     \
1823
1823
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
1824
1824
  e1->f_SetStringParameter       = (int32_t (*)(void*,const char*,const char*,\
1825
1825
    struct sidl_BaseInterface__object **)) epv->f_SetStringParameter;
1826
 
  e1->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,            \
1827
 
    struct sidl_int__array*,                                                  \
1828
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray1Parameter;
1829
 
  e1->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,            \
1830
 
    struct sidl_int__array*,                                                  \
1831
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray2Parameter;
1832
 
  e1->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,            \
1833
 
    struct sidl_double__array*,                                               \
1834
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray1Parameter;
1835
 
  e1->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,            \
1836
 
    struct sidl_double__array*,                                               \
1837
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray2Parameter;
 
1826
  e1->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,struct      \
 
1827
    sidl_int__array*,struct sidl_BaseInterface__object **))                   \
 
1828
    epv->f_SetIntArray1Parameter;
 
1829
  e1->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,struct      \
 
1830
    sidl_int__array*,struct sidl_BaseInterface__object **))                   \
 
1831
    epv->f_SetIntArray2Parameter;
 
1832
  e1->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,struct      \
 
1833
    sidl_double__array*,struct sidl_BaseInterface__object **))                \
 
1834
    epv->f_SetDoubleArray1Parameter;
 
1835
  e1->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,struct      \
 
1836
    sidl_double__array*,struct sidl_BaseInterface__object **))                \
 
1837
    epv->f_SetDoubleArray2Parameter;
1838
1838
  e1->f_GetIntValue              = (int32_t (*)(void*,const char*,int32_t*,   \
1839
1839
    struct sidl_BaseInterface__object **)) epv->f_GetIntValue;
1840
1840
  e1->f_GetDoubleValue           = (int32_t (*)(void*,const char*,double*,    \
1841
1841
    struct sidl_BaseInterface__object **)) epv->f_GetDoubleValue;
1842
 
  e1->f_Setup                    = (int32_t (*)(void*,                        \
1843
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,              \
1844
 
    struct sidl_BaseInterface__object **)) epv->f_Setup;
1845
 
  e1->f_Apply                    = (int32_t (*)(void*,                        \
1846
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,             \
1847
 
    struct sidl_BaseInterface__object **)) epv->f_Apply;
1848
 
  e1->f_ApplyAdjoint             = (int32_t (*)(void*,                        \
1849
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,             \
1850
 
    struct sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
1851
 
  e1->f_addRef                   = (void (*)(void*,                           \
1852
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1853
 
  e1->f_deleteRef                = (void (*)(void*,                           \
1854
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1855
 
  e1->f_isSame                   = (sidl_bool (*)(void*,                      \
1856
 
    struct sidl_BaseInterface__object*,                                       \
1857
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1858
 
  e1->f_isType                   = (sidl_bool (*)(void*,const char*,          \
1859
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
1842
  e1->f_Setup                    = (int32_t (*)(void*,struct                  \
 
1843
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,struct               \
 
1844
    sidl_BaseInterface__object **)) epv->f_Setup;
 
1845
  e1->f_Apply                    = (int32_t (*)(void*,struct                  \
 
1846
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct              \
 
1847
    sidl_BaseInterface__object **)) epv->f_Apply;
 
1848
  e1->f_ApplyAdjoint             = (int32_t (*)(void*,struct                  \
 
1849
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct              \
 
1850
    sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
 
1851
  e1->f_addRef                   = (void (*)(void*,struct                     \
 
1852
    sidl_BaseInterface__object **)) epv->f_addRef;
 
1853
  e1->f_deleteRef                = (void (*)(void*,struct                     \
 
1854
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
1855
  e1->f_isSame                   = (sidl_bool (*)(void*,struct                \
 
1856
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1857
    epv->f_isSame;
 
1858
  e1->f_isType                   = (sidl_bool (*)(void*,const char*,struct    \
 
1859
    sidl_BaseInterface__object **)) epv->f_isType;
1860
1860
  e1->f_getClassInfo             = (struct sidl_ClassInfo__object* (*)(void*, \
1861
1861
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
1862
1862
 
1863
 
  e2->f__cast        = (void* (*)(void*,const char*,                          \
1864
 
    sidl_BaseInterface*)) epv->f__cast;
 
1863
  e2->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*))     \
 
1864
    epv->f__cast;
1865
1865
  e2->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
1866
1866
  e2->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
1867
1867
  e2->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
1868
 
  e2->f__isRemote    = (sidl_bool (*)(void*,                                  \
1869
 
    sidl_BaseInterface*)) epv->f__isRemote;
1870
 
  e2->f__set_hooks   = (void (*)(void*,int32_t,                               \
1871
 
    sidl_BaseInterface*)) epv->f__set_hooks;
1872
 
  e2->f__exec        = (void (*)(void*,const char*,                           \
1873
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,            \
1874
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
1875
 
  e2->f_addRef       = (void (*)(void*,                                       \
1876
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
1877
 
  e2->f_deleteRef    = (void (*)(void*,                                       \
1878
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
1879
 
  e2->f_isSame       = (sidl_bool (*)(void*,                                  \
1880
 
    struct sidl_BaseInterface__object*,                                       \
1881
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
1882
 
  e2->f_isType       = (sidl_bool (*)(void*,const char*,                      \
1883
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
1884
 
  e2->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,             \
1885
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
1868
  e2->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*))             \
 
1869
    epv->f__isRemote;
 
1870
  e2->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*))         \
 
1871
    epv->f__set_hooks;
 
1872
  e2->f__exec        = (void (*)(void*,const char*,struct                     \
 
1873
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct             \
 
1874
    sidl_BaseInterface__object **)) epv->f__exec;
 
1875
  e2->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1876
    epv->f_addRef;
 
1877
  e2->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) \
 
1878
    epv->f_deleteRef;
 
1879
  e2->f_isSame       = (sidl_bool (*)(void*,struct                            \
 
1880
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **))        \
 
1881
    epv->f_isSame;
 
1882
  e2->f_isType       = (sidl_bool (*)(void*,const char*,struct                \
 
1883
    sidl_BaseInterface__object **)) epv->f_isType;
 
1884
  e2->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct       \
 
1885
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
1886
1886
 
1887
1887
  s_remote_initialized = 1;
1888
1888
}
1901
1901
  char* objectID = NULL;
1902
1902
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
1903
1903
  if(objectID) {
1904
 
    sidl_BaseInterface bi =                                                   \
1905
 
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(      \
 
1904
    sidl_BaseInterface bi = (                                                 \
 
1905
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(       \
1906
1906
      objectID, _ex);
1907
1907
    if(ar) {
1908
1908
      sidl_BaseInterface_addRef(bi, _ex);
1948
1948
/* Create an instance that uses an already existing  */
1949
1949
/* InstanceHandel to connect to an existing remote object. */
1950
1950
static struct bHYPRE_Solver__object*
1951
 
bHYPRE_Solver__IHConnect(sidl_rmi_InstanceHandle instance,                    \
1952
 
  sidl_BaseInterface *_ex)
 
1951
bHYPRE_Solver__IHConnect(sidl_rmi_InstanceHandle instance, sidl_BaseInterface \
 
1952
  *_ex)
1953
1953
{
1954
1954
  struct bHYPRE__Solver__object* self;
1955
1955
 
2004
2004
 
2005
2005
  *_ex = NULL;
2006
2006
  if(!connect_loaded) {
2007
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.Solver",                 \
2008
 
      (void*)bHYPRE_Solver__IHConnect, _ex);
 
2007
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.Solver", (               \
 
2008
      void*)bHYPRE_Solver__IHConnect, _ex);
2009
2009
    connect_loaded = 1;
2010
2010
  }
2011
2011
  if (obj != NULL) {
2026
2026
 */
2027
2027
 
2028
2028
struct bHYPRE_Solver__object*
2029
 
bHYPRE_Solver__connectI(const char* url, sidl_bool ar,                        \
2030
 
  struct sidl_BaseInterface__object **_ex)
 
2029
bHYPRE_Solver__connectI(const char* url, sidl_bool ar, struct                 \
 
2030
  sidl_BaseInterface__object **_ex)
2031
2031
{
2032
2032
  return bHYPRE_Solver__remoteConnect(url, ar, _ex);
2033
2033
}
2034
2034
 
2035
2035
static PyObject *
2036
 
pStub_Solver__connect(PyObject *_ignored, PyObject *_args,                    \
2037
 
  PyObject *_kwdict) {
 
2036
pStub_Solver__connect(PyObject *_ignored, PyObject *_args, PyObject *_kwdict) \
 
2037
  {
2038
2038
  PyObject *_return_value = NULL;
2039
2039
  struct bHYPRE_Solver__object* self = NULL;
2040
2040
  char* url = NULL;
2057
2057
      sidl_PyExceptionCast(_exception, "sidl.rmi.NetworkException"))) {
2058
2058
        struct sidl_BaseInterface__object *throwaway_exception;
2059
2059
        PyObject *_obj = sidl_rmi_NetworkException__wrap(_ex0);
2060
 
        PyObject *_args = PyTuple_New(1);
2061
 
        PyTuple_SetItem(_args, 0, _obj);
2062
 
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _args);
 
2060
        PyObject *_eargs = PyTuple_New(1);
 
2061
        PyTuple_SetItem(_eargs, 0, _obj);
 
2062
        _obj = PyObject_CallObject(sidl_rmi_NetworkException__type, _eargs);
2063
2063
        PyErr_SetObject(sidl_rmi_NetworkException__type, _obj);
2064
2064
        Py_XDECREF(_obj);
2065
2065
        (*(_exception->d_epv->f_deleteRef))(_exception->d_object,             \
2066
2066
          &throwaway_exception);
2067
 
        Py_XDECREF(_args);
 
2067
        Py_XDECREF(_eargs);
2068
2068
      }
2069
2069
    }
2070
2070
    else {
2079
2079
staticforward PyTypeObject _bHYPRE_SolverType;
2080
2080
 
2081
2081
static PyObject *
2082
 
pStub_Solver_GetNumIterations(PyObject *_self, PyObject *_args,               \
2083
 
  PyObject *_kwdict) {
 
2082
pStub_Solver_GetNumIterations(PyObject *_self, PyObject *_args, PyObject      \
 
2083
  *_kwdict) {
2084
2084
  PyObject *_return_value = NULL;
2085
2085
  struct bHYPRE_Solver__object *_self_ior =
2086
2086
    ((struct bHYPRE_Solver__object *)
2110
2110
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2111
2111
          struct sidl_BaseInterface__object *throwaway_exception;
2112
2112
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2113
 
          PyObject *_args = PyTuple_New(1);
2114
 
          PyTuple_SetItem(_args, 0, _obj);
2115
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2113
          PyObject *_eargs = PyTuple_New(1);
 
2114
          PyTuple_SetItem(_eargs, 0, _obj);
 
2115
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2116
2116
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2117
2117
          Py_XDECREF(_obj);
2118
2118
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2119
2119
            &throwaway_exception);
2120
 
          Py_XDECREF(_args);
 
2120
          Py_XDECREF(_eargs);
2121
2121
        }
2122
2122
      }
2123
2123
      else {
2141
2141
}
2142
2142
 
2143
2143
static PyObject *
2144
 
pStub_Solver_GetRelResidualNorm(PyObject *_self, PyObject *_args,             \
2145
 
  PyObject *_kwdict) {
 
2144
pStub_Solver_GetRelResidualNorm(PyObject *_self, PyObject *_args, PyObject    \
 
2145
  *_kwdict) {
2146
2146
  PyObject *_return_value = NULL;
2147
2147
  struct bHYPRE_Solver__object *_self_ior =
2148
2148
    ((struct bHYPRE_Solver__object *)
2161
2161
    if (_okay) {
2162
2162
      int32_t _return = (int32_t) 0;
2163
2163
      long _proxy__return;
2164
 
      _return =                                                               \
2165
 
        (*(_self_ior->d_epv->f_GetRelResidualNorm))(_self_ior->d_object,      \
2166
 
        &norm, &_exception);
 
2164
      _return = (*(_self_ior->d_epv->f_GetRelResidualNorm))(                  \
 
2165
        _self_ior->d_object, &norm, &_exception);
2167
2166
      _proxy__return = _return;
2168
2167
      if (_exception) {
2169
2168
        struct sidl_RuntimeException__object *_ex0;
2171
2170
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2172
2171
          struct sidl_BaseInterface__object *throwaway_exception;
2173
2172
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2174
 
          PyObject *_args = PyTuple_New(1);
2175
 
          PyTuple_SetItem(_args, 0, _obj);
2176
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2173
          PyObject *_eargs = PyTuple_New(1);
 
2174
          PyTuple_SetItem(_eargs, 0, _obj);
 
2175
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2177
2176
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2178
2177
          Py_XDECREF(_obj);
2179
2178
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2180
2179
            &throwaway_exception);
2181
 
          Py_XDECREF(_args);
 
2180
          Py_XDECREF(_eargs);
2182
2181
        }
2183
2182
      }
2184
2183
      else {
2234
2233
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2235
2234
          struct sidl_BaseInterface__object *throwaway_exception;
2236
2235
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2237
 
          PyObject *_args = PyTuple_New(1);
2238
 
          PyTuple_SetItem(_args, 0, _obj);
2239
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2236
          PyObject *_eargs = PyTuple_New(1);
 
2237
          PyTuple_SetItem(_eargs, 0, _obj);
 
2238
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2240
2239
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2241
2240
          Py_XDECREF(_obj);
2242
2241
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2243
2242
            &throwaway_exception);
2244
 
          Py_XDECREF(_args);
 
2243
          Py_XDECREF(_eargs);
2245
2244
        }
2246
2245
      }
2247
2246
      else {
2264
2263
}
2265
2264
 
2266
2265
static PyObject *
2267
 
pStub_Solver_SetMaxIterations(PyObject *_self, PyObject *_args,               \
2268
 
  PyObject *_kwdict) {
 
2266
pStub_Solver_SetMaxIterations(PyObject *_self, PyObject *_args, PyObject      \
 
2267
  *_kwdict) {
2269
2268
  PyObject *_return_value = NULL;
2270
2269
  struct bHYPRE_Solver__object *_self_ior =
2271
2270
    ((struct bHYPRE_Solver__object *)
2297
2296
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2298
2297
          struct sidl_BaseInterface__object *throwaway_exception;
2299
2298
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2300
 
          PyObject *_args = PyTuple_New(1);
2301
 
          PyTuple_SetItem(_args, 0, _obj);
2302
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2299
          PyObject *_eargs = PyTuple_New(1);
 
2300
          PyTuple_SetItem(_eargs, 0, _obj);
 
2301
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2303
2302
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2304
2303
          Py_XDECREF(_obj);
2305
2304
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2306
2305
            &throwaway_exception);
2307
 
          Py_XDECREF(_args);
 
2306
          Py_XDECREF(_eargs);
2308
2307
        }
2309
2308
      }
2310
2309
      else {
2327
2326
}
2328
2327
 
2329
2328
static PyObject *
2330
 
pStub_Solver_SetOperator(PyObject *_self, PyObject *_args,                    \
2331
 
  PyObject *_kwdict) {
 
2329
pStub_Solver_SetOperator(PyObject *_self, PyObject *_args, PyObject *_kwdict) \
 
2330
  {
2332
2331
  PyObject *_return_value = NULL;
2333
2332
  struct bHYPRE_Solver__object *_self_ior =
2334
2333
    ((struct bHYPRE_Solver__object *)
2358
2357
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2359
2358
          struct sidl_BaseInterface__object *throwaway_exception;
2360
2359
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2361
 
          PyObject *_args = PyTuple_New(1);
2362
 
          PyTuple_SetItem(_args, 0, _obj);
2363
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2360
          PyObject *_eargs = PyTuple_New(1);
 
2361
          PyTuple_SetItem(_eargs, 0, _obj);
 
2362
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2364
2363
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2365
2364
          Py_XDECREF(_obj);
2366
2365
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2367
2366
            &throwaway_exception);
2368
 
          Py_XDECREF(_args);
 
2367
          Py_XDECREF(_eargs);
2369
2368
        }
2370
2369
      }
2371
2370
      else {
2389
2388
}
2390
2389
 
2391
2390
static PyObject *
2392
 
pStub_Solver_SetPrintLevel(PyObject *_self, PyObject *_args,                  \
2393
 
  PyObject *_kwdict) {
 
2391
pStub_Solver_SetPrintLevel(PyObject *_self, PyObject *_args, PyObject         \
 
2392
  *_kwdict) {
2394
2393
  PyObject *_return_value = NULL;
2395
2394
  struct bHYPRE_Solver__object *_self_ior =
2396
2395
    ((struct bHYPRE_Solver__object *)
2422
2421
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2423
2422
          struct sidl_BaseInterface__object *throwaway_exception;
2424
2423
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2425
 
          PyObject *_args = PyTuple_New(1);
2426
 
          PyTuple_SetItem(_args, 0, _obj);
2427
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2424
          PyObject *_eargs = PyTuple_New(1);
 
2425
          PyTuple_SetItem(_eargs, 0, _obj);
 
2426
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2428
2427
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2429
2428
          Py_XDECREF(_obj);
2430
2429
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2431
2430
            &throwaway_exception);
2432
 
          Py_XDECREF(_args);
 
2431
          Py_XDECREF(_eargs);
2433
2432
        }
2434
2433
      }
2435
2434
      else {
2452
2451
}
2453
2452
 
2454
2453
static PyObject *
2455
 
pStub_Solver_SetTolerance(PyObject *_self, PyObject *_args,                   \
2456
 
  PyObject *_kwdict) {
 
2454
pStub_Solver_SetTolerance(PyObject *_self, PyObject *_args, PyObject          \
 
2455
  *_kwdict) {
2457
2456
  PyObject *_return_value = NULL;
2458
2457
  struct bHYPRE_Solver__object *_self_ior =
2459
2458
    ((struct bHYPRE_Solver__object *)
2483
2482
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2484
2483
          struct sidl_BaseInterface__object *throwaway_exception;
2485
2484
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2486
 
          PyObject *_args = PyTuple_New(1);
2487
 
          PyTuple_SetItem(_args, 0, _obj);
2488
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2485
          PyObject *_eargs = PyTuple_New(1);
 
2486
          PyTuple_SetItem(_eargs, 0, _obj);
 
2487
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2489
2488
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2490
2489
          Py_XDECREF(_obj);
2491
2490
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2492
2491
            &throwaway_exception);
2493
 
          Py_XDECREF(_args);
 
2492
          Py_XDECREF(_eargs);
2494
2493
        }
2495
2494
      }
2496
2495
      else {
2548
2547
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2549
2548
          struct sidl_BaseInterface__object *throwaway_exception;
2550
2549
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2551
 
          PyObject *_args = PyTuple_New(1);
2552
 
          PyTuple_SetItem(_args, 0, _obj);
2553
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2550
          PyObject *_eargs = PyTuple_New(1);
 
2551
          PyTuple_SetItem(_eargs, 0, _obj);
 
2552
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2554
2553
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2555
2554
          Py_XDECREF(_obj);
2556
2555
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2557
2556
            &throwaway_exception);
2558
 
          Py_XDECREF(_args);
 
2557
          Py_XDECREF(_eargs);
2559
2558
        }
2560
2559
      }
2561
2560
      else {
2604
2603
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2605
2604
          struct sidl_BaseInterface__object *throwaway_exception;
2606
2605
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2607
 
          PyObject *_args = PyTuple_New(1);
2608
 
          PyTuple_SetItem(_args, 0, _obj);
2609
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2606
          PyObject *_eargs = PyTuple_New(1);
 
2607
          PyTuple_SetItem(_eargs, 0, _obj);
 
2608
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2610
2609
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2611
2610
          Py_XDECREF(_obj);
2612
2611
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2613
2612
            &throwaway_exception);
2614
 
          Py_XDECREF(_args);
 
2613
          Py_XDECREF(_eargs);
2615
2614
        }
2616
2615
      }
2617
2616
      else {
2618
2617
        _return_value = Py_BuildValue(
2619
2618
          "z",
2620
2619
          _return);
 
2620
        free((void *)_return);
2621
2621
      }
2622
 
      free((void *)_return);
2623
2622
    }
2624
2623
    {
2625
2624
      struct sidl_BaseInterface__object *throwaway_exception;
2662
2661
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2663
2662
          struct sidl_BaseInterface__object *throwaway_exception;
2664
2663
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2665
 
          PyObject *_args = PyTuple_New(1);
2666
 
          PyTuple_SetItem(_args, 0, _obj);
2667
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2664
          PyObject *_eargs = PyTuple_New(1);
 
2665
          PyTuple_SetItem(_eargs, 0, _obj);
 
2666
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2668
2667
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2669
2668
          Py_XDECREF(_obj);
2670
2669
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2671
2670
            &throwaway_exception);
2672
 
          Py_XDECREF(_args);
 
2671
          Py_XDECREF(_eargs);
2673
2672
        }
2674
2673
      }
2675
2674
      else {
2719
2718
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2720
2719
          struct sidl_BaseInterface__object *throwaway_exception;
2721
2720
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2722
 
          PyObject *_args = PyTuple_New(1);
2723
 
          PyTuple_SetItem(_args, 0, _obj);
2724
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2721
          PyObject *_eargs = PyTuple_New(1);
 
2722
          PyTuple_SetItem(_eargs, 0, _obj);
 
2723
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2725
2724
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2726
2725
          Py_XDECREF(_obj);
2727
2726
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2728
2727
            &throwaway_exception);
2729
 
          Py_XDECREF(_args);
 
2728
          Py_XDECREF(_eargs);
2730
2729
        }
2731
2730
      }
2732
2731
      else {
2778
2777
        sidl_PyExceptionCast(_exception, "sidl.RuntimeException"))) {
2779
2778
          struct sidl_BaseInterface__object *throwaway_exception;
2780
2779
          PyObject *_obj = sidl_RuntimeException__wrap(_ex0);
2781
 
          PyObject *_args = PyTuple_New(1);
2782
 
          PyTuple_SetItem(_args, 0, _obj);
2783
 
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _args);
 
2780
          PyObject *_eargs = PyTuple_New(1);
 
2781
          PyTuple_SetItem(_eargs, 0, _obj);
 
2782
          _obj = PyObject_CallObject(sidl_RuntimeException__type, _eargs);
2784
2783
          PyErr_SetObject(sidl_RuntimeException__type, _obj);
2785
2784
          Py_XDECREF(_obj);
2786
2785
          (*(_exception->d_epv->f_deleteRef))(_exception->d_object,           \
2787
2786
            &throwaway_exception);
2788
 
          Py_XDECREF(_args);
 
2787
          Py_XDECREF(_eargs);
2789
2788
        }
2790
2789
      }
2791
2790
      else {
2810
2809
bHYPRE_Solver_createCast(PyObject *self, PyObject *args, PyObject *kwds) {
2811
2810
  struct bHYPRE_Solver__object *optarg = NULL;
2812
2811
  static char *_kwlist[] = { "sobj", NULL };
2813
 
  int _okay = PyArg_ParseTupleAndKeywords(args, kwds, "O&", _kwlist,          \
2814
 
    (void *)bHYPRE_Solver__convert, &optarg);
 
2812
  int _okay = PyArg_ParseTupleAndKeywords(args, kwds, "O&", _kwlist, (void    \
 
2813
    *)bHYPRE_Solver__convert, &optarg);
2815
2814
  if (_okay) {
2816
2815
    return sidl_Object_Init(
2817
2816
      (SPObject *)self,
3253
3252
  dict = PyModule_GetDict(module);
3254
3253
  ExternalAPI[bHYPRE_Solver__wrap_NUM] = (void*)bHYPRE_Solver__wrap;
3255
3254
  ExternalAPI[bHYPRE_Solver__convert_NUM] = (void*)bHYPRE_Solver__convert;
3256
 
  ExternalAPI[bHYPRE_Solver__convert_python_array_NUM] =                      \
3257
 
    (void*)bHYPRE_Solver__convert_python_array;
3258
 
  ExternalAPI[bHYPRE_Solver__convert_sidl_array_NUM] =                        \
3259
 
    (void*)bHYPRE_Solver__convert_sidl_array;
 
3255
  ExternalAPI[bHYPRE_Solver__convert_python_array_NUM] = (                    \
 
3256
    void*)bHYPRE_Solver__convert_python_array;
 
3257
  ExternalAPI[bHYPRE_Solver__convert_sidl_array_NUM] = (                      \
 
3258
    void*)bHYPRE_Solver__convert_sidl_array;
3260
3259
  ExternalAPI[bHYPRE_Solver__weakRef_NUM] = (void*)bHYPRE_Solver__weakRef;
3261
3260
  ExternalAPI[bHYPRE_Solver_deref_NUM] = (void*)bHYPRE_Solver_deref;
3262
3261
  ExternalAPI[bHYPRE_Solver__newRef_NUM] = (void*)bHYPRE_Solver__newRef;
3282
3281
  bHYPRE_Operator__import();
3283
3282
  _bHYPRE_SolverType.tp_base = bHYPRE_Operator_PyType();
3284
3283
  _bHYPRE_SolverType.tp_bases = PyTuple_New(1);
3285
 
  PyTuple_SetItem(_bHYPRE_SolverType.tp_bases,0,                              \
3286
 
    (PyObject *)bHYPRE_Operator_PyType());
 
3284
  PyTuple_SetItem(_bHYPRE_SolverType.tp_bases,0, (PyObject                    \
 
3285
    *)bHYPRE_Operator_PyType());
3287
3286
  if (PyType_Ready(&_bHYPRE_SolverType) < 0) {
3288
3287
    PyErr_Print();
3289
3288
    fprintf(stderr, "PyType_Ready on bHYPRE.Solver failed.\n");
3292
3291
  Py_INCREF(&_bHYPRE_SolverType);
3293
3292
  PyDict_SetItemString(dict, "Solver", (PyObject *)&_bHYPRE_SolverType);
3294
3293
 
3295
 
  sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.Solver",                   \
3296
 
    (void*)bHYPRE_Solver__IHConnect, &throwaway_exception);
 
3294
  sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.Solver", (                 \
 
3295
    void*)bHYPRE_Solver__IHConnect, &throwaway_exception);
3297
3296
}