← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/babel/bHYPRE/bHYPRE_StructDiagScale_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_StructDiagScale_Stub.c
2
2
 * File:          bHYPRE_StructDiagScale_Stub.c
3
3
 * Symbol:        bHYPRE.StructDiagScale-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.StructDiagScale
7
7
 * 
8
8
 * WARNING: Automatically generated; changes will be lost
59
59
#ifdef SIDL_STATIC_LIBRARY
60
60
  _externals = bHYPRE_StructDiagScale__externals();
61
61
#else
62
 
  _externals = (struct 
63
 
    bHYPRE_StructDiagScale__external*)sidl_dynamicLoadIOR(
 
62
  _externals = (struct bHYPRE_StructDiagScale__external*)sidl_dynamicLoadIOR(
64
63
    "bHYPRE.StructDiagScale","bHYPRE_StructDiagScale__externals") ;
65
 
  sidl_checkIORVersion("bHYPRE.StructDiagScale",
66
 
    _externals->d_ior_major_version, _externals->d_ior_minor_version, 0, 10);
 
64
  sidl_checkIORVersion("bHYPRE.StructDiagScale", 
 
65
    _externals->d_ior_major_version, _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_StructDiagScale__object* 
121
 
  bHYPRE_StructDiagScale__remoteConnect(const char* url, sidl_bool ar,
 
120
  bHYPRE_StructDiagScale__remoteConnect(const char* url, sidl_bool ar, 
122
121
  sidl_BaseInterface *_ex);
123
 
static struct bHYPRE_StructDiagScale__object* 
124
 
  bHYPRE_StructDiagScale__IHConnect(struct sidl_rmi_InstanceHandle__object* 
125
 
  instance, sidl_BaseInterface *_ex);
 
122
static struct bHYPRE_StructDiagScale__object* bHYPRE_StructDiagScale__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 a Struct DiagScale solver. 
138
136
 */
139
137
 
140
138
bHYPRE_StructDiagScale
143
141
  /* in */ bHYPRE_StructMatrix A,
144
142
  /* out */ sidl_BaseInterface *_ex)
145
143
{
146
 
  return (_getSEPV()->f_Create)(
 
144
  bHYPRE_StructDiagScale _result;
 
145
  _result = (_getSEPV()->f_Create)(
147
146
    mpi_comm,
148
147
    A,
149
148
    _ex);
 
149
  return _result;
150
150
}
151
151
 
152
152
/*
215
215
  /* out */ sidl_BaseInterface *_ex)
216
216
#if SIDL_C_INLINE_REPEAT_DEFN
217
217
{
218
 
  return (*self->d_epv->f_isSame)(
 
218
  sidl_bool _result;
 
219
  _result = (*self->d_epv->f_isSame)(
219
220
    self,
220
221
    iobj,
221
222
    _ex);
 
223
  return _result;
222
224
}
223
225
#else /* ISO C 1999 inline semantics */
224
226
;
239
241
  /* out */ sidl_BaseInterface *_ex)
240
242
#if SIDL_C_INLINE_REPEAT_DEFN
241
243
{
242
 
  return (*self->d_epv->f_isType)(
 
244
  sidl_bool _result;
 
245
  _result = (*self->d_epv->f_isType)(
243
246
    self,
244
247
    name,
245
248
    _ex);
 
249
  return _result;
246
250
}
247
251
#else /* ISO C 1999 inline semantics */
248
252
;
259
263
  /* out */ sidl_BaseInterface *_ex)
260
264
#if SIDL_C_INLINE_REPEAT_DEFN
261
265
{
262
 
  return (*self->d_epv->f_getClassInfo)(
 
266
  sidl_ClassInfo _result;
 
267
  _result = (*self->d_epv->f_getClassInfo)(
263
268
    self,
264
269
    _ex);
 
270
  return _result;
265
271
}
266
272
#else /* ISO C 1999 inline semantics */
267
273
;
280
286
  /* out */ sidl_BaseInterface *_ex)
281
287
#if SIDL_C_INLINE_REPEAT_DEFN
282
288
{
283
 
  return (*self->d_epv->f_SetOperator)(
 
289
  int32_t _result;
 
290
  _result = (*self->d_epv->f_SetOperator)(
284
291
    self,
285
292
    A,
286
293
    _ex);
 
294
  return _result;
287
295
}
288
296
#else /* ISO C 1999 inline semantics */
289
297
;
302
310
  /* out */ sidl_BaseInterface *_ex)
303
311
#if SIDL_C_INLINE_REPEAT_DEFN
304
312
{
305
 
  return (*self->d_epv->f_SetTolerance)(
 
313
  int32_t _result;
 
314
  _result = (*self->d_epv->f_SetTolerance)(
306
315
    self,
307
316
    tolerance,
308
317
    _ex);
 
318
  return _result;
309
319
}
310
320
#else /* ISO C 1999 inline semantics */
311
321
;
324
334
  /* out */ sidl_BaseInterface *_ex)
325
335
#if SIDL_C_INLINE_REPEAT_DEFN
326
336
{
327
 
  return (*self->d_epv->f_SetMaxIterations)(
 
337
  int32_t _result;
 
338
  _result = (*self->d_epv->f_SetMaxIterations)(
328
339
    self,
329
340
    max_iterations,
330
341
    _ex);
 
342
  return _result;
331
343
}
332
344
#else /* ISO C 1999 inline semantics */
333
345
;
350
362
  /* out */ sidl_BaseInterface *_ex)
351
363
#if SIDL_C_INLINE_REPEAT_DEFN
352
364
{
353
 
  return (*self->d_epv->f_SetLogging)(
 
365
  int32_t _result;
 
366
  _result = (*self->d_epv->f_SetLogging)(
354
367
    self,
355
368
    level,
356
369
    _ex);
 
370
  return _result;
357
371
}
358
372
#else /* ISO C 1999 inline semantics */
359
373
;
376
390
  /* out */ sidl_BaseInterface *_ex)
377
391
#if SIDL_C_INLINE_REPEAT_DEFN
378
392
{
379
 
  return (*self->d_epv->f_SetPrintLevel)(
 
393
  int32_t _result;
 
394
  _result = (*self->d_epv->f_SetPrintLevel)(
380
395
    self,
381
396
    level,
382
397
    _ex);
 
398
  return _result;
383
399
}
384
400
#else /* ISO C 1999 inline semantics */
385
401
;
397
413
  /* out */ sidl_BaseInterface *_ex)
398
414
#if SIDL_C_INLINE_REPEAT_DEFN
399
415
{
400
 
  return (*self->d_epv->f_GetNumIterations)(
 
416
  int32_t _result;
 
417
  _result = (*self->d_epv->f_GetNumIterations)(
401
418
    self,
402
419
    num_iterations,
403
420
    _ex);
 
421
  return _result;
404
422
}
405
423
#else /* ISO C 1999 inline semantics */
406
424
;
418
436
  /* out */ sidl_BaseInterface *_ex)
419
437
#if SIDL_C_INLINE_REPEAT_DEFN
420
438
{
421
 
  return (*self->d_epv->f_GetRelResidualNorm)(
 
439
  int32_t _result;
 
440
  _result = (*self->d_epv->f_GetRelResidualNorm)(
422
441
    self,
423
442
    norm,
424
443
    _ex);
 
444
  return _result;
425
445
}
426
446
#else /* ISO C 1999 inline semantics */
427
447
;
440
460
  /* out */ sidl_BaseInterface *_ex)
441
461
#if SIDL_C_INLINE_REPEAT_DEFN
442
462
{
443
 
  return (*self->d_epv->f_SetCommunicator)(
 
463
  int32_t _result;
 
464
  _result = (*self->d_epv->f_SetCommunicator)(
444
465
    self,
445
466
    mpi_comm,
446
467
    _ex);
 
468
  return _result;
447
469
}
448
470
#else /* ISO C 1999 inline semantics */
449
471
;
484
506
  /* out */ sidl_BaseInterface *_ex)
485
507
#if SIDL_C_INLINE_REPEAT_DEFN
486
508
{
487
 
  return (*self->d_epv->f_SetIntParameter)(
 
509
  int32_t _result;
 
510
  _result = (*self->d_epv->f_SetIntParameter)(
488
511
    self,
489
512
    name,
490
513
    value,
491
514
    _ex);
 
515
  return _result;
492
516
}
493
517
#else /* ISO C 1999 inline semantics */
494
518
;
507
531
  /* out */ sidl_BaseInterface *_ex)
508
532
#if SIDL_C_INLINE_REPEAT_DEFN
509
533
{
510
 
  return (*self->d_epv->f_SetDoubleParameter)(
 
534
  int32_t _result;
 
535
  _result = (*self->d_epv->f_SetDoubleParameter)(
511
536
    self,
512
537
    name,
513
538
    value,
514
539
    _ex);
 
540
  return _result;
515
541
}
516
542
#else /* ISO C 1999 inline semantics */
517
543
;
530
556
  /* out */ sidl_BaseInterface *_ex)
531
557
#if SIDL_C_INLINE_REPEAT_DEFN
532
558
{
533
 
  return (*self->d_epv->f_SetStringParameter)(
 
559
  int32_t _result;
 
560
  _result = (*self->d_epv->f_SetStringParameter)(
534
561
    self,
535
562
    name,
536
563
    value,
537
564
    _ex);
 
565
  return _result;
538
566
}
539
567
#else /* ISO C 1999 inline semantics */
540
568
;
554
582
  /* out */ sidl_BaseInterface *_ex)
555
583
#if SIDL_C_INLINE_REPEAT_DEFN
556
584
{
 
585
  int32_t _result;
557
586
  int32_t value_lower[1], value_upper[1], value_stride[1]; 
558
587
  struct sidl_int__array value_real;
559
588
  struct sidl_int__array*value_tmp = &value_real;
560
589
  value_upper[0] = nvalues-1;
561
 
  sidl_int__array_init(value, value_tmp, 1, value_lower, value_upper,
 
590
  sidl_int__array_init(value, value_tmp, 1, value_lower, value_upper, 
562
591
    value_stride);
563
 
  return (*self->d_epv->f_SetIntArray1Parameter)(
 
592
  _result = (*self->d_epv->f_SetIntArray1Parameter)(
564
593
    self,
565
594
    name,
566
595
    value_tmp,
567
596
    _ex);
 
597
#ifdef SIDL_DEBUG_REFCOUNT
 
598
  sidl__array_deleteRef((struct sidl__array*)value_tmp);
 
599
#endif /* SIDL_DEBUG_REFCOUNT */
 
600
  return _result;
568
601
}
569
602
#else /* ISO C 1999 inline semantics */
570
603
;
583
616
  /* out */ sidl_BaseInterface *_ex)
584
617
#if SIDL_C_INLINE_REPEAT_DEFN
585
618
{
586
 
  return (*self->d_epv->f_SetIntArray2Parameter)(
 
619
  int32_t _result;
 
620
  _result = (*self->d_epv->f_SetIntArray2Parameter)(
587
621
    self,
588
622
    name,
589
623
    value,
590
624
    _ex);
 
625
  return _result;
591
626
}
592
627
#else /* ISO C 1999 inline semantics */
593
628
;
607
642
  /* out */ sidl_BaseInterface *_ex)
608
643
#if SIDL_C_INLINE_REPEAT_DEFN
609
644
{
 
645
  int32_t _result;
610
646
  int32_t value_lower[1], value_upper[1], value_stride[1]; 
611
647
  struct sidl_double__array value_real;
612
648
  struct sidl_double__array*value_tmp = &value_real;
613
649
  value_upper[0] = nvalues-1;
614
 
  sidl_double__array_init(value, value_tmp, 1, value_lower, value_upper,
 
650
  sidl_double__array_init(value, value_tmp, 1, value_lower, value_upper, 
615
651
    value_stride);
616
 
  return (*self->d_epv->f_SetDoubleArray1Parameter)(
 
652
  _result = (*self->d_epv->f_SetDoubleArray1Parameter)(
617
653
    self,
618
654
    name,
619
655
    value_tmp,
620
656
    _ex);
 
657
#ifdef SIDL_DEBUG_REFCOUNT
 
658
  sidl__array_deleteRef((struct sidl__array*)value_tmp);
 
659
#endif /* SIDL_DEBUG_REFCOUNT */
 
660
  return _result;
621
661
}
622
662
#else /* ISO C 1999 inline semantics */
623
663
;
636
676
  /* out */ sidl_BaseInterface *_ex)
637
677
#if SIDL_C_INLINE_REPEAT_DEFN
638
678
{
639
 
  return (*self->d_epv->f_SetDoubleArray2Parameter)(
 
679
  int32_t _result;
 
680
  _result = (*self->d_epv->f_SetDoubleArray2Parameter)(
640
681
    self,
641
682
    name,
642
683
    value,
643
684
    _ex);
 
685
  return _result;
644
686
}
645
687
#else /* ISO C 1999 inline semantics */
646
688
;
659
701
  /* out */ sidl_BaseInterface *_ex)
660
702
#if SIDL_C_INLINE_REPEAT_DEFN
661
703
{
662
 
  return (*self->d_epv->f_GetIntValue)(
 
704
  int32_t _result;
 
705
  _result = (*self->d_epv->f_GetIntValue)(
663
706
    self,
664
707
    name,
665
708
    value,
666
709
    _ex);
 
710
  return _result;
667
711
}
668
712
#else /* ISO C 1999 inline semantics */
669
713
;
682
726
  /* out */ sidl_BaseInterface *_ex)
683
727
#if SIDL_C_INLINE_REPEAT_DEFN
684
728
{
685
 
  return (*self->d_epv->f_GetDoubleValue)(
 
729
  int32_t _result;
 
730
  _result = (*self->d_epv->f_GetDoubleValue)(
686
731
    self,
687
732
    name,
688
733
    value,
689
734
    _ex);
 
735
  return _result;
690
736
}
691
737
#else /* ISO C 1999 inline semantics */
692
738
;
706
752
  /* out */ sidl_BaseInterface *_ex)
707
753
#if SIDL_C_INLINE_REPEAT_DEFN
708
754
{
709
 
  return (*self->d_epv->f_Setup)(
 
755
  int32_t _result;
 
756
  _result = (*self->d_epv->f_Setup)(
710
757
    self,
711
758
    b,
712
759
    x,
713
760
    _ex);
 
761
  return _result;
714
762
}
715
763
#else /* ISO C 1999 inline semantics */
716
764
;
729
777
  /* out */ sidl_BaseInterface *_ex)
730
778
#if SIDL_C_INLINE_REPEAT_DEFN
731
779
{
732
 
  return (*self->d_epv->f_Apply)(
 
780
  int32_t _result;
 
781
  _result = (*self->d_epv->f_Apply)(
733
782
    self,
734
783
    b,
735
784
    x,
736
785
    _ex);
 
786
  return _result;
737
787
}
738
788
#else /* ISO C 1999 inline semantics */
739
789
;
752
802
  /* out */ sidl_BaseInterface *_ex)
753
803
#if SIDL_C_INLINE_REPEAT_DEFN
754
804
{
755
 
  return (*self->d_epv->f_ApplyAdjoint)(
 
805
  int32_t _result;
 
806
  _result = (*self->d_epv->f_ApplyAdjoint)(
756
807
    self,
757
808
    b,
758
809
    x,
759
810
    _ex);
 
811
  return _result;
760
812
}
761
813
#else /* ISO C 1999 inline semantics */
762
814
;
775
827
 
776
828
  if(!connect_loaded) {
777
829
    connect_loaded = 1;
778
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.StructDiagScale",
779
 
      (void*)bHYPRE_StructDiagScale__IHConnect,_ex);SIDL_CHECK(*_ex);
 
830
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.StructDiagScale", (
 
831
      void*)bHYPRE_StructDiagScale__IHConnect,_ex);SIDL_CHECK(*_ex);
780
832
  }
781
833
  if (obj != NULL) {
782
834
    sidl_BaseInterface base = (sidl_BaseInterface) obj;
846
898
  /* out */ sidl_BaseInterface *_ex)
847
899
#if SIDL_C_INLINE_REPEAT_DEFN
848
900
{
849
 
  return (*self->d_epv->f__getURL)(
 
901
  char* _result;
 
902
  _result = (*self->d_epv->f__getURL)(
850
903
    self,
851
904
    _ex);
 
905
  return _result;
852
906
}
853
907
#else /* ISO C 1999 inline semantics */
854
908
;
921
975
  /* out */ sidl_BaseInterface *_ex)
922
976
#if SIDL_C_INLINE_REPEAT_DEFN
923
977
{
924
 
  return (*self->d_epv->f__isRemote)(
 
978
  sidl_bool _result;
 
979
  _result = (*self->d_epv->f__isRemote)(
925
980
    self,
926
981
    _ex);
 
982
  return _result;
927
983
}
928
984
#else /* ISO C 1999 inline semantics */
929
985
;
948
1004
  const int32_t lower[],
949
1005
  const int32_t upper[])
950
1006
{
951
 
  return (struct 
952
 
    bHYPRE_StructDiagScale__array*)sidl_interface__array_createCol(dimen, lower,
953
 
    upper);
 
1007
  return (struct bHYPRE_StructDiagScale__array*)sidl_interface__array_createCol(
 
1008
    dimen, lower, upper);
954
1009
}
955
1010
 
956
1011
struct bHYPRE_StructDiagScale__array*
959
1014
  const int32_t lower[],
960
1015
  const int32_t upper[])
961
1016
{
962
 
  return (struct 
963
 
    bHYPRE_StructDiagScale__array*)sidl_interface__array_createRow(dimen, lower,
964
 
    upper);
 
1017
  return (struct bHYPRE_StructDiagScale__array*)sidl_interface__array_createRow(
 
1018
    dimen, lower, upper);
965
1019
}
966
1020
 
967
1021
struct bHYPRE_StructDiagScale__array*
968
1022
bHYPRE_StructDiagScale__array_create1d(int32_t len)
969
1023
{
970
 
  return (struct 
971
 
    bHYPRE_StructDiagScale__array*)sidl_interface__array_create1d(len);
 
1024
  return (struct bHYPRE_StructDiagScale__array*)sidl_interface__array_create1d(
 
1025
    len);
972
1026
}
973
1027
 
974
1028
struct bHYPRE_StructDiagScale__array*
977
1031
  bHYPRE_StructDiagScale* data)
