← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/babel/bHYPRE/bHYPRE_IdentitySolver_Stub.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/bHYPRE/bHYPRE_IdentitySolver_Stub.c
2
2
 * File:          bHYPRE_IdentitySolver_Stub.c
3
3
 * Symbol:        bHYPRE.IdentitySolver-v1.0.0
4
4
 * Symbol Type:   class
5
 
 * Babel Version: 1.0.0
 
5
 * Babel Version: 1.0.4
6
6
 * Description:   Client-side glue code for bHYPRE.IdentitySolver
7
7
 * 
8
8
 * WARNING: Automatically generated; changes will be lost
59
59
#ifdef SIDL_STATIC_LIBRARY
60
60
  _externals = bHYPRE_IdentitySolver__externals();
61
61
#else
62
 
  _externals = (struct 
63
 
    bHYPRE_IdentitySolver__external*)sidl_dynamicLoadIOR(
 
62
  _externals = (struct bHYPRE_IdentitySolver__external*)sidl_dynamicLoadIOR(
64
63
    "bHYPRE.IdentitySolver","bHYPRE_IdentitySolver__externals") ;
65
64
  sidl_checkIORVersion("bHYPRE.IdentitySolver", _externals->d_ior_major_version,
66
 
    _externals->d_ior_minor_version, 0, 10);
 
65
    _externals->d_ior_minor_version, 1, 0);
67
66
#endif
68
67
  return _externals;
69
68
}
118
117
}
119
118
 
120
119
static struct bHYPRE_IdentitySolver__object* 
121
 
  bHYPRE_IdentitySolver__remoteConnect(const char* url, sidl_bool ar,
 
120
  bHYPRE_IdentitySolver__remoteConnect(const char* url, sidl_bool ar, 
122
121
  sidl_BaseInterface *_ex);
123
 
static struct bHYPRE_IdentitySolver__object* 
124
 
  bHYPRE_IdentitySolver__IHConnect(struct sidl_rmi_InstanceHandle__object* 
125
 
  instance, sidl_BaseInterface *_ex);
 
122
static struct bHYPRE_IdentitySolver__object* bHYPRE_IdentitySolver__IHConnect(
 
123
  struct sidl_rmi_InstanceHandle__object* instance, sidl_BaseInterface *_ex);
126
124
/*
127
125
 * RMI connector function for the class.
128
126
 */
134
132
}
135
133
 
136
134
/*
137
 
 * Method:  Create[]
 
135
 *  This function is the preferred way to create an Identity (null) solver. 
138
136
 */
139
137
 
140
138
bHYPRE_IdentitySolver
142
140
  /* in */ bHYPRE_MPICommunicator mpi_comm,
143
141
  /* out */ sidl_BaseInterface *_ex)
144
142
{
145
 
  return (_getSEPV()->f_Create)(
 
143
  bHYPRE_IdentitySolver _result;
 
144
  _result = (_getSEPV()->f_Create)(
146
145
    mpi_comm,
147
146
    _ex);
 
147
  return _result;
148
148
}
149
149
 
150
150
/*
213
213
  /* out */ sidl_BaseInterface *_ex)
214
214
#if SIDL_C_INLINE_REPEAT_DEFN
215
215
{
216
 
  return (*self->d_epv->f_isSame)(
 
216
  sidl_bool _result;
 
217
  _result = (*self->d_epv->f_isSame)(
217
218
    self,
218
219
    iobj,
219
220
    _ex);
 
221
  return _result;
220
222
}
221
223
#else /* ISO C 1999 inline semantics */
222
224
;
237
239
  /* out */ sidl_BaseInterface *_ex)
238
240
#if SIDL_C_INLINE_REPEAT_DEFN
239
241
{
240
 
  return (*self->d_epv->f_isType)(
 
242
  sidl_bool _result;
 
243
  _result = (*self->d_epv->f_isType)(
241
244
    self,
242
245
    name,
243
246
    _ex);
 
247
  return _result;
244
248
}
245
249
#else /* ISO C 1999 inline semantics */
246
250
;
257
261
  /* out */ sidl_BaseInterface *_ex)
258
262
#if SIDL_C_INLINE_REPEAT_DEFN
259
263
{
260
 
  return (*self->d_epv->f_getClassInfo)(
 
264
  sidl_ClassInfo _result;
 
265
  _result = (*self->d_epv->f_getClassInfo)(
261
266
    self,
262
267
    _ex);
 
268
  return _result;
263
269
}
264
270
#else /* ISO C 1999 inline semantics */
265
271
;
278
284
  /* out */ sidl_BaseInterface *_ex)
279
285
#if SIDL_C_INLINE_REPEAT_DEFN
280
286
{
281
 
  return (*self->d_epv->f_SetOperator)(
 
287
  int32_t _result;
 
288
  _result = (*self->d_epv->f_SetOperator)(
282
289
    self,
283
290
    A,
284
291
    _ex);
 
292
  return _result;
285
293
}
286
294
#else /* ISO C 1999 inline semantics */
287
295
;
300
308
  /* out */ sidl_BaseInterface *_ex)
301
309
#if SIDL_C_INLINE_REPEAT_DEFN
302
310
{
303
 
  return (*self->d_epv->f_SetTolerance)(
 
311
  int32_t _result;
 
312
  _result = (*self->d_epv->f_SetTolerance)(
304
313
    self,
305
314
    tolerance,
306
315
    _ex);
 
316
  return _result;
307
317
}
308
318
#else /* ISO C 1999 inline semantics */
309
319
;
322
332
  /* out */ sidl_BaseInterface *_ex)
323
333
#if SIDL_C_INLINE_REPEAT_DEFN
324
334
{
325
 
  return (*self->d_epv->f_SetMaxIterations)(
 
335
  int32_t _result;
 
336
  _result = (*self->d_epv->f_SetMaxIterations)(
326
337
    self,
327
338
    max_iterations,
328
339
    _ex);
 
340
  return _result;
329
341
}
330
342
#else /* ISO C 1999 inline semantics */
331
343
;
348
360
  /* out */ sidl_BaseInterface *_ex)
349
361
#if SIDL_C_INLINE_REPEAT_DEFN
350
362
{
351
 
  return (*self->d_epv->f_SetLogging)(
 
363
  int32_t _result;
 
364
  _result = (*self->d_epv->f_SetLogging)(
352
365
    self,
353
366
    level,
354
367
    _ex);
 
368
  return _result;
355
369
}
356
370
#else /* ISO C 1999 inline semantics */
357
371
;
374
388
  /* out */ sidl_BaseInterface *_ex)
375
389
#if SIDL_C_INLINE_REPEAT_DEFN
376
390
{
377
 
  return (*self->d_epv->f_SetPrintLevel)(
 
391
  int32_t _result;
 
392
  _result = (*self->d_epv->f_SetPrintLevel)(
378
393
    self,
379
394
    level,
380
395
    _ex);
 
396
  return _result;
381
397
}
382
398
#else /* ISO C 1999 inline semantics */
383
399
;
395
411
  /* out */ sidl_BaseInterface *_ex)
396
412
#if SIDL_C_INLINE_REPEAT_DEFN
397
413
{
398
 
  return (*self->d_epv->f_GetNumIterations)(
 
414
  int32_t _result;
 
415
  _result = (*self->d_epv->f_GetNumIterations)(
399
416
    self,
400
417
    num_iterations,
401
418
    _ex);
 
419
  return _result;
402
420
}
403
421
#else /* ISO C 1999 inline semantics */
404
422
;
416
434
  /* out */ sidl_BaseInterface *_ex)
417
435
#if SIDL_C_INLINE_REPEAT_DEFN
418
436
{
419
 
  return (*self->d_epv->f_GetRelResidualNorm)(
 
437
  int32_t _result;
 
438
  _result = (*self->d_epv->f_GetRelResidualNorm)(
420
439
    self,
421
440
    norm,
422
441
    _ex);
 
442
  return _result;
423
443
}
424
444
#else /* ISO C 1999 inline semantics */
425
445
;
438
458
  /* out */ sidl_BaseInterface *_ex)