978
1032
{
979
1033
  return (struct 
980
 
    bHYPRE_StructDiagScale__array*)sidl_interface__array_create1dInit(len,
981
 
    (struct sidl_BaseInterface__object **)data);
 
1034
    bHYPRE_StructDiagScale__array*)sidl_interface__array_create1dInit(len, (
 
1035
    struct sidl_BaseInterface__object **)data);
982
1036
}
983
1037
 
984
1038
struct bHYPRE_StructDiagScale__array*
1127
1181
  const int32_t indices[])
1128
1182
{
1129
1183
  return (bHYPRE_StructDiagScale)
1130
 
    sidl_interface__array_get((const struct sidl_interface__array *)array,
 
1184
    sidl_interface__array_get((const struct sidl_interface__array *)array, 
1131
1185
      indices);
1132
1186
}
1133
1187
 
1228
1282
  const int32_t indices[],
1229
1283
  bHYPRE_StructDiagScale const value)
1230
1284
{
1231
 
  sidl_interface__array_set((struct sidl_interface__array *)array, indices,
1232
 
    (struct sidl_BaseInterface__object *)value);
 
1285
  sidl_interface__array_set((struct sidl_interface__array *)array, indices, (
 
1286
    struct sidl_BaseInterface__object *)value);
1233
1287
}
1234
1288
 
1235
1289
int32_t
1244
1298
  const struct bHYPRE_StructDiagScale__array* array,
1245
1299
  const int32_t ind)
1246
1300
{
1247
 
  return sidl_interface__array_lower((struct sidl_interface__array *)array,
 
1301
  return sidl_interface__array_lower((struct sidl_interface__array *)array, 
1248
1302
    ind);
1249
1303
}
1250
1304
 
1253
1307
  const struct bHYPRE_StructDiagScale__array* array,
1254
1308
  const int32_t ind)
1255
1309
{
1256
 
  return sidl_interface__array_upper((struct sidl_interface__array *)array,
 
1310
  return sidl_interface__array_upper((struct sidl_interface__array *)array, 
1257
1311
    ind);
1258
1312
}
1259
1313
 
1262
1316
  const struct bHYPRE_StructDiagScale__array* array,
1263
1317
  const int32_t ind)
1264
1318
{
1265
 
  return sidl_interface__array_length((struct sidl_interface__array *)array,
 
1319
  return sidl_interface__array_length((struct sidl_interface__array *)array, 
1266
1320
    ind);
1267
1321
}
1268
1322
 
1271
1325
  const struct bHYPRE_StructDiagScale__array* array,
1272
1326
  const int32_t ind)
1273
1327
{
1274
 
  return sidl_interface__array_stride((struct sidl_interface__array *)array,
 
1328
  return sidl_interface__array_stride((struct sidl_interface__array *)array, 
1275
1329
    ind);
1276
1330
}
1277
1331
 
1321
1375
  int     ordering)
1322
1376
{
1323
1377
  return (struct bHYPRE_StructDiagScale__array*)
1324
 
    sidl_interface__array_ensure((struct sidl_interface__array *)src, dimen,
 
1378
    sidl_interface__array_ensure((struct sidl_interface__array *)src, dimen, 
1325
1379
      ordering);
1326
1380
}
1327
1381
 
1376
1430
#endif
1377
1431
 
1378
1432
/* Static variables to hold version of IOR */
1379
 
static const int32_t s_IOR_MAJOR_VERSION = 0;
1380
 
static const int32_t s_IOR_MINOR_VERSION = 10;
 
1433
static const int32_t s_IOR_MAJOR_VERSION = 1;
 
1434
static const int32_t s_IOR_MINOR_VERSION = 0;
1381
1435
 
1382
1436
/* Static variables for managing EPV initialization. */
1383
1437
static int s_remote_initialized = 0;
1407
1461
  cmp0 = strcmp(name, "bHYPRE.StructDiagScale");
1408
1462
  if (!cmp0) {
1409
1463
    (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
1410
 
    cast = self;
 
1464
    cast = ((struct bHYPRE_StructDiagScale__object*)self);
1411
1465
    return cast;
1412
1466
  }
1413
1467
  else if (cmp0 < 0) {
1437
1491
      cmp2 = strcmp(name, "sidl.BaseClass");
1438
1492
      if (!cmp2) {
1439
1493
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
1440
 
        cast = self;
 
1494
        cast = ((struct sidl_BaseClass__object*)self);
1441
1495
        return cast;
1442
1496
      }
1443
1497
    }
1444
1498
  }
1445
1499
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
1446
 
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,
1447
 
      struct sidl_BaseInterface__object**) = 
1448
 
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,
1449
 
        struct sidl_BaseInterface__object**)) 
 
1500
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1501
      sidl_BaseInterface__object**) = 
 
1502
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1503
        sidl_BaseInterface__object**)) 
1450
1504
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
1451
1505
    cast =  (*func)(((struct 
1452
1506
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih, _ex);
1489
1543
  struct sidl_rmi_InstanceHandle__object *_conn = ((struct 
1490
1544
    bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
1491
1545
  sidl_rmi_Response _rsvp = NULL;
1492
 
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1546
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1493
1547
    "addRef", _ex ); SIDL_CHECK(*_ex);
1494
1548
  /* send actual RMI request */
1495
1549
  _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
1534
1588
    sidl_rmi_Response _rsvp = NULL;
1535
1589
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1536
1590
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
1537
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1591
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1538
1592
      "_set_hooks", _ex ); SIDL_CHECK(*_ex);
1539
1593
 
1540
1594
    /* pack in and inout arguments */
1628
1682
    sidl_bool _retval = FALSE;
1629
1683
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1630
1684
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
1631
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1685
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1632
1686
      "isSame", _ex ); SIDL_CHECK(*_ex);
1633
1687
 
1634
1688
    /* pack in and inout arguments */
1635
1689
    if(iobj){
1636
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,
 
1690
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj, 
1637
1691
        _ex);SIDL_CHECK(*_ex);
1638
1692
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(*_ex);
1639
1693
      free((void*)_url);
1654
1708
    }
1655
1709
 
1656
1710
    /* extract return value */
1657
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1658
 
      _ex);SIDL_CHECK(*_ex);
 
1711
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1712
      *_ex);
1659
1713
 
1660
1714
    /* unpack out and inout arguments */
1661
1715
 
1684
1738
    sidl_bool _retval = FALSE;