439
459
#if SIDL_C_INLINE_REPEAT_DEFN
440
460
{
441
 
  return (*self->d_epv->f_SetCommunicator)(
 
461
  int32_t _result;
 
462
  _result = (*self->d_epv->f_SetCommunicator)(
442
463
    self,
443
464
    mpi_comm,
444
465
    _ex);
 
466
  return _result;
445
467
}
446
468
#else /* ISO C 1999 inline semantics */
447
469
;
482
504
  /* out */ sidl_BaseInterface *_ex)
483
505
#if SIDL_C_INLINE_REPEAT_DEFN
484
506
{
485
 
  return (*self->d_epv->f_SetIntParameter)(
 
507
  int32_t _result;
 
508
  _result = (*self->d_epv->f_SetIntParameter)(
486
509
    self,
487
510
    name,
488
511
    value,
489
512
    _ex);
 
513
  return _result;
490
514
}
491
515
#else /* ISO C 1999 inline semantics */
492
516
;
505
529
  /* out */ sidl_BaseInterface *_ex)
506
530
#if SIDL_C_INLINE_REPEAT_DEFN
507
531
{
508
 
  return (*self->d_epv->f_SetDoubleParameter)(
 
532
  int32_t _result;
 
533
  _result = (*self->d_epv->f_SetDoubleParameter)(
509
534
    self,
510
535
    name,
511
536
    value,
512
537
    _ex);
 
538
  return _result;
513
539
}
514
540
#else /* ISO C 1999 inline semantics */
515
541
;
528
554
  /* out */ sidl_BaseInterface *_ex)
529
555
#if SIDL_C_INLINE_REPEAT_DEFN
530
556
{
531
 
  return (*self->d_epv->f_SetStringParameter)(
 
557
  int32_t _result;
 
558
  _result = (*self->d_epv->f_SetStringParameter)(
532
559
    self,
533
560
    name,
534
561
    value,
535
562
    _ex);
 
563
  return _result;
536
564
}
537
565
#else /* ISO C 1999 inline semantics */
538
566
;
552
580
  /* out */ sidl_BaseInterface *_ex)
553
581
#if SIDL_C_INLINE_REPEAT_DEFN
554
582
{
 
583
  int32_t _result;
555
584
  int32_t value_lower[1], value_upper[1], value_stride[1]; 
556
585
  struct sidl_int__array value_real;
557
586
  struct sidl_int__array*value_tmp = &value_real;
558
587
  value_upper[0] = nvalues-1;
559
 
  sidl_int__array_init(value, value_tmp, 1, value_lower, value_upper,
 
588
  sidl_int__array_init(value, value_tmp, 1, value_lower, value_upper, 
560
589
    value_stride);
561
 
  return (*self->d_epv->f_SetIntArray1Parameter)(
 
590
  _result = (*self->d_epv->f_SetIntArray1Parameter)(
562
591
    self,
563
592
    name,
564
593
    value_tmp,
565
594
    _ex);
 
595
#ifdef SIDL_DEBUG_REFCOUNT
 
596
  sidl__array_deleteRef((struct sidl__array*)value_tmp);
 
597
#endif /* SIDL_DEBUG_REFCOUNT */
 
598
  return _result;
566
599
}
567
600
#else /* ISO C 1999 inline semantics */
568
601
;
581
614
  /* out */ sidl_BaseInterface *_ex)
582
615
#if SIDL_C_INLINE_REPEAT_DEFN
583
616
{
584
 
  return (*self->d_epv->f_SetIntArray2Parameter)(
 
617
  int32_t _result;
 
618
  _result = (*self->d_epv->f_SetIntArray2Parameter)(
585
619
    self,
586
620
    name,
587
621
    value,
588
622
    _ex);
 
623
  return _result;
589
624
}
590
625
#else /* ISO C 1999 inline semantics */
591
626
;
605
640
  /* out */ sidl_BaseInterface *_ex)
606
641
#if SIDL_C_INLINE_REPEAT_DEFN
607
642
{
 
643
  int32_t _result;
608
644
  int32_t value_lower[1], value_upper[1], value_stride[1]; 
609
645
  struct sidl_double__array value_real;
610
646
  struct sidl_double__array*value_tmp = &value_real;
611
647
  value_upper[0] = nvalues-1;
612
 
  sidl_double__array_init(value, value_tmp, 1, value_lower, value_upper,
 
648
  sidl_double__array_init(value, value_tmp, 1, value_lower, value_upper, 
613
649
    value_stride);
614
 
  return (*self->d_epv->f_SetDoubleArray1Parameter)(
 
650
  _result = (*self->d_epv->f_SetDoubleArray1Parameter)(
615
651
    self,
616
652
    name,
617
653
    value_tmp,
618
654
    _ex);
 
655
#ifdef SIDL_DEBUG_REFCOUNT
 
656
  sidl__array_deleteRef((struct sidl__array*)value_tmp);
 
657
#endif /* SIDL_DEBUG_REFCOUNT */
 
658
  return _result;
619
659
}
620
660
#else /* ISO C 1999 inline semantics */
621
661
;
634
674
  /* out */ sidl_BaseInterface *_ex)
635
675
#if SIDL_C_INLINE_REPEAT_DEFN
636
676
{
637
 
  return (*self->d_epv->f_SetDoubleArray2Parameter)(
 
677
  int32_t _result;
 
678
  _result = (*self->d_epv->f_SetDoubleArray2Parameter)(
638
679
    self,
639
680
    name,
640
681
    value,
641
682
    _ex);
 
683
  return _result;
642
684
}
643
685
#else /* ISO C 1999 inline semantics */
644
686
;
657
699
  /* out */ sidl_BaseInterface *_ex)
658
700
#if SIDL_C_INLINE_REPEAT_DEFN
659
701
{
660
 
  return (*self->d_epv->f_GetIntValue)(
 
702
  int32_t _result;
 
703
  _result = (*self->d_epv->f_GetIntValue)(
661
704
    self,
662
705
    name,
663
706
    value,
664
707
    _ex);
 
708
  return _result;
665
709
}
666
710
#else /* ISO C 1999 inline semantics */
667
711
;
680
724
  /* out */ sidl_BaseInterface *_ex)
681
725
#if SIDL_C_INLINE_REPEAT_DEFN
682
726
{
683
 
  return (*self->d_epv->f_GetDoubleValue)(
 
727
  int32_t _result;
 
728
  _result = (*self->d_epv->f_GetDoubleValue)(
684
729
    self,
685
730
    name,
686
731
    value,
687
732
    _ex);
 
733
  return _result;
688
734
}
689
735
#else /* ISO C 1999 inline semantics */
690
736
;
704
750
  /* out */ sidl_BaseInterface *_ex)
705
751
#if SIDL_C_INLINE_REPEAT_DEFN
706
752
{
707
 
  return (*self->d_epv->f_Setup)(
 
753
  int32_t _result;
 
754
  _result = (*self->d_epv->f_Setup)(
708
755
    self,
709
756
    b,
710
757
    x,
711
758
    _ex);
 
759
  return _result;
712
760
}
713
761
#else /* ISO C 1999 inline semantics */
714
762
;
727
775
  /* out */ sidl_BaseInterface *_ex)
728
776
#if SIDL_C_INLINE_REPEAT_DEFN
729
777
{
730
 
  return (*self->d_epv->f_Apply)(
 
778
  int32_t _result;
 
779
  _result = (*self->d_epv->f_Apply)(
731
780
    self,
732
781
    b,
733
782
    x,
734
783
    _ex);
 
784
  return _result;
735
785
}
736
786
#else /* ISO C 1999 inline semantics */
737
787
;
750
800
  /* out */ sidl_BaseInterface *_ex)
751
801
#if SIDL_C_INLINE_REPEAT_DEFN
752
802
{
753
 
  return (*self->d_epv->f_ApplyAdjoint)(
 
803
  int32_t _result;
 
804
  _result = (*self->d_epv->f_ApplyAdjoint)(
754
805
    self,
755
806
    b,
756
807
    x,
757
808
    _ex);
 
809
  return _result;
758
810
}
759
811
#else /* ISO C 1999 inline semantics */
760
812
;
773
825
 
774
826
  if(!connect_loaded) {
775
827
    connect_loaded = 1;
776
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.IdentitySolver",
777
 
      (void*)bHYPRE_IdentitySolver__IHConnect,_ex);SIDL_CHECK(*_ex);
 
828
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.IdentitySolver", (
 
829
      void*)bHYPRE_IdentitySolver__IHConnect,_ex);SIDL_CHECK(*_ex);
778
830
  }