1685
1739
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1686
1740
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
1687
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1741
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1688
1742
      "isType", _ex ); SIDL_CHECK(*_ex);
1689
1743
 
1690
1744
    /* pack in and inout arguments */
1703
1757
    }
1704
1758
 
1705
1759
    /* extract return value */
1706
 
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
1707
 
      _ex);SIDL_CHECK(*_ex);
 
1760
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1761
      *_ex);
1708
1762
 
1709
1763
    /* unpack out and inout arguments */
1710
1764
 
1733
1787
    struct sidl_ClassInfo__object* _retval = 0;
1734
1788
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1735
1789
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
1736
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1790
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1737
1791
      "getClassInfo", _ex ); SIDL_CHECK(*_ex);
1738
1792
 
1739
1793
    /* pack in and inout arguments */
1751
1805
    }
1752
1806
 
1753
1807
    /* extract return value */
1754
 
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
1755
 
      _ex);SIDL_CHECK(*_ex);
1756
 
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,
1757
 
      _ex);SIDL_CHECK(*_ex);
 
1808
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
1809
      _ex);SIDL_CHECK(*_ex);
 
1810
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
1811
      *_ex);
1758
1812
 
1759
1813
    /* unpack out and inout arguments */
1760
1814
 
1783
1837
    int32_t _retval = 0;
1784
1838
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1785
1839
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
1786
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1840
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1787
1841
      "SetOperator", _ex ); SIDL_CHECK(*_ex);
1788
1842
 
1789
1843
    /* pack in and inout arguments */
1790
1844
    if(A){
1791
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)A,
 
1845
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)A, 
1792
1846
        _ex);SIDL_CHECK(*_ex);
1793
1847
      sidl_rmi_Invocation_packString( _inv, "A", _url, _ex);SIDL_CHECK(*_ex);
1794
1848
      free((void*)_url);
1809
1863
    }
1810
1864
 
1811
1865
    /* extract return value */
1812
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1813
 
      _ex);SIDL_CHECK(*_ex);
 
1866
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1867
      *_ex);
1814
1868
 
1815
1869
    /* unpack out and inout arguments */
1816
1870
 
1839
1893
    int32_t _retval = 0;
1840
1894
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1841
1895
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
1842
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1896
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1843
1897
      "SetTolerance", _ex ); SIDL_CHECK(*_ex);
1844
1898
 
1845
1899
    /* pack in and inout arguments */
1846
 
    sidl_rmi_Invocation_packDouble( _inv, "tolerance", tolerance,
 
1900
    sidl_rmi_Invocation_packDouble( _inv, "tolerance", tolerance, 
1847
1901
      _ex);SIDL_CHECK(*_ex);
1848
1902
 
1849
1903
    /* send actual RMI request */
1859
1913
    }
1860
1914
 
1861
1915
    /* extract return value */
1862
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1863
 
      _ex);SIDL_CHECK(*_ex);
 
1916
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1917
      *_ex);
1864
1918
 
1865
1919
    /* unpack out and inout arguments */
1866
1920
 
1889
1943
    int32_t _retval = 0;
1890
1944
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1891
1945
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
1892
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1946
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1893
1947
      "SetMaxIterations", _ex ); SIDL_CHECK(*_ex);
1894
1948
 
1895
1949
    /* pack in and inout arguments */
1896
 
    sidl_rmi_Invocation_packInt( _inv, "max_iterations", max_iterations,
 
1950
    sidl_rmi_Invocation_packInt( _inv, "max_iterations", max_iterations, 
1897
1951
      _ex);SIDL_CHECK(*_ex);
1898
1952
 
1899
1953
    /* send actual RMI request */
1909
1963
    }
1910
1964
 
1911
1965
    /* extract return value */
1912
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1913
 
      _ex);SIDL_CHECK(*_ex);
 
1966
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1967
      *_ex);
1914
1968
 
1915
1969
    /* unpack out and inout arguments */
1916
1970
 
1939
1993
    int32_t _retval = 0;
1940
1994
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1941
1995
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
1942
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1996
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1943
1997
      "SetLogging", _ex ); SIDL_CHECK(*_ex);
1944
1998
 
1945
1999
    /* pack in and inout arguments */
1958
2012
    }
1959
2013
 
1960
2014
    /* extract return value */
1961
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
1962
 
      _ex);SIDL_CHECK(*_ex);
 
2015
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2016
      *_ex);
1963
2017
 
1964
2018
    /* unpack out and inout arguments */
1965
2019
 
1988
2042
    int32_t _retval = 0;
1989
2043
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
1990
2044
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
1991
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2045
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
1992
2046
      "SetPrintLevel", _ex ); SIDL_CHECK(*_ex);
1993
2047
 
1994
2048
    /* pack in and inout arguments */
2007
2061
    }
2008
2062
 
2009
2063
    /* extract return value */
2010
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2011
 
      _ex);SIDL_CHECK(*_ex);
 
2064
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2065
      *_ex);
2012
2066
 
2013
2067
    /* unpack out and inout arguments */
2014
2068
 
2037
2091
    int32_t _retval = 0;
2038
2092
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2039
2093
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2040
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2094
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2041
2095
      "GetNumIterations", _ex ); SIDL_CHECK(*_ex);
2042
2096
 
2043
2097
    /* pack in and inout arguments */
2055
2109
    }
2056
2110
 
2057
2111
    /* extract return value */
2058
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2059
 
      _ex);SIDL_CHECK(*_ex);
 
2112
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2113
      *_ex);
2060
2114
 
2061
2115
    /* unpack out and inout arguments */
2062
 
    sidl_rmi_Response_unpackInt( _rsvp, "num_iterations", num_iterations,
 
2116
    sidl_rmi_Response_unpackInt( _rsvp, "num_iterations", num_iterations, 
2063
2117
      _ex);SIDL_CHECK(*_ex);
2064
2118
 
2065
2119
    /* cleanup and return */
2087
2141
    int32_t _retval = 0;
2088
2142
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2089
2143
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2090
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2144
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2091
2145
      "GetRelResidualNorm", _ex ); SIDL_CHECK(*_ex);
2092
2146
 
2093
2147
    /* pack in and inout arguments */
2105
2159
    }
2106
2160
 
2107
2161
    /* extract return value */
2108
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2109
 
      _ex);SIDL_CHECK(*_ex);
 
2162
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2163
      *_ex);
2110
2164
 
2111
2165
    /* unpack out and inout arguments */
2112
2166
    sidl_rmi_Response_unpackDouble( _rsvp, "norm", norm, _ex);SIDL_CHECK(*_ex);
2136
2190
    int32_t _retval = 0;
2137
2191
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2138
2192
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2139
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2193
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2140
2194
      "SetCommunicator", _ex ); SIDL_CHECK(*_ex);
2141
2195
 
2142
2196
    /* pack in and inout arguments */
2143
2197
    if(mpi_comm){
2144
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm,
2145
 
        _ex);SIDL_CHECK(*_ex);
2146
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url,
2147
 
        _ex);SIDL_CHECK(*_ex);
 
2198
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)mpi_comm, 
 
2199
        _ex);SIDL_CHECK(*_ex);
 
2200
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", _url, _ex);SIDL_CHECK(
 
2201
        *_ex);
2148
2202
      free((void*)_url);
2149
2203
    } else {
2150
 
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL,
2151
 
        _ex);SIDL_CHECK(*_ex);
 
2204
      sidl_rmi_Invocation_packString( _inv, "mpi_comm", NULL, _ex);SIDL_CHECK(
 
2205
        *_ex);
2152
2206
    }
2153
2207
 
2154
2208
    /* send actual RMI request */
2164
2218
    }
2165
2219
 
2166
2220
    /* extract return value */
2167
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2168
 
      _ex);SIDL_CHECK(*_ex);
 
2221
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2222
      *_ex);
2169
2223
 
2170
2224
    /* unpack out and inout arguments */
2171
2225
 
2192
2246
    sidl_rmi_Response _rsvp = NULL;
2193
2247
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2194
2248
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2195
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2249
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2196
2250
      "Destroy", _ex ); SIDL_CHECK(*_ex);
2197
2251
 
2198
2252
    /* pack in and inout arguments */
2237
2291
    int32_t _retval = 0;
2238
2292
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2239
2293
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2240
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2294
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2241
2295
      "SetIntParameter", _ex ); SIDL_CHECK(*_ex);
2242
2296
 
2243
2297
    /* pack in and inout arguments */
2257
2311
    }
2258
2312
 
2259
2313
    /* extract return value */
2260
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2261
 
      _ex);SIDL_CHECK(*_ex);
 
2314
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2315
      *_ex);
2262
2316
 
2263
2317
    /* unpack out and inout arguments */
2264
2318
 
2288
2342
    int32_t _retval = 0;
2289
2343
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2290
2344
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2291
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2345
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2292
2346
      "SetDoubleParameter", _ex ); SIDL_CHECK(*_ex);
2293
2347
 
2294
2348
    /* pack in and inout arguments */
2308
2362
    }
2309
2363
 
2310
2364
    /* extract return value */
2311
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2312
 
      _ex);SIDL_CHECK(*_ex);
 
2365
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2366
      *_ex);
2313
2367
 
2314
2368
    /* unpack out and inout arguments */
2315
2369
 
2339
2393
    int32_t _retval = 0;
2340
2394
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2341
2395
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2342
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2396
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2343
2397
      "SetStringParameter", _ex ); SIDL_CHECK(*_ex);
2344
2398
 
2345
2399
    /* pack in and inout arguments */
2359
2413
    }
2360
2414
 
2361
2415
    /* extract return value */
2362
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2363
 
      _ex);SIDL_CHECK(*_ex);
 
2416
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2417
      *_ex);
2364
2418
 
2365
2419
    /* unpack out and inout arguments */
2366
2420
 
2390
2444
    int32_t _retval = 0;
2391
2445
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2392
2446
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2393
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2447
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2394
2448
      "SetIntArray1Parameter", _ex ); SIDL_CHECK(*_ex);
2395
2449
 
2396
2450
    /* pack in and inout arguments */
2411
2465
    }
2412
2466
 
2413
2467
    /* extract return value */
2414
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2415
 
      _ex);SIDL_CHECK(*_ex);
 
2468
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2469
      *_ex);
2416
2470
 
2417
2471
    /* unpack out and inout arguments */
2418
2472
 
2442
2496
    int32_t _retval = 0;
2443
2497
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2444
2498
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2445
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2499
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2446
2500
      "SetIntArray2Parameter", _ex ); SIDL_CHECK(*_ex);
2447
2501
 
2448
2502
    /* pack in and inout arguments */
2463
2517
    }
2464
2518
 
2465
2519
    /* extract return value */
2466
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2467
 
      _ex);SIDL_CHECK(*_ex);
 
2520
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2521
      *_ex);
2468
2522
 
2469
2523
    /* unpack out and inout arguments */
2470
2524
 
2494
2548
    int32_t _retval = 0;
2495
2549
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2496
2550
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2497
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2551
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2498
2552
      "SetDoubleArray1Parameter", _ex ); SIDL_CHECK(*_ex);
2499
2553
 
2500
2554
    /* pack in and inout arguments */
2515
2569
    }
2516
2570
 
2517
2571
    /* extract return value */
2518
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2519
 
      _ex);SIDL_CHECK(*_ex);
 
2572
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2573
      *_ex);
2520
2574
 
2521
2575
    /* unpack out and inout arguments */
2522
2576
 
2546
2600
    int32_t _retval = 0;
2547
2601
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2548
2602
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2549
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2603
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2550
2604
      "SetDoubleArray2Parameter", _ex ); SIDL_CHECK(*_ex);
2551
2605
 
2552
2606
    /* pack in and inout arguments */
2567
2621
    }
2568
2622
 
2569
2623
    /* extract return value */
2570
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2571
 
      _ex);SIDL_CHECK(*_ex);
 
2624
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2625
      *_ex);
2572
2626
 
2573
2627
    /* unpack out and inout arguments */
2574
2628
 
2598
2652
    int32_t _retval = 0;
2599
2653
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2600
2654
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2601
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2655
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2602
2656
      "GetIntValue", _ex ); SIDL_CHECK(*_ex);
2603
2657
 
2604
2658
    /* pack in and inout arguments */
2617
2671
    }
2618
2672
 
2619
2673
    /* extract return value */
2620
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2621
 
      _ex);SIDL_CHECK(*_ex);
 
2674
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2675
      *_ex);
2622
2676
 
2623
2677
    /* unpack out and inout arguments */
2624
2678
    sidl_rmi_Response_unpackInt( _rsvp, "value", value, _ex);SIDL_CHECK(*_ex);
2649
2703
    int32_t _retval = 0;
2650
2704
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2651
2705
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2652
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2706
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2653
2707
      "GetDoubleValue", _ex ); SIDL_CHECK(*_ex);
2654
2708
 
2655
2709
    /* pack in and inout arguments */
2668
2722
    }
2669
2723
 
2670
2724
    /* extract return value */
2671
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2672
 
      _ex);SIDL_CHECK(*_ex);
 
2725
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2726
      *_ex);
2673
2727
 
2674
2728
    /* unpack out and inout arguments */
2675
 
    sidl_rmi_Response_unpackDouble( _rsvp, "value", value,
2676
 
      _ex);SIDL_CHECK(*_ex);
 
2729
    sidl_rmi_Response_unpackDouble( _rsvp, "value", value, _ex);SIDL_CHECK(
 
2730
      *_ex);
2677
2731
 
2678
2732
    /* cleanup and return */
2679
2733
    EXIT:
2701
2755
    int32_t _retval = 0;
2702
2756
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2703
2757
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2704
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2758
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2705
2759
      "Setup", _ex ); SIDL_CHECK(*_ex);
2706
2760
 
2707
2761
    /* pack in and inout arguments */
2708
2762
    if(b){
2709
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
2763
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
2710
2764
        _ex);SIDL_CHECK(*_ex);
2711
2765
      sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
2712
2766
      free((void*)_url);
2714
2768
      sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
2715
2769
    }
2716
2770
    if(x){
2717
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)x,
 
2771
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)x, 
2718
2772
        _ex);SIDL_CHECK(*_ex);
2719
2773
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
2720
2774
      free((void*)_url);
2735
2789
    }
2736
2790
 
2737
2791
    /* extract return value */
2738
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2739
 
      _ex);SIDL_CHECK(*_ex);
 
2792
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2793
      *_ex);
2740
2794
 
2741
2795
    /* unpack out and inout arguments */
2742
2796
 
2767
2821
    int32_t _retval = 0;
2768
2822
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2769
2823
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2770
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2824
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2771
2825
      "Apply", _ex ); SIDL_CHECK(*_ex);
2772
2826
 
2773
2827
    /* pack in and inout arguments */
2774
2828
    if(b){
2775
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
2829
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
2776
2830
        _ex);SIDL_CHECK(*_ex);
2777
2831
      sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
2778
2832
      free((void*)_url);
2780
2834
      sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
2781
2835
    }
2782
2836
    if(*x){
2783
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x,
 
2837
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x, 
2784
2838
        _ex);SIDL_CHECK(*_ex);
2785
2839
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
2786
2840
      free((void*)_url);
2792
2846
      SIDL_CHECK(*_ex);
2793
2847
      (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((
2794
2848
        sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
2795
 
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,
2796
 
        _ex);SIDL_CHECK(*_ex); 
 
2849
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(
 
2850
        *_ex); 
2797
2851
    }
2798
2852
 
2799
2853
    /* send actual RMI request */
2809
2863
    }
2810
2864
 
2811
2865
    /* extract return value */
2812
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2813
 
      _ex);SIDL_CHECK(*_ex);
 
2866
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2867
      *_ex);
2814
2868
 
2815
2869
    /* unpack out and inout arguments */
2816
2870
    sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
2843
2897
    int32_t _retval = 0;
2844
2898
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
2845
2899
      bHYPRE_StructDiagScale__remote*)self->d_data)->d_ih;
2846
 
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
2900
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
2847
2901
      "ApplyAdjoint", _ex ); SIDL_CHECK(*_ex);
2848
2902
 
2849
2903
    /* pack in and inout arguments */
2850
2904
    if(b){
2851
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b,
 
2905
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)b, 
2852
2906
        _ex);SIDL_CHECK(*_ex);
2853
2907
      sidl_rmi_Invocation_packString( _inv, "b", _url, _ex);SIDL_CHECK(*_ex);
2854
2908
      free((void*)_url);
2856
2910
      sidl_rmi_Invocation_packString( _inv, "b", NULL, _ex);SIDL_CHECK(*_ex);