779
831
  if (obj != NULL) {
780
832
    sidl_BaseInterface base = (sidl_BaseInterface) obj;
844
896
  /* out */ sidl_BaseInterface *_ex)
845
897
#if SIDL_C_INLINE_REPEAT_DEFN
846
898
{
847
 
  return (*self->d_epv->f__getURL)(
 
899
  char* _result;
 
900
  _result = (*self->d_epv->f__getURL)(
848
901
    self,
849
902
    _ex);
 
903
  return _result;
850
904
}
851
905
#else /* ISO C 1999 inline semantics */
852
906
;
919
973
  /* out */ sidl_BaseInterface *_ex)
920
974
#if SIDL_C_INLINE_REPEAT_DEFN
921
975
{
922
 
  return (*self->d_epv->f__isRemote)(
 
976
  sidl_bool _result;
 
977
  _result = (*self->d_epv->f__isRemote)(
923
978
    self,
924
979
    _ex);
 
980
  return _result;
925
981
}
926
982
#else /* ISO C 1999 inline semantics */
927
983
;
946
1002
  const int32_t lower[],
947
1003
  const int32_t upper[])
948
1004
{
949
 
  return (struct 
950
 
    bHYPRE_IdentitySolver__array*)sidl_interface__array_createCol(dimen, lower,
951
 
    upper);
 
1005
  return (struct bHYPRE_IdentitySolver__array*)sidl_interface__array_createCol(
 
1006
    dimen, lower, upper);
952
1007
}
953
1008
 
954
1009
struct bHYPRE_IdentitySolver__array*
957
1012
  const int32_t lower[],
958
1013
  const int32_t upper[])
959
1014
{
960
 
  return (struct 
961
 
    bHYPRE_IdentitySolver__array*)sidl_interface__array_createRow(dimen, lower,
962
 
    upper);
 
1015
  return (struct bHYPRE_IdentitySolver__array*)sidl_interface__array_createRow(
 
1016
    dimen, lower, upper);
963
1017
}
964
1018
 
965
1019
struct bHYPRE_IdentitySolver__array*
966
1020
bHYPRE_IdentitySolver__array_create1d(int32_t len)
967
1021
{
968
 
  return (struct 
969
 
    bHYPRE_IdentitySolver__array*)sidl_interface__array_create1d(len);
 
1022
  return (struct bHYPRE_IdentitySolver__array*)sidl_interface__array_create1d(
 
1023
    len);
970
1024
}
971
1025
 
972
1026
struct bHYPRE_IdentitySolver__array*
975
1029
  bHYPRE_IdentitySolver* data)
976
1030
{
977
1031
  return (struct 
978
 
    bHYPRE_IdentitySolver__array*)sidl_interface__array_create1dInit(len,
979
 
    (struct sidl_BaseInterface__object **)data);
 
1032
    bHYPRE_IdentitySolver__array*)sidl_interface__array_create1dInit(len, (
 
1033
    struct sidl_BaseInterface__object **)data);
980
1034
}
981
1035
 
982
1036
struct bHYPRE_IdentitySolver__array*
1125
1179
  const int32_t indices[])
1126
1180
{
1127
1181
  return (bHYPRE_IdentitySolver)
1128
 
    sidl_interface__array_get((const struct sidl_interface__array *)array,
 
1182
    sidl_interface__array_get((const struct sidl_interface__array *)array, 
1129
1183
      indices);
1130
1184
}
1131
1185
 
1226
1280
  const int32_t indices[],
1227
1281
  bHYPRE_IdentitySolver const value)
1228
1282
{
1229
 
  sidl_interface__array_set((struct sidl_interface__array *)array, indices,
1230
 
    (struct sidl_BaseInterface__object *)value);
 
1283
  sidl_interface__array_set((struct sidl_interface__array *)array, indices, (
 
1284
    struct sidl_BaseInterface__object *)value);
1231
1285
}
1232
1286
 
1233
1287
int32_t
1242
1296
  const struct bHYPRE_IdentitySolver__array* array,
1243
1297
  const int32_t ind)
1244
1298
{
1245
 
  return sidl_interface__array_lower((struct sidl_interface__array *)array,
 
1299
  return sidl_interface__array_lower((struct sidl_interface__array *)array, 
1246
1300
    ind);
1247
1301
}
1248
1302
 
1251
1305
  const struct bHYPRE_IdentitySolver__array* array,
1252
1306
  const int32_t ind)
1253
1307
{
1254
 
  return sidl_interface__array_upper((struct sidl_interface__array *)array,
 
1308
  return sidl_interface__array_upper((struct sidl_interface__array *)array, 
1255
1309
    ind);
1256
1310
}
1257
1311
 
1260
1314
  const struct bHYPRE_IdentitySolver__array* array,
1261
1315
  const int32_t ind)
1262
1316
{
1263
 
  return sidl_interface__array_length((struct sidl_interface__array *)array,
 
1317
  return sidl_interface__array_length((struct sidl_interface__array *)array, 
1264
1318
    ind);
1265
1319
}
1266
1320
 
1269
1323
  const struct bHYPRE_IdentitySolver__array* array,
1270
1324
  const int32_t ind)
1271
1325
{
1272
 
  return sidl_interface__array_stride((struct sidl_interface__array *)array,
 
1326
  return sidl_interface__array_stride((struct sidl_interface__array *)array, 
1273
1327
    ind);
1274
1328
}
1275
1329
 
1319
1373
  int     ordering)
1320
1374
{
1321
1375
  return (struct bHYPRE_IdentitySolver__array*)
1322
 
    sidl_interface__array_ensure((struct sidl_interface__array *)src, dimen,
 
1376
    sidl_interface__array_ensure((struct sidl_interface__array *)src, dimen, 
1323
1377
      ordering);
1324
1378
}
1325
1379
 
1374
1428
#endif
1375
1429
 
1376
1430
/* Static variables to hold version of IOR */
1377
 
static const int32_t s_IOR_MAJOR_VERSION = 0;
1378
 
static const int32_t s_IOR_MINOR_VERSION = 10;
 
1431
static const int32_t s_IOR_MAJOR_VERSION = 1;
 
1432
static const int32_t s_IOR_MINOR_VERSION = 0;
1379
1433
 
1380
1434
/* Static variables for managing EPV initialization. */
1381
1435
static int s_remote_initialized = 0;
1419
1473
      cmp2 = strcmp(name, "bHYPRE.IdentitySolver");
1420
1474
      if (!cmp2) {
1421
1475
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
1422
 
        cast = self;
 
1476
        cast = ((struct bHYPRE_IdentitySolver__object*)self);
1423
1477
        return cast;
1424
1478
      }
1425
1479
    }
1435
1489
      cmp2 = strcmp(name, "sidl.BaseClass");
1436
1490
      if (!cmp2) {
1437
1491
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
1438
 
        cast = self;
 
1492
        cast = ((struct sidl_BaseClass__object*)self);
1439
1493
        return cast;
1440
1494
      }
1441
1495
    }
1442
1496
  }
1443
1497
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
1444
 
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,
1445
 
      struct sidl_BaseInterface__object**) = 
1446
 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,
1447
 
        struct sidl_BaseInterface__object**)) 
 
1498
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1499
      sidl_BaseInterface__object**) = 
 
1500
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1501
        sidl_BaseInterface__object**)) 
1448
1502
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
1449
1503
    cast =  (*func)(((struct bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih,
1450
1504
      _ex);
1487
1541
  struct sidl_rmi_InstanceHandle__object *_conn = ((struct 
1488
1542
    bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
1489
1543
  sidl_rmi_Response _rsvp = NULL;
1490
 
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1544
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1491
1545
    "addRef", _ex ); SIDL_CHECK(*_ex);
1492
1546
  /* send actual RMI request */
1493
1547
  _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
1532
1586
    sidl_rmi_Response _rsvp = NULL;
1533
1587
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1534
1588
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
1535
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1589
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1536
1590
      "_set_hooks", _ex ); SIDL_CHECK(*_ex);
1537
1591
 
1538
1592
    /* pack in and inout arguments */
1626
1680
    sidl_bool _retval = FALSE;
1627
1681
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1628
1682
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
1629
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1683
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1630
1684
      "isSame", _ex ); SIDL_CHECK(*_ex);
1631
1685
 
1632
1686
    /* pack in and inout arguments */
1633
1687
    if(iobj){
1634
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,
 
1688
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj, 
1635
1689
        _ex);SIDL_CHECK(*_ex);
1636
1690
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(*_ex);
1637
1691
      free((void*)_url);
1652
1706
    }
1653
1707
 
1654
1708
    /* extract return value */
1655
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1656
 
      _ex);SIDL_CHECK(*_ex);
 
1709
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1710
      *_ex);
1657
1711
 
1658
1712
    /* unpack out and inout arguments */
1659
1713
 
1682
1736
    sidl_bool _retval = FALSE;
1683
1737
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1684
1738
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
1685
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1739
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1686
1740
      "isType", _ex ); SIDL_CHECK(*_ex);
1687
1741
 
1688
1742
    /* pack in and inout arguments */
1701
1755
    }
1702
1756
 
1703
1757
    /* extract return value */
1704
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1705
 
      _ex);SIDL_CHECK(*_ex);
 
1758
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1759
      *_ex);
1706
1760
 
1707
1761
    /* unpack out and inout arguments */
1708
1762
 
1731
1785
    struct sidl_ClassInfo__object* _retval = 0;
1732
1786
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1733
1787
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
1734
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1788
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1735
1789
      "getClassInfo", _ex ); SIDL_CHECK(*_ex);
1736
1790
 
1737
1791
    /* pack in and inout arguments */
1749
1803
    }
1750
1804
 
1751
1805
    /* extract return value */
1752
 
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
1753
 
      _ex);SIDL_CHECK(*_ex);
1754
 
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,
1755
 
      _ex);SIDL_CHECK(*_ex);
 
1806
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
1807
      _ex);SIDL_CHECK(*_ex);
 
1808
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
1809
      *_ex);
1756
1810
 
1757
1811
    /* unpack out and inout arguments */
1758
1812
 
1781
1835
    int32_t _retval = 0;
1782
1836
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1783
1837
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
1784
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1838
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1785
1839
      "SetOperator", _ex ); SIDL_CHECK(*_ex);
1786
1840
 
1787
1841
    /* pack in and inout arguments */
1788
1842
    if(A){
1789
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)A,
 
1843
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)A, 
1790
1844
        _ex);SIDL_CHECK(*_ex);
1791
1845
      sidl_rmi_Invocation_packString( _inv, "A", _url, _ex);SIDL_CHECK(*_ex);
1792
1846
      free((void*)_url);
1807
1861
    }
1808
1862
 
1809
1863
    /* extract return value */
1810
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1811
 
      _ex);SIDL_CHECK(*_ex);
 
1864
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1865
      *_ex);
1812
1866
 
1813
1867
    /* unpack out and inout arguments */
1814
1868
 
1837
1891
    int32_t _retval = 0;
1838
1892
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1839
1893
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
1840
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1894
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1841
1895
      "SetTolerance", _ex ); SIDL_CHECK(*_ex);
1842
1896
 
1843
1897
    /* pack in and inout arguments */
1844
 
    sidl_rmi_Invocation_packDouble( _inv, "tolerance", tolerance,
 
1898
    sidl_rmi_Invocation_packDouble( _inv, "tolerance", tolerance, 
1845
1899
      _ex);SIDL_CHECK(*_ex);
1846
1900
 
1847
1901
    /* send actual RMI request */
1857
1911
    }
1858
1912
 
1859
1913
    /* extract return value */
1860
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1861
 
      _ex);SIDL_CHECK(*_ex);
 
1914
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1915
      *_ex);
1862
1916
 
1863
1917
    /* unpack out and inout arguments */
1864
1918
 
1887
1941
    int32_t _retval = 0;
1888
1942
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1889
1943
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
1890
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1944
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1891
1945
      "SetMaxIterations", _ex ); SIDL_CHECK(*_ex);
1892
1946
 
1893
1947
    /* pack in and inout arguments */
1894
 
    sidl_rmi_Invocation_packInt( _inv, "max_iterations", max_iterations,
 
1948
    sidl_rmi_Invocation_packInt( _inv, "max_iterations", max_iterations, 
1895
1949
      _ex);SIDL_CHECK(*_ex);
1896
1950
 
1897
1951
    /* send actual RMI request */
1907
1961
    }
1908
1962
 
1909
1963
    /* extract return value */
1910
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1911
 
      _ex);SIDL_CHECK(*_ex);
 
1964
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1965
      *_ex);
1912
1966
 
1913
1967
    /* unpack out and inout arguments */
1914
1968
 
1937
1991
    int32_t _retval = 0;
1938
1992
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1939
1993
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
1940
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1994
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1941
1995
      "SetLogging", _ex ); SIDL_CHECK(*_ex);
1942
1996
 
1943
1997
    /* pack in and inout arguments */
1956
2010
    }
1957
2011
 
1958
2012
    /* extract return value */
1959
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1960
 
      _ex);SIDL_CHECK(*_ex);
 
2013
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2014
      *_ex);
1961
2015
 
1962
2016
    /* unpack out and inout arguments */
1963
2017
 
1986
2040
    int32_t _retval = 0;
1987
2041
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1988
2042
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
1989
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2043
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1990
2044
      "SetPrintLevel", _ex ); SIDL_CHECK(*_ex);
1991
2045
 
1992
2046
    /* pack in and inout arguments */
2005
2059
    }
2006
2060
 
2007
2061
    /* extract return value */
2008
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2009
 
      _ex);SIDL_CHECK(*_ex);
 
2062
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2063
      *_ex);
2010
2064
 
2011
2065
    /* unpack out and inout arguments */
2012
2066
 
2035
2089
    int32_t _retval = 0;
2036
2090
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2037
2091
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2038
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2092
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2039
2093
      "GetNumIterations", _ex ); SIDL_CHECK(*_ex);
2040
2094
 
2041
2095
    /* pack in and inout arguments */
2053
2107
    }
2054
2108
 
2055
2109
    /* extract return value */
2056
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2057
 
      _ex);SIDL_CHECK(*_ex);
 
2110
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2111
      *_ex);
2058
2112
 
2059
2113
    /* unpack out and inout arguments */
2060
 
    sidl_rmi_Response_unpackInt( _rsvp, "num_iterations", num_iterations,
 
2114
    sidl_rmi_Response_unpackInt( _rsvp, "num_iterations", num_iterations, 
2061
2115
      _ex);SIDL_CHECK(*_ex);
2062
2116
 
2063
2117
    /* cleanup and return */
2085
2139
    int32_t _retval = 0;
2086
2140
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2087
2141
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2088
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2142
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2089
2143
      "GetRelResidualNorm", _ex ); SIDL_CHECK(*_ex);
2090
2144
 
2091
2145
    /* pack in and inout arguments */
2103
2157
    }
2104
2158
 
2105
2159
    /* extract return value */
2106
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2107
 
      _ex);SIDL_CHECK(*_ex);
 
2160
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2161
      *_ex);
2108
2162
 
2109
2163
    /* unpack out and inout arguments */
2110
2164
    sidl_rmi_Response_unpackDouble( _rsvp, "norm", norm, _ex);SIDL_CHECK(*_ex);
2134
2188
    int32_t _retval = 0;
2135
2189
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2136
2190
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2137
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2191
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2138
2192
      "SetCommunicator", _ex ); SIDL_CHECK(*_ex);
2139
2193
 
2140
2194
    /* pack in and inout arguments */
2141
2195
    if(mpi_comm){
2142
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm,
2143
 
        _ex);SIDL_CHECK(*_ex);