2857
2911
    }
2858
2912
    if(*x){
2859
 
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x,
 
2913
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)*x, 
2860
2914
        _ex);SIDL_CHECK(*_ex);
2861
2915
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
2862
2916
      free((void*)_url);
2868
2922
      SIDL_CHECK(*_ex);
2869
2923
      (*((sidl_BaseInterface)*x)->d_epv->f__raddRef)(((
2870
2924
        sidl_BaseInterface)*x)->d_object, _ex);SIDL_CHECK(*_ex);
2871
 
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x,
2872
 
        _ex);SIDL_CHECK(*_ex); 
 
2925
      sidl_BaseInterface_deleteRef((sidl_BaseInterface)*x, _ex);SIDL_CHECK(
 
2926
        *_ex); 
2873
2927
    }
2874
2928
 
2875
2929
    /* send actual RMI request */
2885
2939
    }
2886
2940
 
2887
2941
    /* extract return value */
2888
 
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
2889
 
      _ex);SIDL_CHECK(*_ex);
 
2942
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2943
      *_ex);
2890
2944
 
2891
2945
    /* unpack out and inout arguments */
2892
2946
    sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
2971
3025
 
2972
3026
  e0->f__cast                    = (void* (*)(void*,const char*,
2973
3027
    sidl_BaseInterface*)) epv->f__cast;
2974
 
  e0->f__delete                  = (void (*)(void*,
2975
 
    sidl_BaseInterface*)) epv->f__delete;
2976
 
  e0->f__getURL                  = (char* (*)(void*,
2977
 
    sidl_BaseInterface*)) epv->f__getURL;
2978
 
  e0->f__raddRef                 = (void (*)(void*,
2979
 
    sidl_BaseInterface*)) epv->f__raddRef;
2980
 
  e0->f__isRemote                = (sidl_bool (*)(void*,
2981
 
    sidl_BaseInterface*)) epv->f__isRemote;