2144
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url,
2145
 
        _ex);SIDL_CHECK(*_ex);
 
2196
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm, 
 
2197
        _ex);SIDL_CHECK(*_ex);
 
2198
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url, _ex);SIDL_CHECK(
 
2199
        *_ex);
2146
2200
      free((void*)_url);
2147
2201
    } else {
2148
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL,
2149
 
        _ex);SIDL_CHECK(*_ex);
 
2202
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL, _ex);SIDL_CHECK(
 
2203
        *_ex);
2150
2204
    }
2151
2205
 
2152
2206
    /* send actual RMI request */
2162
2216
    }
2163
2217
 
2164
2218
    /* extract return value */
2165
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2166
 
      _ex);SIDL_CHECK(*_ex);
 
2219
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2220
      *_ex);
2167
2221
 
2168
2222
    /* unpack out and inout arguments */
2169
2223
 
2190
2244
    sidl_rmi_Response _rsvp = NULL;
2191
2245
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2192
2246
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2193
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2247
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2194
2248
      "Destroy", _ex ); SIDL_CHECK(*_ex);
2195
2249
 
2196
2250
    /* pack in and inout arguments */
2235
2289
    int32_t _retval = 0;
2236
2290
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2237
2291
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2238
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2292
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2239
2293
      "SetIntParameter", _ex ); SIDL_CHECK(*_ex);
2240
2294
 
2241
2295
    /* pack in and inout arguments */
2255
2309
    }
2256
2310
 
2257
2311
    /* extract return value */
2258
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2259
 
      _ex);SIDL_CHECK(*_ex);
 
2312
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2313
      *_ex);
2260
2314
 
2261
2315
    /* unpack out and inout arguments */
2262
2316
 
2286
2340
    int32_t _retval = 0;
2287
2341
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2288
2342
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2289
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2343
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2290
2344
      "SetDoubleParameter", _ex ); SIDL_CHECK(*_ex);
2291
2345
 
2292
2346
    /* pack in and inout arguments */
2306
2360
    }
2307
2361
 
2308
2362
    /* extract return value */
2309
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2310
 
      _ex);SIDL_CHECK(*_ex);
 
2363
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2364
      *_ex);
2311
2365
 
2312
2366
    /* unpack out and inout arguments */
2313
2367
 
2337
2391
    int32_t _retval = 0;
2338
2392
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2339
2393
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2340
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2394
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2341
2395
      "SetStringParameter", _ex ); SIDL_CHECK(*_ex);
2342
2396
 
2343
2397
    /* pack in and inout arguments */
2357
2411
    }
2358
2412
 
2359
2413
    /* extract return value */
2360
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2361
 
      _ex);SIDL_CHECK(*_ex);
 
2414
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2415
      *_ex);
2362
2416
 
2363
2417
    /* unpack out and inout arguments */
2364
2418
 
2388
2442
    int32_t _retval = 0;
2389
2443
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2390
2444
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2391
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2445
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2392
2446
      "SetIntArray1Parameter", _ex ); SIDL_CHECK(*_ex);
2393
2447
 
2394
2448
    /* pack in and inout arguments */
2409
2463
    }
2410
2464
 
2411
2465
    /* extract return value */
2412
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2413
 
      _ex);SIDL_CHECK(*_ex);
 
2466
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2467
      *_ex);
2414
2468
 
2415
2469
    /* unpack out and inout arguments */
2416
2470
 
2440
2494
    int32_t _retval = 0;
2441
2495
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2442
2496
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2443
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2497
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2444
2498
      "SetIntArray2Parameter", _ex ); SIDL_CHECK(*_ex);
2445
2499
 
2446
2500
    /* pack in and inout arguments */
2461
2515
    }
2462
2516
 
2463
2517
    /* extract return value */
2464
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2465
 
      _ex);SIDL_CHECK(*_ex);
 
2518
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2519
      *_ex);
2466
2520
 
2467
2521
    /* unpack out and inout arguments */
2468
2522
 
2492
2546
    int32_t _retval = 0;
2493
2547
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2494
2548
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2495
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2549
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2496
2550
      "SetDoubleArray1Parameter", _ex ); SIDL_CHECK(*_ex);
2497
2551
 
2498
2552
    /* pack in and inout arguments */
2513
2567
    }
2514
2568
 
2515
2569
    /* extract return value */
2516
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2517
 
      _ex);SIDL_CHECK(*_ex);
 
2570
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2571
      *_ex);
2518
2572
 
2519
2573
    /* unpack out and inout arguments */
2520
2574
 
2544
2598
    int32_t _retval = 0;
2545
2599
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2546
2600
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2547
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2601
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2548
2602
      "SetDoubleArray2Parameter", _ex ); SIDL_CHECK(*_ex);
2549
2603
 
2550
2604
    /* pack in and inout arguments */
2565
2619
    }
2566
2620
 
2567
2621
    /* extract return value */
2568
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2569
 
      _ex);SIDL_CHECK(*_ex);
 
2622
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2623
      *_ex);
2570
2624
 
2571
2625
    /* unpack out and inout arguments */
2572
2626
 
2596
2650
    int32_t _retval = 0;
2597
2651
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2598
2652
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2599
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2653
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2600
2654
      "GetIntValue", _ex ); SIDL_CHECK(*_ex);
2601
2655
 
2602
2656
    /* pack in and inout arguments */
2615
2669
    }
2616
2670
 
2617
2671
    /* extract return value */
2618
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2619
 
      _ex);SIDL_CHECK(*_ex);
 
2672
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2673
      *_ex);
2620
2674
 
2621
2675
    /* unpack out and inout arguments */
2622
2676
    sidl_rmi_Response_unpackInt( _rsvp, "value", value, _ex);SIDL_CHECK(*_ex);
2647
2701
    int32_t _retval = 0;
2648
2702
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2649
2703
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2650
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2704
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2651
2705
      "GetDoubleValue", _ex ); SIDL_CHECK(*_ex);
2652
2706
 
2653
2707
    /* pack in and inout arguments */
2666
2720
    }
2667
2721
 
2668
2722
    /* extract return value */
2669
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2670
 
      _ex);SIDL_CHECK(*_ex);
 
2723
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2724
      *_ex);
2671
2725
 
2672
2726
    /* unpack out and inout arguments */
2673
 
    sidl_rmi_Response_unpackDouble( _rsvp, "value", value,
2674
 
      _ex);SIDL_CHECK(*_ex);
 
2727
    sidl_rmi_Response_unpackDouble( _rsvp, "value", value, _ex);SIDL_CHECK(
 
2728
      *_ex);
2675
2729
 
2676
2730
    /* cleanup and return */
2677
2731
    EXIT:
2699
2753
    int32_t _retval = 0;
2700
2754
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2701
2755
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2702
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2756
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2703
2757
      "Setup", _ex ); SIDL_CHECK(*_ex);
2704
2758
 
2705
2759
    /* pack in and inout arguments */
2706
2760
    if(b){
2707
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
2761
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
2708
2762
        _ex);SIDL_CHECK(*_ex);
2709
2763
      sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
2710
2764
      free((void*)_url);
2712
2766
      sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
2713
2767
    }
2714
2768
    if(x){
2715
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)x,
 
2769
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)x, 
2716
2770
        _ex);SIDL_CHECK(*_ex);
2717
2771
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
2718
2772
      free((void*)_url);
2733
2787
    }
2734
2788
 
2735
2789
    /* extract return value */
2736
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2737
 
      _ex);SIDL_CHECK(*_ex);
 
2790
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2791
      *_ex);
2738
2792
 
2739
2793
    /* unpack out and inout arguments */
2740
2794
 
2765
2819
    int32_t _retval = 0;
2766
2820
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2767
2821
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2768
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2822
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2769
2823
      "Apply", _ex ); SIDL_CHECK(*_ex);
2770
2824
 
2771
2825
    /* pack in and inout arguments */
2772
2826
    if(b){
2773
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
2827
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
2774
2828
        _ex);SIDL_CHECK(*_ex);
2775
2829
      sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
2776
2830
      free((void*)_url);
2778
2832
      sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
2779
2833
    }
2780
2834
    if(*x){
2781
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x,
 
2835
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x, 
2782
2836
        _ex);SIDL_CHECK(*_ex);
2783
2837
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
2784
2838
      free((void*)_url);
2790
2844
      SIDL_CHECK(*_ex);
2791
2845
      (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((
2792
2846
        sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
2793
 
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,
2794
 
        _ex);SIDL_CHECK(*_ex); 
 
2847
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(
 
2848
        *_ex); 
2795
2849
    }
2796
2850
 
2797
2851
    /* send actual RMI request */
2807
2861
    }
2808
2862
 
2809
2863
    /* extract return value */
2810
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2811
 
      _ex);SIDL_CHECK(*_ex);
 
2864
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2865
      *_ex);
2812
2866
 
2813
2867
    /* unpack out and inout arguments */
2814
2868
    sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
2841
2895
    int32_t _retval = 0;
2842
2896
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2843
2897
      bHYPRE_IdentitySolver__remote*)self->d_data)->d_ih;
2844
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2898
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2845
2899
      "ApplyAdjoint", _ex ); SIDL_CHECK(*_ex);
2846
2900
 
2847
2901
    /* pack in and inout arguments */
2848
2902
    if(b){
2849
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
2903
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
2850
2904
        _ex);SIDL_CHECK(*_ex);
2851
2905
      sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
2852
2906
      free((void*)_url);
2854
2908
      sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
2855
2909
    }
2856
2910
    if(*x){
2857
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x,
 
2911
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x, 
2858
2912
        _ex);SIDL_CHECK(*_ex);
2859
2913
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
2860
2914
      free((void*)_url);
2866
2920
      SIDL_CHECK(*_ex);
2867
2921
      (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((
2868
2922
        sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
2869
 
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,
2870
 
        _ex);SIDL_CHECK(*_ex); 
 
2923
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(
 
2924
        *_ex); 
2871
2925
    }
2872
2926
 
2873
2927
    /* send actual RMI request */
2883
2937
    }
2884
2938
 
2885
2939
    /* extract return value */
2886
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2887
 
      _ex);SIDL_CHECK(*_ex);
 
2940
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2941
      *_ex);
2888
2942
 
2889
2943
    /* unpack out and inout arguments */
2890
2944
    sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
2967
3021
 
2968
3022
  e0->f__cast                    = (void* (*)(void*,const char*,
2969
3023
    sidl_BaseInterface*)) epv->f__cast;
2970
 
  e0->f__delete                  = (void (*)(void*,
2971
 
    sidl_BaseInterface*)) epv->f__delete;
2972
 
  e0->f__getURL                  = (char* (*)(void*,
2973
 
    sidl_BaseInterface*)) epv->f__getURL;
2974
 
  e0->f__raddRef                 = (void (*)(void*,
2975
 
    sidl_BaseInterface*)) epv->f__raddRef;
2976
 
  e0->f__isRemote                = (sidl_bool (*)(void*,
2977
 
    sidl_BaseInterface*)) epv->f__isRemote;