2982
 
  e0->f__set_hooks               = (void (*)(void*,int32_t,
 
3028
  e0->f__delete                  = (void (*)(void*,sidl_BaseInterface*)) 
 
3029
    epv->f__delete;
 
3030
  e0->f__getURL                  = (char* (*)(void*,sidl_BaseInterface*)) 
 
3031
    epv->f__getURL;
 
3032
  e0->f__raddRef                 = (void (*)(void*,sidl_BaseInterface*)) 
 
3033
    epv->f__raddRef;
 
3034
  e0->f__isRemote                = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
3035
    epv->f__isRemote;
 
3036
  e0->f__set_hooks               = (void (*)(void*,int32_t, 
2983
3037
    sidl_BaseInterface*)) epv->f__set_hooks;
2984
 
  e0->f__exec                    = (void (*)(void*,const char*,
2985
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
2986
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
2987
 
  e0->f_SetCommunicator          = (int32_t (*)(void*,
2988
 
    struct bHYPRE_MPICommunicator__object*,
2989
 
    struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
2990
 
  e0->f_Destroy                  = (void (*)(void*,
2991
 
    struct sidl_BaseInterface__object **)) epv->f_Destroy;
 
3038
  e0->f__exec                    = (void (*)(void*,const char*,struct 
 
3039
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3040
    sidl_BaseInterface__object **)) epv->f__exec;
 
3041
  e0->f_SetCommunicator          = (int32_t (*)(void*,struct 
 
3042
    bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
3043
    epv->f_SetCommunicator;
 
3044
  e0->f_Destroy                  = (void (*)(void*,struct 
 
3045
    sidl_BaseInterface__object **)) epv->f_Destroy;
2992
3046
  e0->f_SetIntParameter          = (int32_t (*)(void*,const char*,int32_t,
2993
3047
    struct sidl_BaseInterface__object **)) epv->f_SetIntParameter;
2994
 
  e0->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,
2995
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
 
3048
  e0->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,struct 
 
3049
    sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
2996
3050
  e0->f_SetStringParameter       = (int32_t (*)(void*,const char*,const char*,
2997
3051
    struct sidl_BaseInterface__object **)) epv->f_SetStringParameter;
2998
 
  e0->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,
2999
 
    struct sidl_int__array*,
3000
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray1Parameter;
3001
 
  e0->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,
3002
 
    struct sidl_int__array*,
3003
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray2Parameter;
3004
 
  e0->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,
3005
 
    struct sidl_double__array*,
3006
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray1Parameter;
3007
 
  e0->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,
3008
 
    struct sidl_double__array*,
3009
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray2Parameter;
 
3052
  e0->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,struct 
 
3053
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3054
    epv->f_SetIntArray1Parameter;
 
3055
  e0->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,struct 
 
3056
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3057
    epv->f_SetIntArray2Parameter;
 
3058
  e0->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,struct 
 
3059
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3060
    epv->f_SetDoubleArray1Parameter;
 
3061
  e0->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,struct 
 
3062
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3063
    epv->f_SetDoubleArray2Parameter;
3010
3064
  e0->f_GetIntValue              = (int32_t (*)(void*,const char*,int32_t*,
3011
3065
    struct sidl_BaseInterface__object **)) epv->f_GetIntValue;
3012
3066
  e0->f_GetDoubleValue           = (int32_t (*)(void*,const char*,double*,
3013
3067
    struct sidl_BaseInterface__object **)) epv->f_GetDoubleValue;
3014
 
  e0->f_Setup                    = (int32_t (*)(void*,
3015
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,
3016
 
    struct sidl_BaseInterface__object **)) epv->f_Setup;
3017
 
  e0->f_Apply                    = (int32_t (*)(void*,
3018
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3019
 
    struct sidl_BaseInterface__object **)) epv->f_Apply;
3020
 
  e0->f_ApplyAdjoint             = (int32_t (*)(void*,
3021
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3022
 
    struct sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
3023
 
  e0->f_addRef                   = (void (*)(void*,
3024
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3025
 
  e0->f_deleteRef                = (void (*)(void*,
3026
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
3027
 
  e0->f_isSame                   = (sidl_bool (*)(void*,
3028
 
    struct sidl_BaseInterface__object*,
3029
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3030
 
  e0->f_isType                   = (sidl_bool (*)(void*,const char*,
3031
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
3068
  e0->f_Setup                    = (int32_t (*)(void*,struct 
 
3069
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,struct 
 
3070
    sidl_BaseInterface__object **)) epv->f_Setup;
 
3071
  e0->f_Apply                    = (int32_t (*)(void*,struct 
 
3072
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3073
    sidl_BaseInterface__object **)) epv->f_Apply;
 
3074
  e0->f_ApplyAdjoint             = (int32_t (*)(void*,struct 
 
3075
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3076
    sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
 
3077
  e0->f_addRef                   = (void (*)(void*,struct 
 
3078
    sidl_BaseInterface__object **)) epv->f_addRef;
 
3079
  e0->f_deleteRef                = (void (*)(void*,struct 
 
3080
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3081
  e0->f_isSame                   = (sidl_bool (*)(void*,struct 
 
3082
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
3083
    epv->f_isSame;
 
3084
  e0->f_isType                   = (sidl_bool (*)(void*,const char*,struct 
 
3085
    sidl_BaseInterface__object **)) epv->f_isType;
3032
3086
  e0->f_getClassInfo             = (struct sidl_ClassInfo__object* (*)(void*,
3033
3087
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
3034
3088
 
3035
3089
  e1->f__cast                    = (void* (*)(void*,const char*,
3036
3090
    sidl_BaseInterface*)) epv->f__cast;
3037
 
  e1->f__delete                  = (void (*)(void*,
3038
 
    sidl_BaseInterface*)) epv->f__delete;
3039
 
  e1->f__getURL                  = (char* (*)(void*,
3040
 
    sidl_BaseInterface*)) epv->f__getURL;
3041
 
  e1->f__raddRef                 = (void (*)(void*,
3042
 
    sidl_BaseInterface*)) epv->f__raddRef;
3043
 
  e1->f__isRemote                = (sidl_bool (*)(void*,
3044
 
    sidl_BaseInterface*)) epv->f__isRemote;
3045
 
  e1->f__set_hooks               = (void (*)(void*,int32_t,
 
3091
  e1->f__delete                  = (void (*)(void*,sidl_BaseInterface*)) 
 
3092
    epv->f__delete;
 
3093
  e1->f__getURL                  = (char* (*)(void*,sidl_BaseInterface*)) 
 
3094
    epv->f__getURL;
 
3095
  e1->f__raddRef                 = (void (*)(void*,sidl_BaseInterface*)) 
 
3096
    epv->f__raddRef;
 
3097
  e1->f__isRemote                = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
3098
    epv->f__isRemote;
 
3099
  e1->f__set_hooks               = (void (*)(void*,int32_t, 
3046
3100
    sidl_BaseInterface*)) epv->f__set_hooks;
3047
 
  e1->f__exec                    = (void (*)(void*,const char*,
3048
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
3049
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
3050
 
  e1->f_SetOperator              = (int32_t (*)(void*,
3051
 
    struct bHYPRE_Operator__object*,
3052
 
    struct sidl_BaseInterface__object **)) epv->f_SetOperator;
3053
 
  e1->f_SetTolerance             = (int32_t (*)(void*,double,
3054
 
    struct sidl_BaseInterface__object **)) epv->f_SetTolerance;
3055
 
  e1->f_SetMaxIterations         = (int32_t (*)(void*,int32_t,
3056
 
    struct sidl_BaseInterface__object **)) epv->f_SetMaxIterations;
3057
 
  e1->f_SetLogging               = (int32_t (*)(void*,int32_t,
3058
 
    struct sidl_BaseInterface__object **)) epv->f_SetLogging;
3059
 
  e1->f_SetPrintLevel            = (int32_t (*)(void*,int32_t,
3060
 
    struct sidl_BaseInterface__object **)) epv->f_SetPrintLevel;
3061
 
  e1->f_GetNumIterations         = (int32_t (*)(void*,int32_t*,
3062
 
    struct sidl_BaseInterface__object **)) epv->f_GetNumIterations;
3063
 
  e1->f_GetRelResidualNorm       = (int32_t (*)(void*,double*,
3064
 
    struct sidl_BaseInterface__object **)) epv->f_GetRelResidualNorm;
3065
 
  e1->f_SetCommunicator          = (int32_t (*)(void*,
3066
 
    struct bHYPRE_MPICommunicator__object*,
3067
 
    struct sidl_BaseInterface__object **)) epv->f_SetCommunicator;
3068
 
  e1->f_Destroy                  = (void (*)(void*,
3069
 
    struct sidl_BaseInterface__object **)) epv->f_Destroy;
 
3101
  e1->f__exec                    = (void (*)(void*,const char*,struct 
 
3102
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3103
    sidl_BaseInterface__object **)) epv->f__exec;
 
3104
  e1->f_SetOperator              = (int32_t (*)(void*,struct 
 
3105
    bHYPRE_Operator__object*,struct sidl_BaseInterface__object **)) 
 
3106
    epv->f_SetOperator;
 
3107
  e1->f_SetTolerance             = (int32_t (*)(void*,double,struct 
 
3108
    sidl_BaseInterface__object **)) epv->f_SetTolerance;
 
3109
  e1->f_SetMaxIterations         = (int32_t (*)(void*,int32_t,struct 
 
3110
    sidl_BaseInterface__object **)) epv->f_SetMaxIterations;
 
3111
  e1->f_SetLogging               = (int32_t (*)(void*,int32_t,struct 
 
3112
    sidl_BaseInterface__object **)) epv->f_SetLogging;
 
3113
  e1->f_SetPrintLevel            = (int32_t (*)(void*,int32_t,struct 
 
3114
    sidl_BaseInterface__object **)) epv->f_SetPrintLevel;
 
3115
  e1->f_GetNumIterations         = (int32_t (*)(void*,int32_t*,struct 
 
3116
    sidl_BaseInterface__object **)) epv->f_GetNumIterations;
 
3117
  e1->f_GetRelResidualNorm       = (int32_t (*)(void*,double*,struct 
 
3118
    sidl_BaseInterface__object **)) epv->f_GetRelResidualNorm;
 
3119
  e1->f_SetCommunicator          = (int32_t (*)(void*,struct 
 
3120
    bHYPRE_MPICommunicator__object*,struct sidl_BaseInterface__object **)) 
 
3121
    epv->f_SetCommunicator;
 
3122
  e1->f_Destroy                  = (void (*)(void*,struct 
 
3123
    sidl_BaseInterface__object **)) epv->f_Destroy;
3070
3124
  e1->f_SetIntParameter          = (int32_t (*)(void*,const char*,int32_t,
3071
3125
    struct sidl_BaseInterface__object **)) epv->f_SetIntParameter;
3072
 
  e1->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,
3073
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
 
3126
  e1->f_SetDoubleParameter       = (int32_t (*)(void*,const char*,double,struct 
 
3127
    sidl_BaseInterface__object **)) epv->f_SetDoubleParameter;
3074
3128
  e1->f_SetStringParameter       = (int32_t (*)(void*,const char*,const char*,
3075
3129
    struct sidl_BaseInterface__object **)) epv->f_SetStringParameter;
3076
 
  e1->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,
3077
 
    struct sidl_int__array*,
3078
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray1Parameter;
3079
 
  e1->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,
3080
 
    struct sidl_int__array*,
3081
 
    struct sidl_BaseInterface__object **)) epv->f_SetIntArray2Parameter;
3082
 
  e1->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,
3083
 
    struct sidl_double__array*,
3084
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray1Parameter;
3085
 
  e1->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,
3086
 
    struct sidl_double__array*,
3087
 
    struct sidl_BaseInterface__object **)) epv->f_SetDoubleArray2Parameter;
 
3130
  e1->f_SetIntArray1Parameter    = (int32_t (*)(void*,const char*,struct 
 
3131
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3132
    epv->f_SetIntArray1Parameter;
 
3133
  e1->f_SetIntArray2Parameter    = (int32_t (*)(void*,const char*,struct 
 
3134
    sidl_int__array*,struct sidl_BaseInterface__object **)) 
 
3135
    epv->f_SetIntArray2Parameter;
 
3136
  e1->f_SetDoubleArray1Parameter = (int32_t (*)(void*,const char*,struct 
 
3137
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3138
    epv->f_SetDoubleArray1Parameter;
 
3139
  e1->f_SetDoubleArray2Parameter = (int32_t (*)(void*,const char*,struct 
 
3140
    sidl_double__array*,struct sidl_BaseInterface__object **)) 
 
3141
    epv->f_SetDoubleArray2Parameter;
3088
3142
  e1->f_GetIntValue              = (int32_t (*)(void*,const char*,int32_t*,
3089
3143
    struct sidl_BaseInterface__object **)) epv->f_GetIntValue;
3090
3144
  e1->f_GetDoubleValue           = (int32_t (*)(void*,const char*,double*,
3091
3145
    struct sidl_BaseInterface__object **)) epv->f_GetDoubleValue;
3092
 
  e1->f_Setup                    = (int32_t (*)(void*,
3093
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,
3094
 
    struct sidl_BaseInterface__object **)) epv->f_Setup;
3095
 
  e1->f_Apply                    = (int32_t (*)(void*,
3096
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3097
 
    struct sidl_BaseInterface__object **)) epv->f_Apply;
3098
 
  e1->f_ApplyAdjoint             = (int32_t (*)(void*,
3099
 
    struct bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,
3100
 
    struct sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
3101
 
  e1->f_addRef                   = (void (*)(void*,
3102
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3103
 
  e1->f_deleteRef                = (void (*)(void*,
3104
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
3105
 
  e1->f_isSame                   = (sidl_bool (*)(void*,
3106
 
    struct sidl_BaseInterface__object*,
3107
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3108
 
  e1->f_isType                   = (sidl_bool (*)(void*,const char*,
3109
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
3146
  e1->f_Setup                    = (int32_t (*)(void*,struct 
 
3147
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object*,struct 
 
3148
    sidl_BaseInterface__object **)) epv->f_Setup;
 
3149
  e1->f_Apply                    = (int32_t (*)(void*,struct 
 
3150
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3151
    sidl_BaseInterface__object **)) epv->f_Apply;
 
3152
  e1->f_ApplyAdjoint             = (int32_t (*)(void*,struct 
 
3153
    bHYPRE_Vector__object*,struct bHYPRE_Vector__object**,struct 
 
3154
    sidl_BaseInterface__object **)) epv->f_ApplyAdjoint;
 
3155
  e1->f_addRef                   = (void (*)(void*,struct 
 
3156
    sidl_BaseInterface__object **)) epv->f_addRef;
 
3157
  e1->f_deleteRef                = (void (*)(void*,struct 
 
3158
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3159
  e1->f_isSame                   = (sidl_bool (*)(void*,struct 
 
3160
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
3161
    epv->f_isSame;
 
3162
  e1->f_isType                   = (sidl_bool (*)(void*,const char*,struct 
 
3163
    sidl_BaseInterface__object **)) epv->f_isType;
3110
3164
  e1->f_getClassInfo             = (struct sidl_ClassInfo__object* (*)(void*,
3111
3165
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
3112
3166
 
3120
3174
    sidl_BaseInterface*)) epv->f__raddRef;
3121
3175
  e2->f__isRemote    = (sidl_bool (*)(struct sidl_BaseClass__object*,
3122
3176
    sidl_BaseInterface*)) epv->f__isRemote;
3123
 
  e2->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t,
 
3177
  e2->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t, 
3124
3178
    sidl_BaseInterface*)) epv->f__set_hooks;
3125
3179
  e2->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,
3126
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
3127
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
3128
 
  e2->f_addRef       = (void (*)(struct sidl_BaseClass__object*,
3129
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3130
 
  e2->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,
3131
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
3132
 
  e2->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,
3133
 
    struct sidl_BaseInterface__object*,
3134
 
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3135
 
  e2->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,
3136
 
    const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
3180
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3181
    sidl_BaseInterface__object **)) epv->f__exec;
 
3182
  e2->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct 
 
3183
    sidl_BaseInterface__object **)) epv->f_addRef;
 
3184
  e2->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct 
 
3185
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3186
  e2->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct 
 
3187
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
3188
    epv->f_isSame;
 
3189
  e2->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const 
 
3190
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
3137
3191
  e2->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
3138
 
    sidl_BaseClass__object*,
3139
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
3192
    sidl_BaseClass__object*,struct sidl_BaseInterface__object **)) 
 
3193
    epv->f_getClassInfo;
3140
3194
 
3141
 
  e3->f__cast        = (void* (*)(void*,const char*,
3142
 
    sidl_BaseInterface*)) epv->f__cast;
 
3195
  e3->f__cast        = (void* (*)(void*,const char*,sidl_BaseInterface*)) 
 
3196
    epv->f__cast;
3143
3197
  e3->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
3144
3198
  e3->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
3145
3199
  e3->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
3146
 
  e3->f__isRemote    = (sidl_bool (*)(void*,
3147
 
    sidl_BaseInterface*)) epv->f__isRemote;
3148
 
  e3->f__set_hooks   = (void (*)(void*,int32_t,
3149
 
    sidl_BaseInterface*)) epv->f__set_hooks;
3150
 
  e3->f__exec        = (void (*)(void*,const char*,
3151
 
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
3152
 
    struct sidl_BaseInterface__object **)) epv->f__exec;
3153
 
  e3->f_addRef       = (void (*)(void*,
3154
 
    struct sidl_BaseInterface__object **)) epv->f_addRef;
3155
 
  e3->f_deleteRef    = (void (*)(void*,
3156
 
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
3200
  e3->f__isRemote    = (sidl_bool (*)(void*,sidl_BaseInterface*)) 
 
3201
    epv->f__isRemote;
 
3202
  e3->f__set_hooks   = (void (*)(void*,int32_t, sidl_BaseInterface*)) 
 
3203
    epv->f__set_hooks;
 
3204
  e3->f__exec        = (void (*)(void*,const char*,struct 
 
3205
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
3206
    sidl_BaseInterface__object **)) epv->f__exec;
 
3207
  e3->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
3208
    epv->f_addRef;
 
3209
  e3->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
3210
    epv->f_deleteRef;
3157
3211
  e3->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
3158
3212
    struct sidl_BaseInterface__object **)) epv->f_isSame;
3159
 
  e3->f_isType       = (sidl_bool (*)(void*,const char*,
3160
 
    struct sidl_BaseInterface__object **)) epv->f_isType;
3161
 
  e3->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
3162
 
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
3213
  e3->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
3214
    sidl_BaseInterface__object **)) epv->f_isType;
 
3215
  e3->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
3216
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
3163
3217
 
3164
3218
  s_remote_initialized = 1;
3165
3219
}
3166
3220
 
3167
3221
/* Create an instance that connects to an existing remote object. */
3168
3222
static struct bHYPRE_StructDiagScale__object*
3169
 
bHYPRE_StructDiagScale__remoteConnect(const char *url, sidl_bool ar,
 
3223
bHYPRE_StructDiagScale__remoteConnect(const char *url, sidl_bool ar, 
3170
3224
  sidl_BaseInterface *_ex)
3171
3225
{
3172
3226
  struct bHYPRE_StructDiagScale__object* self;
3182
3236
  if(url == NULL) {return NULL;}
3183
3237
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
3184
3238
  if(objectID) {
3185
 
    sidl_BaseInterface bi = 
3186
 
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
3187
 
      objectID, _ex); SIDL_CHECK(*_ex);
 
3239
    sidl_BaseInterface bi = (
 
3240
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(objectID,
 
3241
      _ex); SIDL_CHECK(*_ex);
3188
3242
    return bHYPRE_StructDiagScale__rmicast(bi,_ex);SIDL_CHECK(*_ex);
3189
3243
  }
3190
 
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar,
3191
 
    _ex ); SIDL_CHECK(*_ex);
 
3244
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex ); 
 
3245
    SIDL_CHECK(*_ex);
3192
3246
  if ( instance == NULL) { return NULL; }
3193
3247
  self =
3194
3248
    (struct bHYPRE_StructDiagScale__object*) malloc(
3233
3287
/* Create an instance that uses an already existing  */
3234
3288
/* InstanceHandle to connect to an existing remote object. */
3235
3289
static struct bHYPRE_StructDiagScale__object*
3236
 
bHYPRE_StructDiagScale__IHConnect(sidl_rmi_InstanceHandle instance,
 
3290
bHYPRE_StructDiagScale__IHConnect(sidl_rmi_InstanceHandle instance, 
3237
3291
  sidl_BaseInterface *_ex)
3238
3292
{
3239
3293
  struct bHYPRE_StructDiagScale__object* self;
3294
3348
  struct sidl_BaseClass__object* s1;
3295
3349
 
3296
3350
  struct bHYPRE_StructDiagScale__remote* r_obj;
3297
 
  sidl_rmi_InstanceHandle instance = 
3298
 
    sidl_rmi_ProtocolFactory_createInstance(url, "bHYPRE.StructDiagScale",
3299
 
    _ex ); SIDL_CHECK(*_ex);
 
3351
  sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance(
 
3352
    url, "bHYPRE.StructDiagScale", _ex ); SIDL_CHECK(*_ex);
3300
3353
  if ( instance == NULL) { return NULL; }
3301
3354
  self =
3302
3355
    (struct bHYPRE_StructDiagScale__object*) malloc(
3336
3389
 
3337
3390
  return self;
3338
3391
  EXIT:
3339
 
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance,
 
3392
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance, 
3340
3393
    &_throwaway_exception); }
3341
3394
  return NULL;
3342
3395
}
3353
3406
 
3354
3407
  *_ex = NULL;
3355
3408
  if(!connect_loaded) {
3356
 
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.StructDiagScale",
3357
 
      (void*)bHYPRE_StructDiagScale__IHConnect, _ex);
 
3409
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.StructDiagScale", (
 
3410
      void*)bHYPRE_StructDiagScale__IHConnect, _ex);
3358
3411
    connect_loaded = 1;
3359
3412
  }
3360
3413
  if (obj != NULL) {
3375
3428
 */
3376
3429
 
3377
3430
struct bHYPRE_StructDiagScale__object*
3378
 
bHYPRE_StructDiagScale__connectI(const char* url, sidl_bool ar,
3379
 
  struct sidl_BaseInterface__object **_ex)
 
3431
bHYPRE_StructDiagScale__connectI(const char* url, sidl_bool ar, struct 
 
3432
  sidl_BaseInterface__object **_ex)
3380
3433
{
3381
3434
  return bHYPRE_StructDiagScale__remoteConnect(url, ar, _ex);
3382
3435
}