2978
 
  e0->f__set_hooks               = (void (*)(void*,int32_t,
 
3024
  e0->f__delete                  = (void (*)(void*,sidl_BaseInterface*)) 
 
3025
    epv->f__delete;
 
3026
  e0->f__getURL                  = (char* (*)(void*,sidl_BaseInterface*)) 
 
3027
    epv->f__getURL;
 
3028
  e0->f__raddRef                 = (void (*)(void*,sidl_BaseInterface*)) 
 
3029
    epv->f__raddRef;
 
3030
  e0->f__isRemote                = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
3031
    epv->f__isRemote;
 
3032
  e0->f__set_hooks               = (void (*)(void*,int32_t, 
2979
3033
    sidl_BaseInterface*)) epv->f__set_hooks;
2980
 
  e0->f__exec                    = (void (*)(void*,const char*,
2981
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2982
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
2983
 
  e0->f_SetCommunicator          = (int32_t (*)(void*,
2984
 
    struct bHYPRE_MPICommunicator__object*,
2985
 
    struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
2986
 
  e0->f_Destroy                  = (void (*)(void*,
2987
 
    struct sidl_BaseInterface__object **)) epv->f_Destroy;
 
3034
  e0->f__exec                    = (void (*)(void*,const char*,struct 
 
3035
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3036
    sidl_BaseInterface__object **)) epv->f__exec;
 
3037
  e0->f_SetCommunicator          = (int32_t (*)(void*,struct 
 
3038
    bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
3039
    epv->f_SetCommunicator;
 
3040
  e0->f_Destroy                  = (void (*)(void*,struct 
 
3041
    sidl_BaseInterface__object **)) epv->f_Destroy;
2988
3042
  e0->f_SetIntParameter          = (int32_t (*)(void*,const char*,int32_t,
2989
3043
    struct sidl_BaseInterface__object **)) epv->f_SetIntParameter;
2990
 
  e0->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,
2991
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
 
3044
  e0->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,struct 
 
3045
    sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
2992
3046
  e0->f_SetStringParameter       = (int32_t (*)(void*,const char*,const char*,
2993
3047
    struct sidl_BaseInterface__object **)) epv->f_SetStringParameter;
2994
 
  e0->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,
2995
 
    struct sidl_int__array*,
2996
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray1Parameter;
2997
 
  e0->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,
2998
 
    struct sidl_int__array*,
2999
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray2Parameter;
3000
 
  e0->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,
3001
 
    struct sidl_double__array*,
3002
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray1Parameter;
3003
 
  e0->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,
3004
 
    struct sidl_double__array*,
3005
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray2Parameter;
 
3048
  e0->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,struct 
 
3049
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3050
    epv->f_SetIntArray1Parameter;
 
3051
  e0->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,struct 
 
3052
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3053
    epv->f_SetIntArray2Parameter;
 
3054
  e0->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,struct 
 
3055
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3056
    epv->f_SetDoubleArray1Parameter;
 
3057
  e0->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,struct 
 
3058
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3059
    epv->f_SetDoubleArray2Parameter;
3006
3060
  e0->f_GetIntValue              = (int32_t (*)(void*,const char*,int32_t*,
3007
3061
    struct sidl_BaseInterface__object **)) epv->f_GetIntValue;
3008
3062
  e0->f_GetDoubleValue           = (int32_t (*)(void*,const char*,double*,
3009
3063
    struct sidl_BaseInterface__object **)) epv->f_GetDoubleValue;
3010
 
  e0->f_Setup                    = (int32_t (*)(void*,
3011
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,
3012
 
    struct sidl_BaseInterface__object **)) epv->f_Setup;
3013
 
  e0->f_Apply                    = (int32_t (*)(void*,
3014
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3015
 
    struct sidl_BaseInterface__object **)) epv->f_Apply;
3016
 
  e0->f_ApplyAdjoint             = (int32_t (*)(void*,
3017
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3018
 
    struct sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
3019
 
  e0->f_addRef                   = (void (*)(void*,
3020
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3021
 
  e0->f_deleteRef                = (void (*)(void*,
3022
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
3023
 
  e0->f_isSame                   = (sidl_bool (*)(void*,
3024
 
    struct sidl_BaseInterface__object*,
3025
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3026
 
  e0->f_isType                   = (sidl_bool (*)(void*,const char*,
3027
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
3064
  e0->f_Setup                    = (int32_t (*)(void*,struct 
 
3065
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,struct 
 
3066
    sidl_BaseInterface__object **)) epv->f_Setup;
 
3067
  e0->f_Apply                    = (int32_t (*)(void*,struct 
 
3068
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3069
    sidl_BaseInterface__object **)) epv->f_Apply;
 
3070
  e0->f_ApplyAdjoint             = (int32_t (*)(void*,struct 
 
3071
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3072
    sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
 
3073
  e0->f_addRef                   = (void (*)(void*,struct 
 
3074
    sidl_BaseInterface__object **)) epv->f_addRef;
 
3075
  e0->f_deleteRef                = (void (*)(void*,struct 
 
3076
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3077
  e0->f_isSame                   = (sidl_bool (*)(void*,struct 
 
3078
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
3079
    epv->f_isSame;
 
3080
  e0->f_isType                   = (sidl_bool (*)(void*,const char*,struct 
 
3081
    sidl_BaseInterface__object **)) epv->f_isType;
3028
3082
  e0->f_getClassInfo             = (struct sidl_ClassInfo__object* (*)(void*,
3029
3083
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
3030
3084
 
3031
3085
  e1->f__cast                    = (void* (*)(void*,const char*,
3032
3086
    sidl_BaseInterface*)) epv->f__cast;
3033
 
  e1->f__delete                  = (void (*)(void*,
3034
 
    sidl_BaseInterface*)) epv->f__delete;
3035
 
  e1->f__getURL                  = (char* (*)(void*,
3036
 
    sidl_BaseInterface*)) epv->f__getURL;
3037
 
  e1->f__raddRef                 = (void (*)(void*,
3038
 
    sidl_BaseInterface*)) epv->f__raddRef;
3039
 
  e1->f__isRemote                = (sidl_bool (*)(void*,
3040
 
    sidl_BaseInterface*)) epv->f__isRemote;
3041
 
  e1->f__set_hooks               = (void (*)(void*,int32_t,
 
3087
  e1->f__delete                  = (void (*)(void*,sidl_BaseInterface*)) 
 
3088
    epv->f__delete;
 
3089
  e1->f__getURL                  = (char* (*)(void*,sidl_BaseInterface*)) 
 
3090
    epv->f__getURL;
 
3091
  e1->f__raddRef                 = (void (*)(void*,sidl_BaseInterface*)) 
 
3092
    epv->f__raddRef;
 
3093
  e1->f__isRemote                = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
3094
    epv->f__isRemote;
 
3095
  e1->f__set_hooks               = (void (*)(void*,int32_t, 
3042
3096
    sidl_BaseInterface*)) epv->f__set_hooks;
3043
 
  e1->f__exec                    = (void (*)(void*,const char*,
3044
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
3045
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
3046
 
  e1->f_SetOperator              = (int32_t (*)(void*,
3047
 
    struct bHYPRE_Operator__object*,
3048
 
    struct sidl_BaseInterface__object **)) epv->f_SetOperator;
3049
 
  e1->f_SetTolerance             = (int32_t (*)(void*,double,
3050
 
    struct sidl_BaseInterface__object **)) epv->f_SetTolerance;
3051
 
  e1->f_SetMaxIterations         = (int32_t (*)(void*,int32_t,
3052
 
    struct sidl_BaseInterface__object **)) epv->f_SetMaxIterations;
3053
 
  e1->f_SetLogging               = (int32_t (*)(void*,int32_t,
3054
 
    struct sidl_BaseInterface__object **)) epv->f_SetLogging;
3055
 
  e1->f_SetPrintLevel            = (int32_t (*)(void*,int32_t,
3056
 
    struct sidl_BaseInterface__object **)) epv->f_SetPrintLevel;
3057
 
  e1->f_GetNumIterations         = (int32_t (*)(void*,int32_t*,
3058
 
    struct sidl_BaseInterface__object **)) epv->f_GetNumIterations;
3059
 
  e1->f_GetRelResidualNorm       = (int32_t (*)(void*,double*,
3060
 
    struct sidl_BaseInterface__object **)) epv->f_GetRelResidualNorm;
3061
 
  e1->f_SetCommunicator          = (int32_t (*)(void*,
3062
 
    struct bHYPRE_MPICommunicator__object*,
3063
 
    struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
3064
 
  e1->f_Destroy                  = (void (*)(void*,
3065
 
    struct sidl_BaseInterface__object **)) epv->f_Destroy;
 
3097
  e1->f__exec                    = (void (*)(void*,const char*,struct 
 
3098
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3099
    sidl_BaseInterface__object **)) epv->f__exec;
 
3100
  e1->f_SetOperator              = (int32_t (*)(void*,struct 
 
3101
    bHYPRE_Operator__object*,struct sidl_BaseInterface__object **)) 
 
3102
    epv->f_SetOperator;
 
3103
  e1->f_SetTolerance             = (int32_t (*)(void*,double,struct 
 
3104
    sidl_BaseInterface__object **)) epv->f_SetTolerance;
 
3105
  e1->f_SetMaxIterations         = (int32_t (*)(void*,int32_t,struct 
 
3106
    sidl_BaseInterface__object **)) epv->f_SetMaxIterations;
 
3107
  e1->f_SetLogging               = (int32_t (*)(void*,int32_t,struct 
 
3108
    sidl_BaseInterface__object **)) epv->f_SetLogging;
 
3109
  e1->f_SetPrintLevel            = (int32_t (*)(void*,int32_t,struct 
 
3110
    sidl_BaseInterface__object **)) epv->f_SetPrintLevel;
 
3111
  e1->f_GetNumIterations         = (int32_t (*)(void*,int32_t*,struct 
 
3112
    sidl_BaseInterface__object **)) epv->f_GetNumIterations;
 
3113
  e1->f_GetRelResidualNorm       = (int32_t (*)(void*,double*,struct 
 
3114
    sidl_BaseInterface__object **)) epv->f_GetRelResidualNorm;
 
3115
  e1->f_SetCommunicator          = (int32_t (*)(void*,struct 
 
3116
    bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
3117
    epv->f_SetCommunicator;
 
3118
  e1->f_Destroy                  = (void (*)(void*,struct 
 
3119
    sidl_BaseInterface__object **)) epv->f_Destroy;
3066
3120
  e1->f_SetIntParameter          = (int32_t (*)(void*,const char*,int32_t,
3067
3121
    struct sidl_BaseInterface__object **)) epv->f_SetIntParameter;
3068
 
  e1->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,
3069
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
 
3122
  e1->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,struct 
 
3123
    sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
3070
3124
  e1->f_SetStringParameter       = (int32_t (*)(void*,const char*,const char*,
3071
3125
    struct sidl_BaseInterface__object **)) epv->f_SetStringParameter;
3072
 
  e1->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,
3073
 
    struct sidl_int__array*,
3074
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray1Parameter;
3075
 
  e1->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,
3076
 
    struct sidl_int__array*,
3077
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray2Parameter;
3078
 
  e1->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,
3079
 
    struct sidl_double__array*,
3080
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray1Parameter;
3081
 
  e1->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,
3082
 
    struct sidl_double__array*,
3083
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray2Parameter;
 
3126
  e1->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,struct 
 
3127
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3128
    epv->f_SetIntArray1Parameter;
 
3129
  e1->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,struct 
 
3130
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3131
    epv->f_SetIntArray2Parameter;
 
3132
  e1->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,struct 
 
3133
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3134
    epv->f_SetDoubleArray1Parameter;
 
3135
  e1->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,struct 
 
3136
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3137
    epv->f_SetDoubleArray2Parameter;
3084
3138
  e1->f_GetIntValue              = (int32_t (*)(void*,const char*,int32_t*,
3085
3139
    struct sidl_BaseInterface__object **)) epv->f_GetIntValue;
3086
3140
  e1->f_GetDoubleValue           = (int32_t (*)(void*,const char*,double*,
3087
3141
    struct sidl_BaseInterface__object **)) epv->f_GetDoubleValue;
3088
 
  e1->f_Setup                    = (int32_t (*)(void*,
3089
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,
3090
 
    struct sidl_BaseInterface__object **)) epv->f_Setup;
3091
 
  e1->f_Apply                    = (int32_t (*)(void*,
3092
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3093
 
    struct sidl_BaseInterface__object **)) epv->f_Apply;
3094
 
  e1->f_ApplyAdjoint             = (int32_t (*)(void*,
3095
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3096
 
    struct sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
3097
 
  e1->f_addRef                   = (void (*)(void*,
3098
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3099
 
  e1->f_deleteRef                = (void (*)(void*,
3100
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
3101
 
  e1->f_isSame                   = (sidl_bool (*)(void*,
3102
 
    struct sidl_BaseInterface__object*,
3103
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3104
 
  e1->f_isType                   = (sidl_bool (*)(void*,const char*,
3105
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
3142
  e1->f_Setup                    = (int32_t (*)(void*,struct 
 
3143
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,struct 
 
3144
    sidl_BaseInterface__object **)) epv->f_Setup;
 
3145
  e1->f_Apply                    = (int32_t (*)(void*,struct 
 
3146
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3147
    sidl_BaseInterface__object **)) epv->f_Apply;
 
3148
  e1->f_ApplyAdjoint             = (int32_t (*)(void*,struct 
 
3149
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3150
    sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
 
3151
  e1->f_addRef                   = (void (*)(void*,struct 
 
3152
    sidl_BaseInterface__object **)) epv->f_addRef;
 
3153
  e1->f_deleteRef                = (void (*)(void*,struct 
 
3154
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3155
  e1->f_isSame                   = (sidl_bool (*)(void*,struct 
 
3156
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
3157
    epv->f_isSame;
 
3158
  e1->f_isType                   = (sidl_bool (*)(void*,const char*,struct 
 
3159
    sidl_BaseInterface__object **)) epv->f_isType;
3106
3160
  e1->f_getClassInfo             = (struct sidl_ClassInfo__object* (*)(void*,
3107
3161
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
3108
3162
 
3116
3170
    sidl_BaseInterface*)) epv->f__raddRef;
3117
3171
  e2->f__isRemote    = (sidl_bool (*)(struct sidl_BaseClass__object*,
3118
3172
    sidl_BaseInterface*)) epv->f__isRemote;
3119
 
  e2->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t,
 
3173
  e2->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t, 
3120
3174
    sidl_BaseInterface*)) epv->f__set_hooks;
3121
3175
  e2->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,
3122
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
3123
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
3124
 
  e2->f_addRef       = (void (*)(struct sidl_BaseClass__object*,
3125
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3126
 
  e2->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,
3127
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
3128
 
  e2->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,
3129
 
    struct sidl_BaseInterface__object*,
3130
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3131
 
  e2->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,
3132
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
3176
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3177
    sidl_BaseInterface__object **)) epv->f__exec;
 
3178
  e2->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct 
 
3179
    sidl_BaseInterface__object **)) epv->f_addRef;
 
3180
  e2->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct 
 
3181
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3182
  e2->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct 
 
3183
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
3184
    epv->f_isSame;
 
3185
  e2->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const 
 
3186
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
3133
3187
  e2->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
3134
 
    sidl_BaseClass__object*,
3135
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
3188
    sidl_BaseClass__object*,struct sidl_BaseInterface__object **)) 
 
3189
    epv->f_getClassInfo;
3136
3190
 
3137
 
  e3->f__cast        = (void* (*)(void*,const char*,
3138
 
    sidl_BaseInterface*)) epv->f__cast;
 
3191
  e3->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
3192
    epv->f__cast;
3139
3193
  e3->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
3140
3194
  e3->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
3141
3195
  e3->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
3142
 
  e3->f__isRemote    = (sidl_bool (*)(void*,
3143
 
    sidl_BaseInterface*)) epv->f__isRemote;
3144
 
  e3->f__set_hooks   = (void (*)(void*,int32_t,
3145
 
    sidl_BaseInterface*)) epv->f__set_hooks;
3146
 
  e3->f__exec        = (void (*)(void*,const char*,
3147
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
3148
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
3149
 
  e3->f_addRef       = (void (*)(void*,
3150
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3151
 
  e3->f_deleteRef    = (void (*)(void*,
3152
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3196
  e3->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
3197
    epv->f__isRemote;
 
3198
  e3->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
3199
    epv->f__set_hooks;
 
3200
  e3->f__exec        = (void (*)(void*,const char*,struct 
 
3201
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3202
    sidl_BaseInterface__object **)) epv->f__exec;
 
3203
  e3->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
3204
    epv->f_addRef;
 
3205
  e3->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
3206
    epv->f_deleteRef;
3153
3207
  e3->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
3154
3208
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3155
 
  e3->f_isType       = (sidl_bool (*)(void*,const char*,
3156
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
3157
 
  e3->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
3158
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
3209
  e3->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
3210
    sidl_BaseInterface__object **)) epv->f_isType;
 
3211
  e3->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
3212
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
3159
3213
 
3160
3214
  s_remote_initialized = 1;
3161
3215
}
3162
3216
 
3163
3217
/* Create an instance that connects to an existing remote object. */
3164
3218
static struct bHYPRE_IdentitySolver__object*
3165
 
bHYPRE_IdentitySolver__remoteConnect(const char *url, sidl_bool ar,
 
3219
bHYPRE_IdentitySolver__remoteConnect(const char *url, sidl_bool ar, 
3166
3220
  sidl_BaseInterface *_ex)
3167
3221
{
3168
3222
  struct bHYPRE_IdentitySolver__object* self;
3178
3232
  if(url == NULL) {return NULL;}
3179
3233
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
3180
3234
  if(objectID) {
3181
 
    sidl_BaseInterface bi = 
3182
 
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
3183
 
      objectID, _ex); SIDL_CHECK(*_ex);
 
3235
    sidl_BaseInterface bi = (
 
3236
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(objectID,
 
3237
      _ex); SIDL_CHECK(*_ex);
3184
3238
    return bHYPRE_IdentitySolver__rmicast(bi,_ex);SIDL_CHECK(*_ex);
3185
3239
  }
3186
 
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar,
3187
 
    _ex ); SIDL_CHECK(*_ex);
 
3240
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex ); 
 
3241
    SIDL_CHECK(*_ex);
3188
3242
  if ( instance == NULL) { return NULL; }
3189
3243
  self =
3190
3244
    (struct bHYPRE_IdentitySolver__object*) malloc(
3229
3283
/* Create an instance that uses an already existing  */
3230
3284
/* InstanceHandle to connect to an existing remote object. */
3231
3285
static struct bHYPRE_IdentitySolver__object*
3232
 
bHYPRE_IdentitySolver__IHConnect(sidl_rmi_InstanceHandle instance,
 
3286
bHYPRE_IdentitySolver__IHConnect(sidl_rmi_InstanceHandle instance, 
3233
3287
  sidl_BaseInterface *_ex)
3234
3288
{
3235
3289
  struct bHYPRE_IdentitySolver__object* self;
3290
3344
  struct sidl_BaseClass__object* s1;
3291
3345
 
3292
3346
  struct bHYPRE_IdentitySolver__remote* r_obj;
3293
 
  sidl_rmi_InstanceHandle instance = 
3294
 
    sidl_rmi_ProtocolFactory_createInstance(url, "bHYPRE.IdentitySolver",
3295
 
    _ex ); SIDL_CHECK(*_ex);
 
3347
  sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance(
 
3348
    url, "bHYPRE.IdentitySolver", _ex ); SIDL_CHECK(*_ex);
3296
3349
  if ( instance == NULL) { return NULL; }
3297
3350
  self =
3298
3351
    (struct bHYPRE_IdentitySolver__object*) malloc(
3332
3385
 
3333
3386
  return self;
3334
3387
  EXIT:
3335
 
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance,
 
3388
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance, 
3336
3389
    &_throwaway_exception); }
3337
3390
  return NULL;
3338
3391
}
3349
3402
 
3350
3403
  *_ex = NULL;
3351
3404
  if(!connect_loaded) {
3352
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.IdentitySolver",
3353
 
      (void*)bHYPRE_IdentitySolver__IHConnect, _ex);
 
3405
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.IdentitySolver", (
 
3406
      void*)bHYPRE_IdentitySolver__IHConnect, _ex);
3354
3407
    connect_loaded = 1;
3355
3408
  }
3356
3409
  if (obj != NULL) {
3371
3424
 */
3372
3425
 
3373
3426
struct bHYPRE_IdentitySolver__object*
3374
 
bHYPRE_IdentitySolver__connectI(const char* url, sidl_bool ar,
3375
 
  struct sidl_BaseInterface__object **_ex)
 
3427
bHYPRE_IdentitySolver__connectI(const char* url, sidl_bool ar, struct 
 
3428
  sidl_BaseInterface__object **_ex)
3376
3429
{
3377
3430
  return bHYPRE_IdentitySolver__remoteConnect(url, ar, _ex);
3378
3431
}