← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/babel/bHYPREClient-F90/bHYPRE_Vector_fStub.c

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/babel/bHYPREClient-F90/bHYPRE_Vector_fStub.c
 
1
/*
 
2
 * File:          bHYPRE_Vector_fStub.c
 
3
 * Symbol:        bHYPRE.Vector-v1.0.0
 
4
 * Symbol Type:   interface
 
5
 * Babel Version: 1.0.0
 
6
 * Description:   Client-side glue code for bHYPRE.Vector
 
7
 * 
 
8
 * WARNING: Automatically generated; changes will be lost
 
9
 * 
 
10
 */
 
11
 
 
12
/*
 
13
 * Symbol "bHYPRE.Vector" (version 1.0.0)
 
14
 */
 
15
 
 
16
#ifndef included_bHYPRE_Vector_fStub_h
 
17
#include "bHYPRE_Vector_fStub.h"
 
18
#endif
 
19
#include <stddef.h>
 
20
#include <stdlib.h>
 
21
#include <string.h>
 
22
#include "sidlfortran.h"
 
23
#ifndef included_sidlf90array_h
 
24
#include "sidlf90array.h"
 
25
#endif
 
26
#include "sidl_header.h"
 
27
#ifndef included_sidl_interface_IOR_h
 
28
#include "sidl_interface_IOR.h"
 
29
#endif
 
30
#ifndef included_sidl_Exception_h
 
31
#include "sidl_Exception.h"
 
32
#endif
 
33
#include <stdio.h>
 
34
#include "babel_config.h"
 
35
#ifdef SIDL_DYNAMIC_LIBRARY
 
36
#include "sidl_Loader.h"
 
37
#endif
 
38
#include "bHYPRE_Vector_IOR.h"
 
39
#include "bHYPRE_Vector_fAbbrev.h"
 
40
#include "sidl_BaseException_IOR.h"
 
41
#include "sidl_BaseInterface_IOR.h"
 
42
#include "sidl_ClassInfo_IOR.h"
 
43
#include "sidl_RuntimeException_IOR.h"
 
44
#ifndef included_sidl_rmi_ConnectRegistry_h
 
45
#include "sidl_rmi_ConnectRegistry.h"
 
46
#endif
 
47
/*
 
48
 * Includes for all method dependencies.
 
49
 */
 
50
 
 
51
#ifndef included_bHYPRE_Vector_fStub_h
 
52
#include "bHYPRE_Vector_fStub.h"
 
53
#endif
 
54
#ifndef included_sidl_BaseInterface_fStub_h
 
55
#include "sidl_BaseInterface_fStub.h"
 
56
#endif
 
57
#ifndef included_sidl_ClassInfo_fStub_h
 
58
#include "sidl_ClassInfo_fStub.h"
 
59
#endif
 
60
#ifndef included_sidl_RuntimeException_fStub_h
 
61
#include "sidl_RuntimeException_fStub.h"
 
62
#endif
 
63
 
 
64
#define LANG_SPECIFIC_INIT()
 
65
/*
 
66
 * connect_loaded is a boolean value showing if the IHConnect for this object has been loaded into the connectRegistry
 
67
 */
 
68
 
 
69
static int connect_loaded = 0;
 
70
 
 
71
static struct bHYPRE_Vector__object* bHYPRE_Vector__remoteConnect(const char* 
 
72
  url, sidl_bool ar, sidl_BaseInterface *_ex);
 
73
static struct bHYPRE_Vector__object* bHYPRE_Vector__IHConnect(struct 
 
74
  sidl_rmi_InstanceHandle__object *instance,
 
75
  struct sidl_BaseInterface__object **_ex);
 
76
/*
 
77
 * Remote Connector for the class.
 
78
 */
 
79
 
 
80
void
 
81
SIDLFortran90Symbol(bhypre_vector_rconnect_m,BHYPRE_VECTOR_RCONNECT_M,bHYPRE_Vector_rConnect_m)
 
82
(
 
83
  int64_t *self,
 
84
  SIDL_F90_String url
 
85
  SIDL_F90_STR_NEAR_LEN_DECL(url),
 
86
  int64_t *exception
 
87
  SIDL_F90_STR_FAR_LEN_DECL(url)
 
88
)
 
89
{
 
90
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
91
  char* _proxy_url = NULL;
 
92
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
93
  _proxy_url =
 
94
    sidl_copy_fortran_str(SIDL_F90_STR(url),
 
95
      SIDL_F90_STR_LEN(url));
 
96
  _proxy_self = bHYPRE_Vector__remoteConnect(_proxy_url, 1, &_proxy_exception);
 
97
  if (_proxy_exception) {
 
98
    *exception = (ptrdiff_t)_proxy_exception;
 
99
  }
 
100
  else {
 
101
    *exception = (ptrdiff_t)NULL;
 
102
    *self = (ptrdiff_t)_proxy_self;
 
103
  }
 
104
  free((void *)_proxy_url);
 
105
}
 
106
/*
 
107
 * Cast method for interface and type conversions.
 
108
 */
 
109
 
 
110
void
 
111
SIDLFortran90Symbol(bhypre_vector__cast_m,BHYPRE_VECTOR__CAST_M,bHYPRE_Vector__cast_m)
 
112
(
 
113
  int64_t *ref,
 
114
  int64_t *retval,
 
115
  int64_t *exception
 
116
)
 
117
{
 
118
  struct sidl_BaseInterface__object  *_base =
 
119
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*ref;
 
120
  struct sidl_BaseInterface__object *proxy_exception;
 
121
 
 
122
  *retval = 0;
 
123
  if(!connect_loaded) {
 
124
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.Vector",
 
125
      (void*)bHYPRE_Vector__IHConnect, &proxy_exception);
 
126
    SIDL_CHECK(proxy_exception);
 
127
    connect_loaded = 1;
 
128
  }
 
129
 
 
130
  if (_base) {
 
131
    *retval = (ptrdiff_t)(
 
132
      *_base->d_epv->f__cast)(
 
133
      _base->d_object,
 
134
      "bHYPRE.Vector", &proxy_exception);
 
135
  } else {
 
136
    *retval = 0;
 
137
    proxy_exception = 0;
 
138
  }
 
139
  EXIT:
 
140
  *exception = (ptrdiff_t)proxy_exception;
 
141
}
 
142
 
 
143
/*
 
144
 * Cast method for interface and class type conversions.
 
145
 */
 
146
 
 
147
void
 
148
SIDLFortran90Symbol(bhypre_vector__cast2_m,BHYPRE_VECTOR__CAST2_M,bHYPRE_Vector__cast2_m)
 
149
(
 
150
  int64_t *self,
 
151
  SIDL_F90_String name
 
152
  SIDL_F90_STR_NEAR_LEN_DECL(name),
 
153
  int64_t *retval,
 
154
  int64_t *exception
 
155
  SIDL_F90_STR_FAR_LEN_DECL(name)
 
156
)
 
157
{
 
158
  struct bHYPRE_Vector__epv *_epv = NULL;
 
159
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
160
  char* _proxy_name = NULL;
 
161
  void* _proxy_retval = NULL;
 
162
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
163
  _proxy_self =
 
164
    (struct bHYPRE_Vector__object*)
 
165
    (ptrdiff_t)(*self);
 
166
  _proxy_name =
 
167
    sidl_copy_fortran_str(SIDL_F90_STR(name),
 
168
      SIDL_F90_STR_LEN(name));
 
169
  _epv = _proxy_self->d_epv;
 
170
  _proxy_retval = 
 
171
    (*(_epv->f__cast))(
 
172
      _proxy_self->d_object,
 
173
      _proxy_name,
 
174
      &_proxy_exception
 
175
    );
 
176
  if (_proxy_exception) {
 
177
    *exception = (ptrdiff_t)_proxy_exception;
 
178
  }
 
179
  else {
 
180
    *exception = (ptrdiff_t)NULL;
 
181
    *retval = (ptrdiff_t)_proxy_retval;
 
182
  }
 
183
  free((void *)_proxy_name);
 
184
}
 
185
 
 
186
 
 
187
/*
 
188
 * Select and execute a method by name
 
189
 */
 
190
 
 
191
void
 
192
SIDLFortran90Symbol(bhypre_vector__exec_m,BHYPRE_VECTOR__EXEC_M,bHYPRE_Vector__exec_m)
 
193
(
 
194
  int64_t *self,
 
195
  SIDL_F90_String methodName
 
196
  SIDL_F90_STR_NEAR_LEN_DECL(methodName),
 
197
  int64_t *inArgs,
 
198
  int64_t *outArgs,
 
199
  int64_t *exception
 
200
  SIDL_F90_STR_FAR_LEN_DECL(methodName)
 
201
)
 
202
{
 
203
  struct bHYPRE_Vector__epv *_epv = NULL;
 
204
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
205
  char* _proxy_methodName = NULL;
 
206
  struct sidl_rmi_Call__object* _proxy_inArgs = NULL;
 
207
  struct sidl_rmi_Return__object* _proxy_outArgs = NULL;
 
208
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
209
  _proxy_self =
 
210
    (struct bHYPRE_Vector__object*)
 
211
    (ptrdiff_t)(*self);
 
212
  _proxy_methodName =
 
213
    sidl_copy_fortran_str(SIDL_F90_STR(methodName),
 
214
      SIDL_F90_STR_LEN(methodName));
 
215
  _proxy_inArgs =
 
216
    (struct sidl_rmi_Call__object*)
 
217
    (ptrdiff_t)(*inArgs);
 
218
  _proxy_outArgs =
 
219
    (struct sidl_rmi_Return__object*)
 
220
    (ptrdiff_t)(*outArgs);
 
221
  _epv = _proxy_self->d_epv;
 
222
  (*(_epv->f__exec))(
 
223
    _proxy_self->d_object,
 
224
    _proxy_methodName,
 
225
    _proxy_inArgs,
 
226
    _proxy_outArgs,
 
227
    &_proxy_exception
 
228
  );
 
229
  if (_proxy_exception) {
 
230
    *exception = (ptrdiff_t)_proxy_exception;
 
231
  }
 
232
  else {
 
233
    *exception = (ptrdiff_t)NULL;
 
234
  }
 
235
  free((void *)_proxy_methodName);
 
236
}
 
237
 
 
238
 
 
239
/*
 
240
 * Get the URL of the Implementation of this object (for RMI)
 
241
 */
 
242
 
 
243
void
 
244
SIDLFortran90Symbol(bhypre_vector__geturl_m,BHYPRE_VECTOR__GETURL_M,bHYPRE_Vector__getURL_m)
 
245
(
 
246
  int64_t *self,
 
247
  SIDL_F90_String retval
 
248
  SIDL_F90_STR_NEAR_LEN_DECL(retval),
 
249
  int64_t *exception
 
250
  SIDL_F90_STR_FAR_LEN_DECL(retval)
 
251
)
 
252
{
 
253
  struct bHYPRE_Vector__epv *_epv = NULL;
 
254
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
255
  char* _proxy_retval = NULL;
 
256
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
257
  _proxy_self =
 
258
    (struct bHYPRE_Vector__object*)
 
259
    (ptrdiff_t)(*self);
 
260
  _epv = _proxy_self->d_epv;
 
261
  _proxy_retval = 
 
262
    (*(_epv->f__getURL))(
 
263
      _proxy_self->d_object,
 
264
      &_proxy_exception
 
265
    );
 
266
  if (_proxy_exception) {
 
267
    *exception = (ptrdiff_t)_proxy_exception;
 
268
  }
 
269
  else {
 
270
    *exception = (ptrdiff_t)NULL;
 
271
    sidl_copy_c_str(
 
272
      SIDL_F90_STR(retval),
 
273
      SIDL_F90_STR_LEN(retval),
 
274
      _proxy_retval);
 
275
  }
 
276
  free((void *)_proxy_retval);
 
277
}
 
278
 
 
279
 
 
280
/*
 
281
 * TRUE if this object is remote, false if local
 
282
 */
 
283
 
 
284
void
 
285
SIDLFortran90Symbol(bhypre_vector__isremote_m,BHYPRE_VECTOR__ISREMOTE_M,bHYPRE_Vector__isRemote_m)
 
286
(
 
287
  int64_t *self,
 
288
  SIDL_F90_Bool *retval,
 
289
  int64_t *exception
 
290
)
 
291
{
 
292
  struct bHYPRE_Vector__epv *_epv = NULL;
 
293
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
294
  sidl_bool _proxy_retval;
 
295
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
296
  _proxy_self =
 
297
    (struct bHYPRE_Vector__object*)
 
298
    (ptrdiff_t)(*self);
 
299
  _epv = _proxy_self->d_epv;
 
300
  _proxy_retval = 
 
301
    (*(_epv->f__isRemote))(
 
302
      _proxy_self->d_object,
 
303
      &_proxy_exception
 
304
    );
 
305
  if (_proxy_exception) {
 
306
    *exception = (ptrdiff_t)_proxy_exception;
 
307
  }
 
308
  else {
 
309
    *exception = (ptrdiff_t)NULL;
 
310
    *retval = ((_proxy_retval == TRUE) ? SIDL_F90_TRUE : SIDL_F90_FALSE);
 
311
  }
 
312
}
 
313
 
 
314
 
 
315
/*
 
316
 * TRUE if this object is remote, false if local
 
317
 */
 
318
 
 
319
void
 
320
SIDLFortran90Symbol(bhypre_vector__islocal_m,BHYPRE_VECTOR__ISLOCAL_M,bHYPRE_Vector__isLocal_m)
 
321
(
 
322
  int64_t *self,
 
323
  SIDL_F90_Bool *retval,
 
324
  int64_t *exception
 
325
)
 
326
{
 
327
  struct bHYPRE_Vector__epv *_epv = NULL;
 
328
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
329
  sidl_bool _proxy_retval;
 
330
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
331
  _proxy_self =
 
332
    (struct bHYPRE_Vector__object*)
 
333
    (ptrdiff_t)(*self);
 
334
  _epv = _proxy_self->d_epv;
 
335
  _proxy_retval = 
 
336
    !(*(_epv->f__isRemote))(
 
337
      _proxy_self->d_object,
 
338
      &_proxy_exception
 
339
    );
 
340
  if (_proxy_exception) {
 
341
    *exception = (ptrdiff_t)_proxy_exception;
 
342
  }
 
343
  else {
 
344
    *exception = (ptrdiff_t)NULL;
 
345
    *retval = ((_proxy_retval == TRUE) ? SIDL_F90_TRUE : SIDL_F90_FALSE);
 
346
  }
 
347
}
 
348
 
 
349
 
 
350
/*
 
351
 * Method to set whether or not method hooks should be invoked.
 
352
 */
 
353
 
 
354
void
 
355
SIDLFortran90Symbol(bhypre_vector__set_hooks_m,BHYPRE_VECTOR__SET_HOOKS_M,bHYPRE_Vector__set_hooks_m)
 
356
(
 
357
  int64_t *self,
 
358
  SIDL_F90_Bool *on,
 
359
  int64_t *exception
 
360
)
 
361
{
 
362
  struct bHYPRE_Vector__epv *_epv = NULL;
 
363
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
364
  sidl_bool _proxy_on;
 
365
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
366
  _proxy_self =
 
367
    (struct bHYPRE_Vector__object*)
 
368
    (ptrdiff_t)(*self);
 
369
  _proxy_on = ((*on == SIDL_F90_TRUE) ? TRUE : FALSE);
 
370
  _epv = _proxy_self->d_epv;
 
371
  (*(_epv->f__set_hooks))(
 
372
    _proxy_self->d_object,
 
373
    _proxy_on,
 
374
    &_proxy_exception
 
375
  );
 
376
  if (_proxy_exception) {
 
377
    *exception = (ptrdiff_t)_proxy_exception;
 
378
  }
 
379
  else {
 
380
    *exception = (ptrdiff_t)NULL;
 
381
  }
 
382
}
 
383
 
 
384
/*
 
385
 * Set {\tt self} to 0.
 
386
 */
 
387
 
 
388
void
 
389
SIDLFortran90Symbol(bhypre_vector_clear_m,BHYPRE_VECTOR_CLEAR_M,bHYPRE_Vector_Clear_m)
 
390
(
 
391
  int64_t *self,
 
392
  int32_t *retval,
 
393
  int64_t *exception
 
394
)
 
395
{
 
396
  struct bHYPRE_Vector__epv *_epv = NULL;
 
397
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
398
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
399
  _proxy_self =
 
400
    (struct bHYPRE_Vector__object*)
 
401
    (ptrdiff_t)(*self);
 
402
  _epv = _proxy_self->d_epv;
 
403
  *retval = 
 
404
    (*(_epv->f_Clear))(
 
405
      _proxy_self->d_object,
 
406
      &_proxy_exception
 
407
    );
 
408
  if (_proxy_exception) {
 
409
    *exception = (ptrdiff_t)_proxy_exception;
 
410
  }
 
411
  else {
 
412
    *exception = (ptrdiff_t)NULL;
 
413
  }
 
414
}
 
415
 
 
416
/*
 
417
 * Copy data from x into {\tt self}.
 
418
 */
 
419
 
 
420
void
 
421
SIDLFortran90Symbol(bhypre_vector_copy_m,BHYPRE_VECTOR_COPY_M,bHYPRE_Vector_Copy_m)
 
422
(
 
423
  int64_t *self,
 
424
  int64_t *x,
 
425
  int32_t *retval,
 
426
  int64_t *exception
 
427
)
 
428
{
 
429
  struct bHYPRE_Vector__epv *_epv = NULL;
 
430
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
431
  struct bHYPRE_Vector__object* _proxy_x = NULL;
 
432
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
433
  _proxy_self =
 
434
    (struct bHYPRE_Vector__object*)
 
435
    (ptrdiff_t)(*self);
 
436
  _proxy_x =
 
437
    (struct bHYPRE_Vector__object*)
 
438
    (ptrdiff_t)(*x);
 
439
  _epv = _proxy_self->d_epv;
 
440
  *retval = 
 
441
    (*(_epv->f_Copy))(
 
442
      _proxy_self->d_object,
 
443
      _proxy_x,
 
444
      &_proxy_exception
 
445
    );
 
446
  if (_proxy_exception) {
 
447
    *exception = (ptrdiff_t)_proxy_exception;
 
448
  }
 
449
  else {
 
450
    *exception = (ptrdiff_t)NULL;
 
451
  }
 
452
}
 
453
 
 
454
/*
 
455
 * Create an {\tt x} compatible with {\tt self}.
 
456
 * The new vector's data is not specified.
 
457
 * 
 
458
 * NOTE: When this method is used in an inherited class, the
 
459
 * cloned {\tt Vector} object can be cast to an object with the
 
460
 * inherited class type.
 
461
 */
 
462
 
 
463
void
 
464
SIDLFortran90Symbol(bhypre_vector_clone_m,BHYPRE_VECTOR_CLONE_M,bHYPRE_Vector_Clone_m)
 
465
(
 
466
  int64_t *self,
 
467
  int64_t *x,
 
468
  int32_t *retval,
 
469
  int64_t *exception
 
470
)
 
471
{
 
472
  struct bHYPRE_Vector__epv *_epv = NULL;
 
473
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
474
  struct bHYPRE_Vector__object* _proxy_x = NULL;
 
475
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
476
  _proxy_self =
 
477
    (struct bHYPRE_Vector__object*)
 
478
    (ptrdiff_t)(*self);
 
479
  _epv = _proxy_self->d_epv;
 
480
  *retval = 
 
481
    (*(_epv->f_Clone))(
 
482
      _proxy_self->d_object,
 
483
      &_proxy_x,
 
484
      &_proxy_exception
 
485
    );
 
486
  if (_proxy_exception) {
 
487
    *exception = (ptrdiff_t)_proxy_exception;
 
488
  }
 
489
  else {
 
490
    *exception = (ptrdiff_t)NULL;
 
491
    *x = (ptrdiff_t)_proxy_x;
 
492
  }
 
493
}
 
494
 
 
495
/*
 
496
 * Scale {\tt self} by {\tt a}.
 
497
 */
 
498
 
 
499
void
 
500
SIDLFortran90Symbol(bhypre_vector_scale_m,BHYPRE_VECTOR_SCALE_M,bHYPRE_Vector_Scale_m)
 
501
(
 
502
  int64_t *self,
 
503
  double *a,
 
504
  int32_t *retval,
 
505
  int64_t *exception
 
506
)
 
507
{
 
508
  struct bHYPRE_Vector__epv *_epv = NULL;
 
509
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
510
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
511
  _proxy_self =
 
512
    (struct bHYPRE_Vector__object*)
 
513
    (ptrdiff_t)(*self);
 
514
  _epv = _proxy_self->d_epv;
 
515
  *retval = 
 
516
    (*(_epv->f_Scale))(
 
517
      _proxy_self->d_object,
 
518
      *a,
 
519
      &_proxy_exception
 
520
    );
 
521
  if (_proxy_exception) {
 
522
    *exception = (ptrdiff_t)_proxy_exception;
 
523
  }
 
524
  else {
 
525
    *exception = (ptrdiff_t)NULL;
 
526
  }
 
527
}
 
528
 
 
529
/*
 
530
 * Compute {\tt d}, the inner-product of {\tt self} and {\tt x}.
 
531
 */
 
532
 
 
533
void
 
534
SIDLFortran90Symbol(bhypre_vector_dot_m,BHYPRE_VECTOR_DOT_M,bHYPRE_Vector_Dot_m)
 
535
(
 
536
  int64_t *self,
 
537
  int64_t *x,
 
538
  double *d,
 
539
  int32_t *retval,
 
540
  int64_t *exception
 
541
)
 
542
{
 
543
  struct bHYPRE_Vector__epv *_epv = NULL;
 
544
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
545
  struct bHYPRE_Vector__object* _proxy_x = NULL;
 
546
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
547
  _proxy_self =
 
548
    (struct bHYPRE_Vector__object*)
 
549
    (ptrdiff_t)(*self);
 
550
  _proxy_x =
 
551
    (struct bHYPRE_Vector__object*)
 
552
    (ptrdiff_t)(*x);
 
553
  _epv = _proxy_self->d_epv;
 
554
  *retval = 
 
555
    (*(_epv->f_Dot))(
 
556
      _proxy_self->d_object,
 
557
      _proxy_x,
 
558
      d,
 
559
      &_proxy_exception
 
560
    );
 
561
  if (_proxy_exception) {
 
562
    *exception = (ptrdiff_t)_proxy_exception;
 
563
  }
 
564
  else {
 
565
    *exception = (ptrdiff_t)NULL;
 
566
  }
 
567
}
 
568
 
 
569
/*
 
570
 * Add {\tt a}{\tt x} to {\tt self}.
 
571
 */
 
572
 
 
573
void
 
574
SIDLFortran90Symbol(bhypre_vector_axpy_m,BHYPRE_VECTOR_AXPY_M,bHYPRE_Vector_Axpy_m)
 
575
(
 
576
  int64_t *self,
 
577
  double *a,
 
578
  int64_t *x,
 
579
  int32_t *retval,
 
580
  int64_t *exception
 
581
)
 
582
{
 
583
  struct bHYPRE_Vector__epv *_epv = NULL;
 
584
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
585
  struct bHYPRE_Vector__object* _proxy_x = NULL;
 
586
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
587
  _proxy_self =
 
588
    (struct bHYPRE_Vector__object*)
 
589
    (ptrdiff_t)(*self);
 
590
  _proxy_x =
 
591
    (struct bHYPRE_Vector__object*)
 
592
    (ptrdiff_t)(*x);
 
593
  _epv = _proxy_self->d_epv;
 
594
  *retval = 
 
595
    (*(_epv->f_Axpy))(
 
596
      _proxy_self->d_object,
 
597
      *a,
 
598
      _proxy_x,
 
599
      &_proxy_exception
 
600
    );
 
601
  if (_proxy_exception) {
 
602
    *exception = (ptrdiff_t)_proxy_exception;
 
603
  }
 
604
  else {
 
605
    *exception = (ptrdiff_t)NULL;
 
606
  }
 
607
}
 
608
 
 
609
/*
 
610
 * <p>
 
611
 * Add one to the intrinsic reference count in the underlying object.
 
612
 * Object in <code>sidl</code> have an intrinsic reference count.
 
613
 * Objects continue to exist as long as the reference count is
 
614
 * positive. Clients should call this method whenever they
 
615
 * create another ongoing reference to an object or interface.
 
616
 * </p>
 
617
 * <p>
 
618
 * This does not have a return value because there is no language
 
619
 * independent type that can refer to an interface or a
 
620
 * class.
 
621
 * </p>
 
622
 */
 
623
 
 
624
void
 
625
SIDLFortran90Symbol(bhypre_vector_addref_m,BHYPRE_VECTOR_ADDREF_M,bHYPRE_Vector_addRef_m)
 
626
(
 
627
  int64_t *self,
 
628
  int64_t *exception
 
629
)
 
630
{
 
631
  struct bHYPRE_Vector__epv *_epv = NULL;
 
632
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
633
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
634
  _proxy_self =
 
635
    (struct bHYPRE_Vector__object*)
 
636
    (ptrdiff_t)(*self);
 
637
  _epv = _proxy_self->d_epv;
 
638
  (*(_epv->f_addRef))(
 
639
    _proxy_self->d_object,
 
640
    &_proxy_exception
 
641
  );
 
642
  if (_proxy_exception) {
 
643
    *exception = (ptrdiff_t)_proxy_exception;
 
644
  }
 
645
  else {
 
646
    *exception = (ptrdiff_t)NULL;
 
647
  }
 
648
}
 
649
 
 
650
/*
 
651
 * Decrease by one the intrinsic reference count in the underlying
 
652
 * object, and delete the object if the reference is non-positive.
 
653
 * Objects in <code>sidl</code> have an intrinsic reference count.
 
654
 * Clients should call this method whenever they remove a
 
655
 * reference to an object or interface.
 
656
 */
 
657
 
 
658
void
 
659
SIDLFortran90Symbol(bhypre_vector_deleteref_m,BHYPRE_VECTOR_DELETEREF_M,bHYPRE_Vector_deleteRef_m)
 
660
(
 
661
  int64_t *self,
 
662
  int64_t *exception
 
663
)
 
664
{
 
665
  struct bHYPRE_Vector__epv *_epv = NULL;
 
666
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
667
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
668
  _proxy_self =
 
669
    (struct bHYPRE_Vector__object*)
 
670
    (ptrdiff_t)(*self);
 
671
  _epv = _proxy_self->d_epv;
 
672
  (*(_epv->f_deleteRef))(
 
673
    _proxy_self->d_object,
 
674
    &_proxy_exception
 
675
  );
 
676
  if (_proxy_exception) {
 
677
    *exception = (ptrdiff_t)_proxy_exception;
 
678
  }
 
679
  else {
 
680
    *exception = (ptrdiff_t)NULL;
 
681
  }
 
682
}
 
683
 
 
684
/*
 
685
 * Return true if and only if <code>obj</code> refers to the same
 
686
 * object as this object.
 
687
 */
 
688
 
 
689
void
 
690
SIDLFortran90Symbol(bhypre_vector_issame_m,BHYPRE_VECTOR_ISSAME_M,bHYPRE_Vector_isSame_m)
 
691
(
 
692
  int64_t *self,
 
693
  int64_t *iobj,
 
694
  SIDL_F90_Bool *retval,
 
695
  int64_t *exception
 
696
)
 
697
{
 
698
  struct bHYPRE_Vector__epv *_epv = NULL;
 
699
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
700
  struct sidl_BaseInterface__object* _proxy_iobj = NULL;
 
701
  sidl_bool _proxy_retval;
 
702
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
703
  _proxy_self =
 
704
    (struct bHYPRE_Vector__object*)
 
705
    (ptrdiff_t)(*self);
 
706
  _proxy_iobj =
 
707
    (struct sidl_BaseInterface__object*)
 
708
    (ptrdiff_t)(*iobj);
 
709
  _epv = _proxy_self->d_epv;
 
710
  _proxy_retval = 
 
711
    (*(_epv->f_isSame))(
 
712
      _proxy_self->d_object,
 
713
      _proxy_iobj,
 
714
      &_proxy_exception
 
715
    );
 
716
  if (_proxy_exception) {
 
717
    *exception = (ptrdiff_t)_proxy_exception;
 
718
  }
 
719
  else {
 
720
    *exception = (ptrdiff_t)NULL;
 
721
    *retval = ((_proxy_retval == TRUE) ? SIDL_F90_TRUE : SIDL_F90_FALSE);
 
722
  }
 
723
}
 
724
 
 
725
/*
 
726
 * Return whether this object is an instance of the specified type.
 
727
 * The string name must be the <code>sidl</code> type name.  This
 
728
 * routine will return <code>true</code> if and only if a cast to
 
729
 * the string type name would succeed.
 
730
 */
 
731
 
 
732
void
 
733
SIDLFortran90Symbol(bhypre_vector_istype_m,BHYPRE_VECTOR_ISTYPE_M,bHYPRE_Vector_isType_m)
 
734
(
 
735
  int64_t *self,
 
736
  SIDL_F90_String name
 
737
  SIDL_F90_STR_NEAR_LEN_DECL(name),
 
738
  SIDL_F90_Bool *retval,
 
739
  int64_t *exception
 
740
  SIDL_F90_STR_FAR_LEN_DECL(name)
 
741
)
 
742
{
 
743
  struct bHYPRE_Vector__epv *_epv = NULL;
 
744
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
745
  char* _proxy_name = NULL;
 
746
  sidl_bool _proxy_retval;
 
747
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
748
  _proxy_self =
 
749
    (struct bHYPRE_Vector__object*)
 
750
    (ptrdiff_t)(*self);
 
751
  _proxy_name =
 
752
    sidl_copy_fortran_str(SIDL_F90_STR(name),
 
753
      SIDL_F90_STR_LEN(name));
 
754
  _epv = _proxy_self->d_epv;
 
755
  _proxy_retval = 
 
756
    (*(_epv->f_isType))(
 
757
      _proxy_self->d_object,
 
758
      _proxy_name,
 
759
      &_proxy_exception
 
760
    );
 
761
  if (_proxy_exception) {
 
762
    *exception = (ptrdiff_t)_proxy_exception;
 
763
  }
 
764
  else {
 
765
    *exception = (ptrdiff_t)NULL;
 
766
    *retval = ((_proxy_retval == TRUE) ? SIDL_F90_TRUE : SIDL_F90_FALSE);
 
767
  }
 
768
  free((void *)_proxy_name);
 
769
}
 
770
 
 
771
/*
 
772
 * Return the meta-data about the class implementing this interface.
 
773
 */
 
774
 
 
775
void
 
776
SIDLFortran90Symbol(bhypre_vector_getclassinfo_m,BHYPRE_VECTOR_GETCLASSINFO_M,bHYPRE_Vector_getClassInfo_m)
 
777
(
 
778
  int64_t *self,
 
779
  int64_t *retval,
 
780
  int64_t *exception
 
781
)
 
782
{
 
783
  struct bHYPRE_Vector__epv *_epv = NULL;
 
784
  struct bHYPRE_Vector__object* _proxy_self = NULL;
 
785
  struct sidl_ClassInfo__object* _proxy_retval = NULL;
 
786
  struct sidl_BaseInterface__object* _proxy_exception = NULL;
 
787
  _proxy_self =
 
788
    (struct bHYPRE_Vector__object*)
 
789
    (ptrdiff_t)(*self);
 
790
  _epv = _proxy_self->d_epv;
 
791
  _proxy_retval = 
 
792
    (*(_epv->f_getClassInfo))(
 
793
      _proxy_self->d_object,
 
794
      &_proxy_exception
 
795
    );
 
796
  if (_proxy_exception) {
 
797
    *exception = (ptrdiff_t)_proxy_exception;
 
798
  }
 
799
  else {
 
800
    *exception = (ptrdiff_t)NULL;
 
801
    *retval = (ptrdiff_t)_proxy_retval;
 
802
  }
 
803
}
 
804
 
 
805
void
 
806
SIDLFortran90Symbol(bhypre_vector__array_createcol_m,
 
807
                  BHYPRE_VECTOR__ARRAY_CREATECOL_M,
 
808
                  bHYPRE_Vector__array_createCol_m)
 
809
  (int32_t *dimen,
 
810
   int32_t lower[],
 
811
   int32_t upper[],
 
812
   int64_t *result)
 
813
{
 
814
  *result = (ptrdiff_t)
 
815
    sidl_interface__array_createCol(*dimen, lower, upper);
 
816
}
 
817
 
 
818
void
 
819
SIDLFortran90Symbol(bhypre_vector__array_createrow_m,
 
820
                  BHYPRE_VECTOR__ARRAY_CREATEROW_M,
 
821
                  bHYPRE_Vector__array_createRow_m)
 
822
  (int32_t *dimen,
 
823
   int32_t lower[],
 
824
   int32_t upper[],
 
825
   int64_t *result)
 
826
{
 
827
  *result = (ptrdiff_t)
 
828
    sidl_interface__array_createRow(*dimen, lower, upper);
 
829
}
 
830
 
 
831
void
 
832
SIDLFortran90Symbol(bhypre_vector__array_create1d_m,
 
833
                  BHYPRE_VECTOR__ARRAY_CREATE1D_M,
 
834
                  bHYPRE_Vector__array_create1d_m)
 
835
  (int32_t *len, int64_t *result)
 
836
{
 
837
  *result = (ptrdiff_t)sidl_interface__array_create1d(*len);
 
838
}
 
839
 
 
840
void
 
841
SIDLFortran90Symbol(bhypre_vector__array_create2dcol_m,
 
842
                  BHYPRE_VECTOR__ARRAY_CREATE2DCOL_M,
 
843
                  bHYPRE_Vector__array_create2dCol_m)
 
844
  (int32_t *m, int32_t *n, int64_t *result)
 
845
{
 
846
  *result = (ptrdiff_t)sidl_interface__array_create2dCol(*m, *n);
 
847
}
 
848
 
 
849
void
 
850
SIDLFortran90Symbol(bhypre_vector__array_create2drow_m,
 
851
                  BHYPRE_VECTOR__ARRAY_CREATE2DROW_M,
 
852
                  bHYPRE_Vector__array_create2dRow_m)
 
853
  (int32_t *m, int32_t *n, int64_t *result)
 
854
{
 
855
  *result = (ptrdiff_t)sidl_interface__array_create2dRow(*m, *n);
 
856
}
 
857
 
 
858
void
 
859
SIDLFortran90Symbol(bhypre_vector__array_addref_m,
 
860
                  BHYPRE_VECTOR__ARRAY_ADDREF_M,
 
861
                  bHYPRE_Vector__array_addRef_m)
 
862
  (int64_t *array)
 
863
{
 
864
  sidl_interface__array_addRef((struct sidl_interface__array 
 
865
    *)(ptrdiff_t)*array);
 
866
}
 
867
 
 
868
void
 
869
SIDLFortran90Symbol(bhypre_vector__array_deleteref_m,
 
870
                  BHYPRE_VECTOR__ARRAY_DELETEREF_M,
 
871
                  bHYPRE_Vector__array_deleteRef_m)
 
872
  (int64_t *array)
 
873
{
 
874
  sidl_interface__array_deleteRef((struct sidl_interface__array 
 
875
    *)(ptrdiff_t)*array);
 
876
}
 
877
 
 
878
void
 
879
SIDLFortran90Symbol(bhypre_vector__array_get1_m,
 
880
                  BHYPRE_VECTOR__ARRAY_GET1_M,
 
881
                  bHYPRE_Vector__array_get1_m)
 
882
  (int64_t *array, 
 
883
   int32_t *i1, 
 
884
   int64_t *result)
 
885
{
 
886
  *result = (ptrdiff_t)
 
887
    sidl_interface__array_get1((const struct sidl_interface__array 
 
888
      *)(ptrdiff_t)*array
 
889
    , *i1);
 
890
}
 
891
 
 
892
void
 
893
SIDLFortran90Symbol(bhypre_vector__array_get2_m,
 
894
                  BHYPRE_VECTOR__ARRAY_GET2_M,
 
895
                  bHYPRE_Vector__array_get2_m)
 
896
  (int64_t *array, 
 
897
   int32_t *i1, 
 
898
   int32_t *i2, 
 
899
   int64_t *result)
 
900
{
 
901
  *result = (ptrdiff_t)
 
902
    sidl_interface__array_get2((const struct sidl_interface__array 
 
903
      *)(ptrdiff_t)*array
 
904
    , *i1, *i2);
 
905
}
 
906
 
 
907
void
 
908
SIDLFortran90Symbol(bhypre_vector__array_get3_m,
 
909
                  BHYPRE_VECTOR__ARRAY_GET3_M,
 
910
                  bHYPRE_Vector__array_get3_m)
 
911
  (int64_t *array, 
 
912
   int32_t *i1, 
 
913
   int32_t *i2, 
 
914
   int32_t *i3, 
 
915
   int64_t *result)
 
916
{
 
917
  *result = (ptrdiff_t)
 
918
    sidl_interface__array_get3((const struct sidl_interface__array 
 
919
      *)(ptrdiff_t)*array
 
920
    , *i1, *i2, *i3);
 
921
}
 
922
 
 
923
void
 
924
SIDLFortran90Symbol(bhypre_vector__array_get4_m,
 
925
                  BHYPRE_VECTOR__ARRAY_GET4_M,
 
926
                  bHYPRE_Vector__array_get4_m)
 
927
  (int64_t *array, 
 
928
   int32_t *i1, 
 
929
   int32_t *i2, 
 
930
   int32_t *i3, 
 
931
   int32_t *i4, 
 
932
   int64_t *result)
 
933
{
 
934
  *result = (ptrdiff_t)
 
935
    sidl_interface__array_get4((const struct sidl_interface__array 
 
936
      *)(ptrdiff_t)*array
 
937
    , *i1, *i2, *i3, *i4);
 
938
}
 
939
 
 
940
void
 
941
SIDLFortran90Symbol(bhypre_vector__array_get5_m,
 
942
                  BHYPRE_VECTOR__ARRAY_GET5_M,
 
943
                  bHYPRE_Vector__array_get5_m)
 
944
  (int64_t *array, 
 
945
   int32_t *i1, 
 
946
   int32_t *i2, 
 
947
   int32_t *i3, 
 
948
   int32_t *i4, 
 
949
   int32_t *i5, 
 
950
   int64_t *result)
 
951
{
 
952
  *result = (ptrdiff_t)
 
953
    sidl_interface__array_get5((const struct sidl_interface__array 
 
954
      *)(ptrdiff_t)*array
 
955
    , *i1, *i2, *i3, *i4, *i5);
 
956
}
 
957
 
 
958
void
 
959
SIDLFortran90Symbol(bhypre_vector__array_get6_m,
 
960
                  BHYPRE_VECTOR__ARRAY_GET6_M,
 
961
                  bHYPRE_Vector__array_get6_m)
 
962
  (int64_t *array, 
 
963
   int32_t *i1, 
 
964
   int32_t *i2, 
 
965
   int32_t *i3, 
 
966
   int32_t *i4, 
 
967
   int32_t *i5, 
 
968
   int32_t *i6, 
 
969
   int64_t *result)
 
970
{
 
971
  *result = (ptrdiff_t)
 
972
    sidl_interface__array_get6((const struct sidl_interface__array 
 
973
      *)(ptrdiff_t)*array
 
974
    , *i1, *i2, *i3, *i4, *i5, *i6);
 
975
}
 
976
 
 
977
void
 
978
SIDLFortran90Symbol(bhypre_vector__array_get7_m,
 
979
                  BHYPRE_VECTOR__ARRAY_GET7_M,
 
980
                  bHYPRE_Vector__array_get7_m)
 
981
  (int64_t *array, 
 
982
   int32_t *i1, 
 
983
   int32_t *i2, 
 
984
   int32_t *i3, 
 
985
   int32_t *i4, 
 
986
   int32_t *i5, 
 
987
   int32_t *i6, 
 
988
   int32_t *i7, 
 
989
   int64_t *result)
 
990
{
 
991
  *result = (ptrdiff_t)
 
992
    sidl_interface__array_get7((const struct sidl_interface__array 
 
993
      *)(ptrdiff_t)*array
 
994
    , *i1, *i2, *i3, *i4, *i5, *i6, *i7);
 
995
}
 
996
 
 
997
void
 
998
SIDLFortran90Symbol(bhypre_vector__array_get_m,
 
999
                  BHYPRE_VECTOR__ARRAY_GET_M,
 
1000
                  bHYPRE_Vector__array_get_m)
 
1001
  (int64_t *array,
 
1002
   int32_t indices[],
 
1003
   int64_t *result)
 
1004
{
 
1005
  *result = (ptrdiff_t)
 
1006
    sidl_interface__array_get((const struct sidl_interface__array 
 
1007
      *)(ptrdiff_t)*array, indices);
 
1008
}
 
1009
 
 
1010
void
 
1011
SIDLFortran90Symbol(bhypre_vector__array_set1_m,
 
1012
                  BHYPRE_VECTOR__ARRAY_SET1_M,
 
1013
                  bHYPRE_Vector__array_set1_m)
 
1014
  (int64_t *array,
 
1015
   int32_t *i1,
 
1016
   int64_t *value)
 
1017
{
 
1018
  sidl_interface__array_set1((struct sidl_interface__array *)(ptrdiff_t)*array
 
1019
  , *i1, (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1020
}
 
1021
 
 
1022
void
 
1023
SIDLFortran90Symbol(bhypre_vector__array_set2_m,
 
1024
                  BHYPRE_VECTOR__ARRAY_SET2_M,
 
1025
                  bHYPRE_Vector__array_set2_m)
 
1026
  (int64_t *array,
 
1027
   int32_t *i1,
 
1028
   int32_t *i2,
 
1029
   int64_t *value)
 
1030
{
 
1031
  sidl_interface__array_set2((struct sidl_interface__array *)(ptrdiff_t)*array
 
1032
  , *i1, *i2, (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1033
}
 
1034
 
 
1035
void
 
1036
SIDLFortran90Symbol(bhypre_vector__array_set3_m,
 
1037
                  BHYPRE_VECTOR__ARRAY_SET3_M,
 
1038
                  bHYPRE_Vector__array_set3_m)
 
1039
  (int64_t *array,
 
1040
   int32_t *i1,
 
1041
   int32_t *i2,
 
1042
   int32_t *i3,
 
1043
   int64_t *value)
 
1044
{
 
1045
  sidl_interface__array_set3((struct sidl_interface__array *)(ptrdiff_t)*array
 
1046
  , *i1, *i2, *i3, (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1047
}
 
1048
 
 
1049
void
 
1050
SIDLFortran90Symbol(bhypre_vector__array_set4_m,
 
1051
                  BHYPRE_VECTOR__ARRAY_SET4_M,
 
1052
                  bHYPRE_Vector__array_set4_m)
 
1053
  (int64_t *array,
 
1054
   int32_t *i1,
 
1055
   int32_t *i2,
 
1056
   int32_t *i3,
 
1057
   int32_t *i4,
 
1058
   int64_t *value)
 
1059
{
 
1060
  sidl_interface__array_set4((struct sidl_interface__array *)(ptrdiff_t)*array
 
1061
  , *i1, *i2, *i3, *i4, (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1062
}
 
1063
 
 
1064
void
 
1065
SIDLFortran90Symbol(bhypre_vector__array_set5_m,
 
1066
                  BHYPRE_VECTOR__ARRAY_SET5_M,
 
1067
                  bHYPRE_Vector__array_set5_m)
 
1068
  (int64_t *array,
 
1069
   int32_t *i1,
 
1070
   int32_t *i2,
 
1071
   int32_t *i3,
 
1072
   int32_t *i4,
 
1073
   int32_t *i5,
 
1074
   int64_t *value)
 
1075
{
 
1076
  sidl_interface__array_set5((struct sidl_interface__array *)(ptrdiff_t)*array
 
1077
  , *i1, *i2, *i3, *i4, *i5,
 
1078
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1079
}
 
1080
 
 
1081
void
 
1082
SIDLFortran90Symbol(bhypre_vector__array_set6_m,
 
1083
                  BHYPRE_VECTOR__ARRAY_SET6_M,
 
1084
                  bHYPRE_Vector__array_set6_m)
 
1085
  (int64_t *array,
 
1086
   int32_t *i1,
 
1087
   int32_t *i2,
 
1088
   int32_t *i3,
 
1089
   int32_t *i4,
 
1090
   int32_t *i5,
 
1091
   int32_t *i6,
 
1092
   int64_t *value)
 
1093
{
 
1094
  sidl_interface__array_set6((struct sidl_interface__array *)(ptrdiff_t)*array
 
1095
  , *i1, *i2, *i3, *i4, *i5, *i6,
 
1096
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1097
}
 
1098
 
 
1099
void
 
1100
SIDLFortran90Symbol(bhypre_vector__array_set7_m,
 
1101
                  BHYPRE_VECTOR__ARRAY_SET7_M,
 
1102
                  bHYPRE_Vector__array_set7_m)
 
1103
  (int64_t *array,
 
1104
   int32_t *i1,
 
1105
   int32_t *i2,
 
1106
   int32_t *i3,
 
1107
   int32_t *i4,
 
1108
   int32_t *i5,
 
1109
   int32_t *i6,
 
1110
   int32_t *i7,
 
1111
   int64_t *value)
 
1112
{
 
1113
  sidl_interface__array_set7((struct sidl_interface__array *)(ptrdiff_t)*array
 
1114
  , *i1, *i2, *i3, *i4, *i5, *i6, *i7,
 
1115
    (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1116
}
 
1117
 
 
1118
void
 
1119
SIDLFortran90Symbol(bhypre_vector__array_set_m,
 
1120
                  BHYPRE_VECTOR__ARRAY_SET_M,
 
1121
                  bHYPRE_Vector__array_set_m)
 
1122
  (int64_t *array,
 
1123
  int32_t indices[],
 
1124
  int64_t *value)
 
1125
{
 
1126
  sidl_interface__array_set((struct sidl_interface__array *)(ptrdiff_t)*array,
 
1127
    indices, (struct sidl_BaseInterface__object *)(ptrdiff_t)*value);
 
1128
}
 
1129
 
 
1130
void
 
1131
SIDLFortran90Symbol(bhypre_vector__array_dimen_m,
 
1132
                  BHYPRE_VECTOR__ARRAY_DIMEN_M,
 
1133
                  bHYPRE_Vector__array_dimen_m)
 
1134
  (int64_t *array, int32_t *result)
 
1135
{
 
1136
  *result =
 
1137
    sidl_interface__array_dimen((struct sidl_interface__array 
 
1138
      *)(ptrdiff_t)*array);
 
1139
}
 
1140
 
 
1141
void
 
1142
SIDLFortran90Symbol(bhypre_vector__array_lower_m,
 
1143
                  BHYPRE_VECTOR__ARRAY_LOWER_M,
 
1144
                  bHYPRE_Vector__array_lower_m)
 
1145
  (int64_t *array,
 
1146
   int32_t *ind,
 
1147
   int32_t *result)
 
1148
{
 
1149
  *result = 
 
1150
    sidl_interface__array_lower((struct sidl_interface__array 
 
1151
      *)(ptrdiff_t)*array, *ind);
 
1152
}
 
1153
 
 
1154
void
 
1155
SIDLFortran90Symbol(bhypre_vector__array_upper_m,
 
1156
                  BHYPRE_VECTOR__ARRAY_UPPER_M,
 
1157
                  bHYPRE_Vector__array_upper_m)
 
1158
  (int64_t *array,
 
1159
   int32_t *ind,
 
1160
   int32_t *result)
 
1161
{
 
1162
  *result = 
 
1163
    sidl_interface__array_upper((struct sidl_interface__array 
 
1164
      *)(ptrdiff_t)*array, *ind);
 
1165
}
 
1166
 
 
1167
void
 
1168
SIDLFortran90Symbol(bhypre_vector__array_length_m,
 
1169
                  BHYPRE_VECTOR__ARRAY_LENGTH_M,
 
1170
                  bHYPRE_Vector__array_length_m)
 
1171
  (int64_t *array,
 
1172
   int32_t *ind,
 
1173
   int32_t *result)
 
1174
{
 
1175
  *result = 
 
1176
    sidl_interface__array_length((struct sidl_interface__array 
 
1177
      *)(ptrdiff_t)*array, *ind);
 
1178
}
 
1179
 
 
1180
void
 
1181
SIDLFortran90Symbol(bhypre_vector__array_stride_m,
 
1182
                  BHYPRE_VECTOR__ARRAY_STRIDE_M,
 
1183
                  bHYPRE_Vector__array_stride_m)
 
1184
  (int64_t *array,
 
1185
   int32_t *ind,
 
1186
   int32_t *result)
 
1187
{
 
1188
  *result = 
 
1189
    sidl_interface__array_stride((struct sidl_interface__array 
 
1190
      *)(ptrdiff_t)*array, *ind);
 
1191
}
 
1192
 
 
1193
void
 
1194
SIDLFortran90Symbol(bhypre_vector__array_iscolumnorder_m,
 
1195
                  BHYPRE_VECTOR__ARRAY_ISCOLUMNORDER_M,
 
1196
                  bHYPRE_Vector__array_isColumnOrder_m)
 
1197
  (int64_t *array,
 
1198
   SIDL_F90_Bool *result)
 
1199
{
 
1200
  *result = sidl_interface__array_isColumnOrder((struct sidl_interface__array 
 
1201
    *)(ptrdiff_t)*array);
 
1202
}
 
1203
 
 
1204
void
 
1205
SIDLFortran90Symbol(bhypre_vector__array_isroworder_m,
 
1206
                  BHYPRE_VECTOR__ARRAY_ISROWORDER_M,
 
1207
                  bHYPRE_Vector__array_isRowOrder_m)
 
1208
  (int64_t *array,
 
1209
   SIDL_F90_Bool *result)
 
1210
{
 
1211
  *result = sidl_interface__array_isRowOrder((struct sidl_interface__array 
 
1212
    *)(ptrdiff_t)*array);
 
1213
}
 
1214
 
 
1215
void
 
1216
SIDLFortran90Symbol(bhypre_vector__array_copy_m,
 
1217
                  BHYPRE_VECTOR__ARRAY_COPY_M,
 
1218
                  bHYPRE_Vector__array_copy_m)
 
1219
  (int64_t *src,
 
1220
   int64_t *dest)
 
1221
{
 
1222
  sidl_interface__array_copy((const struct sidl_interface__array 
 
1223
    *)(ptrdiff_t)*src,
 
1224
                             (struct sidl_interface__array *)(ptrdiff_t)*dest);
 
1225
}
 
1226
 
 
1227
void
 
1228
SIDLFortran90Symbol(bhypre_vector__array_smartcopy_m,
 
1229
                  BHYPRE_VECTOR__ARRAY_SMARTCOPY_M,
 
1230
                  bHYPRE_Vector__array_smartCopy_m)
 
1231
  (int64_t *src)
 
1232
{
 
1233
  sidl_interface__array_smartCopy((struct sidl_interface__array 
 
1234
    *)(ptrdiff_t)*src);
 
1235
}
 
1236
 
 
1237
void
 
1238
SIDLFortran90Symbol(bhypre_vector__array_slice_m,
 
1239
                  BHYPRE_VECTOR__ARRAY_SLICE_M,
 
1240
                  bHYPRE_Vector__array_slice_m)
 
1241
  (int64_t *src,
 
1242
   int32_t *dimen,
 
1243
   int32_t numElem[],
 
1244
   int32_t srcStart[],
 
1245
   int32_t srcStride[],
 
1246
   int32_t newStart[],
 
1247
   int64_t *result)
 
1248
{
 
1249
  *result = (ptrdiff_t)
 
1250
    sidl_interface__array_slice((struct sidl_interface__array *)(ptrdiff_t)*src,
 
1251
      *dimen, numElem, srcStart, srcStride, newStart);
 
1252
}
 
1253
 
 
1254
void
 
1255
SIDLFortran90Symbol(bhypre_vector__array_ensure_m,
 
1256
                  BHYPRE_VECTOR__ARRAY_ENSURE_M,
 
1257
                  bHYPRE_Vector__array_ensure_m)
 
1258
  (int64_t *src,
 
1259
   int32_t *dimen,
 
1260
   int     *ordering,
 
1261
   int64_t *result)
 
1262
{
 
1263
  *result = (ptrdiff_t)
 
1264
    sidl_interface__array_ensure((struct sidl_interface__array 
 
1265
      *)(ptrdiff_t)*src,
 
1266
    *dimen, *ordering);
 
1267
}
 
1268
 
 
1269
#include <stdlib.h>
 
1270
#include <string.h>
 
1271
#ifndef included_sidl_BaseClass_h
 
1272
#include "sidl_BaseClass.h"
 
1273
#endif
 
1274
#ifndef included_sidl_ClassInfo_h
 
1275
#include "sidl_ClassInfo.h"
 
1276
#endif
 
1277
#ifndef included_sidl_rmi_ProtocolFactory_h
 
1278
#include "sidl_rmi_ProtocolFactory.h"
 
1279
#endif
 
1280
#ifndef included_sidl_rmi_InstanceRegistry_h
 
1281
#include "sidl_rmi_InstanceRegistry.h"
 
1282
#endif
 
1283
#ifndef included_sidl_rmi_InstanceHandle_h
 
1284
#include "sidl_rmi_InstanceHandle.h"
 
1285
#endif
 
1286
#ifndef included_sidl_rmi_Invocation_h
 
1287
#include "sidl_rmi_Invocation.h"
 
1288
#endif
 
1289
#ifndef included_sidl_rmi_Response_h
 
1290
#include "sidl_rmi_Response.h"
 
1291
#endif
 
1292
#ifndef included_sidl_rmi_ServerRegistry_h
 
1293
#include "sidl_rmi_ServerRegistry.h"
 
1294
#endif
 
1295
#ifndef included_sidl_rmi_ConnectRegistry_h
 
1296
#include "sidl_rmi_ConnectRegistry.h"
 
1297
#endif
 
1298
#ifndef included_sidl_io_Serializable_h
 
1299
#include "sidl_io_Serializable.h"
 
1300
#endif
 
1301
#include "sidl_Exception.h"
 
1302
 
 
1303
#ifndef NULL
 
1304
#define NULL 0
 
1305
#endif
 
1306
 
 
1307
#include "sidl_thread.h"
 
1308
#ifdef HAVE_PTHREAD
 
1309
static struct sidl_recursive_mutex_t bHYPRE__Vector__mutex= SIDL_RECURSIVE_MUTEX_INITIALIZER;
 
1310
#define LOCK_STATIC_GLOBALS sidl_recursive_mutex_lock( &bHYPRE__Vector__mutex )
 
1311
#define UNLOCK_STATIC_GLOBALS sidl_recursive_mutex_unlock( &bHYPRE__Vector__mutex )
 
1312
/* #define HAVE_LOCKED_STATIC_GLOBALS (sidl_recursive_mutex_trylock( &bHYPRE__Vector__mutex )==EDEADLOCK) */
 
1313
#else
 
1314
#define LOCK_STATIC_GLOBALS
 
1315
#define UNLOCK_STATIC_GLOBALS
 
1316
/* #define HAVE_LOCKED_STATIC_GLOBALS (1) */
 
1317
#endif
 
1318
 
 
1319
/* Static variables to hold version of IOR */
 
1320
static const int32_t s_IOR_MAJOR_VERSION = 0;
 
1321
static const int32_t s_IOR_MINOR_VERSION = 10;
 
1322
 
 
1323
/* Static variables for managing EPV initialization. */
 
1324
static int s_remote_initialized = 0;
 
1325
 
 
1326
static struct bHYPRE__Vector__epv s_rem_epv__bhypre__vector;
 
1327
 
 
1328
static struct bHYPRE_Vector__epv s_rem_epv__bhypre_vector;
 
1329
 
 
1330
static struct sidl_BaseInterface__epv s_rem_epv__sidl_baseinterface;
 
1331
 
 
1332
 
 
1333
/* REMOTE CAST: dynamic type casting for remote objects. */
 
1334
static void* remote_bHYPRE__Vector__cast(
 
1335
  struct bHYPRE__Vector__object* self,
 
1336
  const char* name, sidl_BaseInterface* _ex)
 
1337
{
 
1338
  int
 
1339
    cmp0,
 
1340
    cmp1;
 
1341
  void* cast = NULL;
 
1342
  *_ex = NULL; /* default to no exception */
 
1343
  cmp0 = strcmp(name, "bHYPRE._Vector");
 
1344
  if (!cmp0) {
 
1345
    (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1346
    cast = self;
 
1347
    return cast;
 
1348
  }
 
1349
  else if (cmp0 < 0) {
 
1350
    cmp1 = strcmp(name, "bHYPRE.Vector");
 
1351
    if (!cmp1) {
 
1352
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1353
      cast = &((*self).d_bhypre_vector);
 
1354
      return cast;
 
1355
    }
 
1356
  }
 
1357
  else if (cmp0 > 0) {
 
1358
    cmp1 = strcmp(name, "sidl.BaseInterface");
 
1359
    if (!cmp1) {
 
1360
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1361
      cast = &((*self).d_sidl_baseinterface);
 
1362
      return cast;
 
1363
    }
 
1364
  }
 
1365
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
 
1366
    void* (*func)(struct sidl_rmi_InstanceHandle__object*,
 
1367
      struct sidl_BaseInterface__object**) = 
 
1368
      (void* (*)(struct sidl_rmi_InstanceHandle__object*,
 
1369
        struct sidl_BaseInterface__object**)) 
 
1370
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
 
1371
    cast =  (*func)(((struct bHYPRE__Vector__remote*)self->d_data)->d_ih, _ex);
 
1372
  }
 
1373
 
 
1374
  return cast;
 
1375
  EXIT:
 
1376
  return NULL;
 
1377
}
 
1378
 
 
1379
/* REMOTE DELETE: call the remote destructor for the object. */
 
1380
static void remote_bHYPRE__Vector__delete(
 
1381
  struct bHYPRE__Vector__object* self,
 
1382
  sidl_BaseInterface* _ex)
 
1383
{
 
1384
  *_ex = NULL;
 
1385
  free((void*) self);
 
1386
}
 
1387
 
 
1388
/* REMOTE GETURL: call the getURL function for the object. */
 
1389
static char* remote_bHYPRE__Vector__getURL(
 
1390
  struct bHYPRE__Vector__object* self, sidl_BaseInterface* _ex)
 
1391
{
 
1392
  struct sidl_rmi_InstanceHandle__object *conn = ((struct 
 
1393
    bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1394
  *_ex = NULL;
 
1395
  if(conn != NULL) {
 
1396
    return sidl_rmi_InstanceHandle_getObjectURL(conn, _ex);
 
1397
  }
 
1398
  return NULL;
 
1399
}
 
1400
 
 
1401
/* REMOTE ADDREF: For internal babel use only! Remote addRef. */
 
1402
static void remote_bHYPRE__Vector__raddRef(
 
1403
  struct bHYPRE__Vector__object* self,sidl_BaseInterface* _ex)
 
1404
{
 
1405
  sidl_BaseException netex = NULL;
 
1406
  /* initialize a new invocation */
 
1407
  sidl_BaseInterface _throwaway = NULL;
 
1408
  struct sidl_rmi_InstanceHandle__object *_conn = ((struct 
 
1409
    bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1410
  sidl_rmi_Response _rsvp = NULL;
 
1411
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1412
    "addRef", _ex ); SIDL_CHECK(*_ex);
 
1413
  /* send actual RMI request */
 
1414
  _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
 
1415
  /* Check for exceptions */
 
1416
  netex = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);
 
1417
  if(netex != NULL) {
 
1418
    sidl_BaseInterface throwaway_exception = NULL;
 
1419
    *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(netex,
 
1420
      &throwaway_exception);
 
1421
    return;
 
1422
  }
 
1423
 
 
1424
  /* cleanup and return */
 
1425
  EXIT:
 
1426
  if(_inv) { sidl_rmi_Invocation_deleteRef(_inv,&_throwaway); }
 
1427
  if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp,&_throwaway); }
 
1428
  return;
 
1429
}
 
1430
 
 
1431
/* REMOTE ISREMOTE: returns true if this object is Remote (it is). */
 
1432
static sidl_bool
 
1433
remote_bHYPRE__Vector__isRemote(
 
1434
    struct bHYPRE__Vector__object* self, 
 
1435
    sidl_BaseInterface *_ex) {
 
1436
  *_ex = NULL;
 
1437
  return TRUE;
 
1438
}
 
1439
 
 
1440
/* REMOTE METHOD STUB:_set_hooks */
 
1441
static void
 
1442
remote_bHYPRE__Vector__set_hooks(
 
1443
  /* in */ struct bHYPRE__Vector__object* self ,
 
1444
  /* in */ sidl_bool on,
 
1445
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1446
{
 
1447
  LANG_SPECIFIC_INIT();
 
1448
  *_ex = NULL;
 
1449
  {
 
1450
    /* initialize a new invocation */
 
1451
    sidl_BaseInterface _throwaway = NULL;
 
1452
    sidl_BaseException _be = NULL;
 
1453
    sidl_rmi_Response _rsvp = NULL;
 
1454
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1455
      bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1456
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1457
      "_set_hooks", _ex ); SIDL_CHECK(*_ex);
 
1458
 
 
1459
    /* pack in and inout arguments */
 
1460
    sidl_rmi_Invocation_packBool( _inv, "on", on, _ex);SIDL_CHECK(*_ex);
 
1461
 
 
1462
    /* send actual RMI request */
 
1463
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1464
 
 
1465
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1466
    if(_be != NULL) {
 
1467
      sidl_BaseInterface throwaway_exception = NULL;
 
1468
sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE._Vector._set_hooks.", &throwaway_exception);
 
1469
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,
 
1470
        &throwaway_exception);
 
1471
      goto EXIT;
 
1472
    }
 
1473
 
 
1474
    /* unpack out and inout arguments */
 
1475
 
 
1476
    /* cleanup and return */
 
1477
    EXIT:
 
1478
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1479
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1480
    return;
 
1481
  }
 
1482
}
 
1483
 
 
1484
/* REMOTE EXEC: call the exec function for the object. */
 
1485
static void remote_bHYPRE__Vector__exec(
 
1486
  struct bHYPRE__Vector__object* self,const char* methodName,
 
1487
  sidl_rmi_Call inArgs,
 
1488
  sidl_rmi_Return outArgs,
 
1489
  sidl_BaseInterface* _ex)
 
1490
{
 
1491
  *_ex = NULL;
 
1492
}
 
1493
 
 
1494
/* REMOTE METHOD STUB:Clear */
 
1495
static int32_t
 
1496
remote_bHYPRE__Vector_Clear(
 
1497
  /* in */ struct bHYPRE__Vector__object* self ,
 
1498
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1499
{
 
1500
  LANG_SPECIFIC_INIT();
 
1501
  *_ex = NULL;
 
1502
  {
 
1503
    /* initialize a new invocation */
 
1504
    sidl_BaseInterface _throwaway = NULL;
 
1505
    sidl_BaseException _be = NULL;
 
1506
    sidl_rmi_Response _rsvp = NULL;
 
1507
    int32_t _retval = 0;
 
1508
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1509
      bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1510
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1511
      "Clear", _ex ); SIDL_CHECK(*_ex);
 
1512
 
 
1513
    /* pack in and inout arguments */
 
1514
 
 
1515
    /* send actual RMI request */
 
1516
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1517
 
 
1518
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1519
    if(_be != NULL) {
 
1520
      sidl_BaseInterface throwaway_exception = NULL;
 
1521
sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE._Vector.Clear.", &throwaway_exception);
 
1522
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,
 
1523
        &throwaway_exception);
 
1524
      goto EXIT;
 
1525
    }
 
1526
 
 
1527
    /* extract return value */
 
1528
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
 
1529
      _ex);SIDL_CHECK(*_ex);
 
1530
 
 
1531
    /* unpack out and inout arguments */
 
1532
 
 
1533
    /* cleanup and return */
 
1534
    EXIT:
 
1535
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1536
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1537
    return _retval;
 
1538
  }
 
1539
}
 
1540
 
 
1541
/* REMOTE METHOD STUB:Copy */
 
1542
static int32_t
 
1543
remote_bHYPRE__Vector_Copy(
 
1544
  /* in */ struct bHYPRE__Vector__object* self ,
 
1545
  /* in */ struct bHYPRE_Vector__object* x,
 
1546
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1547
{
 
1548
  LANG_SPECIFIC_INIT();
 
1549
  *_ex = NULL;
 
1550
  {
 
1551
    /* initialize a new invocation */
 
1552
    sidl_BaseInterface _throwaway = NULL;
 
1553
    sidl_BaseException _be = NULL;
 
1554
    sidl_rmi_Response _rsvp = NULL;
 
1555
    int32_t _retval = 0;
 
1556
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1557
      bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1558
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1559
      "Copy", _ex ); SIDL_CHECK(*_ex);
 
1560
 
 
1561
    /* pack in and inout arguments */
 
1562
    if(x){
 
1563
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)x,
 
1564
        _ex);SIDL_CHECK(*_ex);
 
1565
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
 
1566
      free((void*)_url);
 
1567
    } else {
 
1568
      sidl_rmi_Invocation_packString( _inv, "x", NULL, _ex);SIDL_CHECK(*_ex);
 
1569
    }
 
1570
 
 
1571
    /* send actual RMI request */
 
1572
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1573
 
 
1574
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1575
    if(_be != NULL) {
 
1576
      sidl_BaseInterface throwaway_exception = NULL;
 
1577
sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE._Vector.Copy.", &throwaway_exception);
 
1578
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,
 
1579
        &throwaway_exception);
 
1580
      goto EXIT;
 
1581
    }
 
1582
 
 
1583
    /* extract return value */
 
1584
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
 
1585
      _ex);SIDL_CHECK(*_ex);
 
1586
 
 
1587
    /* unpack out and inout arguments */
 
1588
 
 
1589
    /* cleanup and return */
 
1590
    EXIT:
 
1591
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1592
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1593
    return _retval;
 
1594
  }
 
1595
}
 
1596
 
 
1597
/* REMOTE METHOD STUB:Clone */
 
1598
static int32_t
 
1599
remote_bHYPRE__Vector_Clone(
 
1600
  /* in */ struct bHYPRE__Vector__object* self ,
 
1601
  /* out */ struct bHYPRE_Vector__object** x,
 
1602
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1603
{
 
1604
  LANG_SPECIFIC_INIT();
 
1605
  *_ex = NULL;
 
1606
  {
 
1607
    /* initialize a new invocation */
 
1608
    sidl_BaseInterface _throwaway = NULL;
 
1609
    sidl_BaseException _be = NULL;
 
1610
    sidl_rmi_Response _rsvp = NULL;
 
1611
    char* x_str= NULL;
 
1612
    int32_t _retval = 0;
 
1613
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1614
      bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1615
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1616
      "Clone", _ex ); SIDL_CHECK(*_ex);
 
1617
 
 
1618
    /* pack in and inout arguments */
 
1619
 
 
1620
    /* send actual RMI request */
 
1621
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1622
 
 
1623
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1624
    if(_be != NULL) {
 
1625
      sidl_BaseInterface throwaway_exception = NULL;
 
1626
sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE._Vector.Clone.", &throwaway_exception);
 
1627
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,
 
1628
        &throwaway_exception);
 
1629
      goto EXIT;
 
1630
    }
 
1631
 
 
1632
    /* extract return value */
 
1633
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
 
1634
      _ex);SIDL_CHECK(*_ex);
 
1635
 
 
1636
    /* unpack out and inout arguments */
 
1637
    sidl_rmi_Response_unpackString( _rsvp, "x", &x_str, _ex);SIDL_CHECK(*_ex);
 
1638
    *x = bHYPRE_Vector__connectI(x_str, FALSE, _ex);SIDL_CHECK(*_ex);
 
1639
 
 
1640
    /* cleanup and return */
 
1641
    EXIT:
 
1642
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1643
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1644
    return _retval;
 
1645
  }
 
1646
}
 
1647
 
 
1648
/* REMOTE METHOD STUB:Scale */
 
1649
static int32_t
 
1650
remote_bHYPRE__Vector_Scale(
 
1651
  /* in */ struct bHYPRE__Vector__object* self ,
 
1652
  /* in */ double a,
 
1653
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1654
{
 
1655
  LANG_SPECIFIC_INIT();
 
1656
  *_ex = NULL;
 
1657
  {
 
1658
    /* initialize a new invocation */
 
1659
    sidl_BaseInterface _throwaway = NULL;
 
1660
    sidl_BaseException _be = NULL;
 
1661
    sidl_rmi_Response _rsvp = NULL;
 
1662
    int32_t _retval = 0;
 
1663
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1664
      bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1665
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1666
      "Scale", _ex ); SIDL_CHECK(*_ex);
 
1667
 
 
1668
    /* pack in and inout arguments */
 
1669
    sidl_rmi_Invocation_packDouble( _inv, "a", a, _ex);SIDL_CHECK(*_ex);
 
1670
 
 
1671
    /* send actual RMI request */
 
1672
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1673
 
 
1674
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1675
    if(_be != NULL) {
 
1676
      sidl_BaseInterface throwaway_exception = NULL;
 
1677
sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE._Vector.Scale.", &throwaway_exception);
 
1678
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,
 
1679
        &throwaway_exception);
 
1680
      goto EXIT;
 
1681
    }
 
1682
 
 
1683
    /* extract return value */
 
1684
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
 
1685
      _ex);SIDL_CHECK(*_ex);
 
1686
 
 
1687
    /* unpack out and inout arguments */
 
1688
 
 
1689
    /* cleanup and return */
 
1690
    EXIT:
 
1691
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1692
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1693
    return _retval;
 
1694
  }
 
1695
}
 
1696
 
 
1697
/* REMOTE METHOD STUB:Dot */
 
1698
static int32_t
 
1699
remote_bHYPRE__Vector_Dot(
 
1700
  /* in */ struct bHYPRE__Vector__object* self ,
 
1701
  /* in */ struct bHYPRE_Vector__object* x,
 
1702
  /* out */ double* d,
 
1703
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1704
{
 
1705
  LANG_SPECIFIC_INIT();
 
1706
  *_ex = NULL;
 
1707
  {
 
1708
    /* initialize a new invocation */
 
1709
    sidl_BaseInterface _throwaway = NULL;
 
1710
    sidl_BaseException _be = NULL;
 
1711
    sidl_rmi_Response _rsvp = NULL;
 
1712
    int32_t _retval = 0;
 
1713
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1714
      bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1715
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1716
      "Dot", _ex ); SIDL_CHECK(*_ex);
 
1717
 
 
1718
    /* pack in and inout arguments */
 
1719
    if(x){
 
1720
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)x,
 
1721
        _ex);SIDL_CHECK(*_ex);
 
1722
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
 
1723
      free((void*)_url);
 
1724
    } else {
 
1725
      sidl_rmi_Invocation_packString( _inv, "x", NULL, _ex);SIDL_CHECK(*_ex);
 
1726
    }
 
1727
 
 
1728
    /* send actual RMI request */
 
1729
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1730
 
 
1731
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1732
    if(_be != NULL) {
 
1733
      sidl_BaseInterface throwaway_exception = NULL;
 
1734
sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE._Vector.Dot.", &throwaway_exception);
 
1735
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,
 
1736
        &throwaway_exception);
 
1737
      goto EXIT;
 
1738
    }
 
1739
 
 
1740
    /* extract return value */
 
1741
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
 
1742
      _ex);SIDL_CHECK(*_ex);
 
1743
 
 
1744
    /* unpack out and inout arguments */
 
1745
    sidl_rmi_Response_unpackDouble( _rsvp, "d", d, _ex);SIDL_CHECK(*_ex);
 
1746
 
 
1747
    /* cleanup and return */
 
1748
    EXIT:
 
1749
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1750
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1751
    return _retval;
 
1752
  }
 
1753
}
 
1754
 
 
1755
/* REMOTE METHOD STUB:Axpy */
 
1756
static int32_t
 
1757
remote_bHYPRE__Vector_Axpy(
 
1758
  /* in */ struct bHYPRE__Vector__object* self ,
 
1759
  /* in */ double a,
 
1760
  /* in */ struct bHYPRE_Vector__object* x,
 
1761
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1762
{
 
1763
  LANG_SPECIFIC_INIT();
 
1764
  *_ex = NULL;
 
1765
  {
 
1766
    /* initialize a new invocation */
 
1767
    sidl_BaseInterface _throwaway = NULL;
 
1768
    sidl_BaseException _be = NULL;
 
1769
    sidl_rmi_Response _rsvp = NULL;
 
1770
    int32_t _retval = 0;
 
1771
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1772
      bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1773
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1774
      "Axpy", _ex ); SIDL_CHECK(*_ex);
 
1775
 
 
1776
    /* pack in and inout arguments */
 
1777
    sidl_rmi_Invocation_packDouble( _inv, "a", a, _ex);SIDL_CHECK(*_ex);
 
1778
    if(x){
 
1779
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)x,
 
1780
        _ex);SIDL_CHECK(*_ex);
 
1781
      sidl_rmi_Invocation_packString( _inv, "x", _url, _ex);SIDL_CHECK(*_ex);
 
1782
      free((void*)_url);
 
1783
    } else {
 
1784
      sidl_rmi_Invocation_packString( _inv, "x", NULL, _ex);SIDL_CHECK(*_ex);
 
1785
    }
 
1786
 
 
1787
    /* send actual RMI request */
 
1788
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1789
 
 
1790
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1791
    if(_be != NULL) {
 
1792
      sidl_BaseInterface throwaway_exception = NULL;
 
1793
sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE._Vector.Axpy.", &throwaway_exception);
 
1794
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,
 
1795
        &throwaway_exception);
 
1796
      goto EXIT;
 
1797
    }
 
1798
 
 
1799
    /* extract return value */
 
1800
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval,
 
1801
      _ex);SIDL_CHECK(*_ex);
 
1802
 
 
1803
    /* unpack out and inout arguments */
 
1804
 
 
1805
    /* cleanup and return */
 
1806
    EXIT:
 
1807
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1808
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1809
    return _retval;
 
1810
  }
 
1811
}
 
1812
 
 
1813
/* REMOTE METHOD STUB:addRef */
 
1814
static void
 
1815
remote_bHYPRE__Vector_addRef(
 
1816
  /* in */ struct bHYPRE__Vector__object* self ,
 
1817
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1818
{
 
1819
  LANG_SPECIFIC_INIT();
 
1820
  *_ex = NULL;
 
1821
  {
 
1822
    struct bHYPRE__Vector__remote* r_obj = (struct 
 
1823
      bHYPRE__Vector__remote*)self->d_data;
 
1824
    LOCK_STATIC_GLOBALS;
 
1825
    r_obj->d_refcount++;
 
1826
    UNLOCK_STATIC_GLOBALS;
 
1827
  }
 
1828
}
 
1829
 
 
1830
/* REMOTE METHOD STUB:deleteRef */
 
1831
static void
 
1832
remote_bHYPRE__Vector_deleteRef(
 
1833
  /* in */ struct bHYPRE__Vector__object* self ,
 
1834
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1835
{
 
1836
  LANG_SPECIFIC_INIT();
 
1837
  *_ex = NULL;
 
1838
  {
 
1839
    struct bHYPRE__Vector__remote* r_obj = (struct 
 
1840
      bHYPRE__Vector__remote*)self->d_data;
 
1841
    LOCK_STATIC_GLOBALS;
 
1842
    r_obj->d_refcount--;
 
1843
    if(r_obj->d_refcount == 0) {
 
1844
      sidl_rmi_InstanceHandle_deleteRef(r_obj->d_ih, _ex);
 
1845
      free(r_obj);
 
1846
      free(self);
 
1847
    }
 
1848
    UNLOCK_STATIC_GLOBALS;
 
1849
  }
 
1850
}
 
1851
 
 
1852
/* REMOTE METHOD STUB:isSame */
 
1853
static sidl_bool
 
1854
remote_bHYPRE__Vector_isSame(
 
1855
  /* in */ struct bHYPRE__Vector__object* self ,
 
1856
  /* in */ struct sidl_BaseInterface__object* iobj,
 
1857
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1858
{
 
1859
  LANG_SPECIFIC_INIT();
 
1860
  *_ex = NULL;
 
1861
  {
 
1862
    /* initialize a new invocation */
 
1863
    sidl_BaseInterface _throwaway = NULL;
 
1864
    sidl_BaseException _be = NULL;
 
1865
    sidl_rmi_Response _rsvp = NULL;
 
1866
    sidl_bool _retval = FALSE;
 
1867
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1868
      bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1869
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1870
      "isSame", _ex ); SIDL_CHECK(*_ex);
 
1871
 
 
1872
    /* pack in and inout arguments */
 
1873
    if(iobj){
 
1874
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj,
 
1875
        _ex);SIDL_CHECK(*_ex);
 
1876
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(*_ex);
 
1877
      free((void*)_url);
 
1878
    } else {
 
1879
      sidl_rmi_Invocation_packString( _inv, "iobj", NULL, _ex);SIDL_CHECK(*_ex);
 
1880
    }
 
1881
 
 
1882
    /* send actual RMI request */
 
1883
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1884
 
 
1885
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1886
    if(_be != NULL) {
 
1887
      sidl_BaseInterface throwaway_exception = NULL;
 
1888
sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE._Vector.isSame.", &throwaway_exception);
 
1889
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,
 
1890
        &throwaway_exception);
 
1891
      goto EXIT;
 
1892
    }
 
1893
 
 
1894
    /* extract return value */
 
1895
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
 
1896
      _ex);SIDL_CHECK(*_ex);
 
1897
 
 
1898
    /* unpack out and inout arguments */
 
1899
 
 
1900
    /* cleanup and return */
 
1901
    EXIT:
 
1902
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1903
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1904
    return _retval;
 
1905
  }
 
1906
}
 
1907
 
 
1908
/* REMOTE METHOD STUB:isType */
 
1909
static sidl_bool
 
1910
remote_bHYPRE__Vector_isType(
 
1911
  /* in */ struct bHYPRE__Vector__object* self ,
 
1912
  /* in */ const char* name,
 
1913
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1914
{
 
1915
  LANG_SPECIFIC_INIT();
 
1916
  *_ex = NULL;
 
1917
  {
 
1918
    /* initialize a new invocation */
 
1919
    sidl_BaseInterface _throwaway = NULL;
 
1920
    sidl_BaseException _be = NULL;
 
1921
    sidl_rmi_Response _rsvp = NULL;
 
1922
    sidl_bool _retval = FALSE;
 
1923
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1924
      bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1925
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1926
      "isType", _ex ); SIDL_CHECK(*_ex);
 
1927
 
 
1928
    /* pack in and inout arguments */
 
1929
    sidl_rmi_Invocation_packString( _inv, "name", name, _ex);SIDL_CHECK(*_ex);
 
1930
 
 
1931
    /* send actual RMI request */
 
1932
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1933
 
 
1934
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1935
    if(_be != NULL) {
 
1936
      sidl_BaseInterface throwaway_exception = NULL;
 
1937
sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE._Vector.isType.", &throwaway_exception);
 
1938
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,
 
1939
        &throwaway_exception);
 
1940
      goto EXIT;
 
1941
    }
 
1942
 
 
1943
    /* extract return value */
 
1944
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval,
 
1945
      _ex);SIDL_CHECK(*_ex);
 
1946
 
 
1947
    /* unpack out and inout arguments */
 
1948
 
 
1949
    /* cleanup and return */
 
1950
    EXIT:
 
1951
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1952
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1953
    return _retval;
 
1954
  }
 
1955
}
 
1956
 
 
1957
/* REMOTE METHOD STUB:getClassInfo */
 
1958
static struct sidl_ClassInfo__object*
 
1959
remote_bHYPRE__Vector_getClassInfo(
 
1960
  /* in */ struct bHYPRE__Vector__object* self ,
 
1961
  /* out */ struct sidl_BaseInterface__object* *_ex)
 
1962
{
 
1963
  LANG_SPECIFIC_INIT();
 
1964
  *_ex = NULL;
 
1965
  {
 
1966
    /* initialize a new invocation */
 
1967
    sidl_BaseInterface _throwaway = NULL;
 
1968
    sidl_BaseException _be = NULL;
 
1969
    sidl_rmi_Response _rsvp = NULL;
 
1970
    char*_retval_str = NULL;
 
1971
    struct sidl_ClassInfo__object* _retval = 0;
 
1972
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1973
      bHYPRE__Vector__remote*)self->d_data)->d_ih;
 
1974
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn,
 
1975
      "getClassInfo", _ex ); SIDL_CHECK(*_ex);
 
1976
 
 
1977
    /* pack in and inout arguments */
 
1978
 
 
1979
    /* send actual RMI request */
 
1980
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1981
 
 
1982
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1983
    if(_be != NULL) {
 
1984
      sidl_BaseInterface throwaway_exception = NULL;
 
1985
sidl_BaseException_addLine(_be, "Exception unserialized from bHYPRE._Vector.getClassInfo.", &throwaway_exception);
 
1986
      *_ex = (sidl_BaseInterface) sidl_BaseInterface__rmicast(_be,
 
1987
        &throwaway_exception);
 
1988
      goto EXIT;
 
1989
    }
 
1990
 
 
1991
    /* extract return value */
 
1992
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str,
 
1993
      _ex);SIDL_CHECK(*_ex);
 
1994
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE,
 
1995
      _ex);SIDL_CHECK(*_ex);
 
1996
 
 
1997
    /* unpack out and inout arguments */
 
1998
 
 
1999
    /* cleanup and return */
 
2000
    EXIT:
 
2001
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
2002
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
2003
    return _retval;
 
2004
  }
 
2005
}
 
2006
 
 
2007
/* REMOTE EPV: create remote entry point vectors (EPVs). */
 
2008
static void bHYPRE__Vector__init_remote_epv(void)
 
2009
{
 
2010
  /* assert( HAVE_LOCKED_STATIC_GLOBALS ); */
 
2011
  struct bHYPRE__Vector__epv*     epv = &s_rem_epv__bhypre__vector;
 
2012
  struct bHYPRE_Vector__epv*      e0  = &s_rem_epv__bhypre_vector;
 
2013
  struct sidl_BaseInterface__epv* e1  = &s_rem_epv__sidl_baseinterface;
 
2014
 
 
2015
  epv->f__cast             = remote_bHYPRE__Vector__cast;
 
2016
  epv->f__delete           = remote_bHYPRE__Vector__delete;
 
2017
  epv->f__exec             = remote_bHYPRE__Vector__exec;
 
2018
  epv->f__getURL           = remote_bHYPRE__Vector__getURL;
 
2019
  epv->f__raddRef          = remote_bHYPRE__Vector__raddRef;
 
2020
  epv->f__isRemote         = remote_bHYPRE__Vector__isRemote;
 
2021
  epv->f__set_hooks        = remote_bHYPRE__Vector__set_hooks;
 
2022
  epv->f__ctor             = NULL;
 
2023
  epv->f__ctor2            = NULL;
 
2024
  epv->f__dtor             = NULL;
 
2025
  epv->f_Clear             = remote_bHYPRE__Vector_Clear;
 
2026
  epv->f_Copy              = remote_bHYPRE__Vector_Copy;
 
2027
  epv->f_Clone             = remote_bHYPRE__Vector_Clone;
 
2028
  epv->f_Scale             = remote_bHYPRE__Vector_Scale;
 
2029
  epv->f_Dot               = remote_bHYPRE__Vector_Dot;
 
2030
  epv->f_Axpy              = remote_bHYPRE__Vector_Axpy;
 
2031
  epv->f_addRef            = remote_bHYPRE__Vector_addRef;
 
2032
  epv->f_deleteRef         = remote_bHYPRE__Vector_deleteRef;
 
2033
  epv->f_isSame            = remote_bHYPRE__Vector_isSame;
 
2034
  epv->f_isType            = remote_bHYPRE__Vector_isType;
 
2035
  epv->f_getClassInfo      = remote_bHYPRE__Vector_getClassInfo;
 
2036
 
 
2037
  e0->f__cast        = (void* (*)(void*,const char*,
 
2038
    sidl_BaseInterface*)) epv->f__cast;
 
2039
  e0->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
 
2040
  e0->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
 
2041
  e0->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
 
2042
  e0->f__isRemote    = (sidl_bool (*)(void*,
 
2043
    sidl_BaseInterface*)) epv->f__isRemote;
 
2044
  e0->f__set_hooks   = (void (*)(void*,int32_t,
 
2045
    sidl_BaseInterface*)) epv->f__set_hooks;
 
2046
  e0->f__exec        = (void (*)(void*,const char*,
 
2047
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
 
2048
    struct sidl_BaseInterface__object **)) epv->f__exec;
 
2049
  e0->f_Clear        = (int32_t (*)(void*,
 
2050
    struct sidl_BaseInterface__object **)) epv->f_Clear;
 
2051
  e0->f_Copy         = (int32_t (*)(void*,struct bHYPRE_Vector__object*,
 
2052
    struct sidl_BaseInterface__object **)) epv->f_Copy;
 
2053
  e0->f_Clone        = (int32_t (*)(void*,struct bHYPRE_Vector__object**,
 
2054
    struct sidl_BaseInterface__object **)) epv->f_Clone;
 
2055
  e0->f_Scale        = (int32_t (*)(void*,double,
 
2056
    struct sidl_BaseInterface__object **)) epv->f_Scale;
 
2057
  e0->f_Dot          = (int32_t (*)(void*,struct bHYPRE_Vector__object*,double*,
 
2058
    struct sidl_BaseInterface__object **)) epv->f_Dot;
 
2059
  e0->f_Axpy         = (int32_t (*)(void*,double,struct bHYPRE_Vector__object*,
 
2060
    struct sidl_BaseInterface__object **)) epv->f_Axpy;
 
2061
  e0->f_addRef       = (void (*)(void*,
 
2062
    struct sidl_BaseInterface__object **)) epv->f_addRef;
 
2063
  e0->f_deleteRef    = (void (*)(void*,
 
2064
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2065
  e0->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
 
2066
    struct sidl_BaseInterface__object **)) epv->f_isSame;
 
2067
  e0->f_isType       = (sidl_bool (*)(void*,const char*,
 
2068
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
2069
  e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
 
2070
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2071
 
 
2072
  e1->f__cast        = (void* (*)(void*,const char*,
 
2073
    sidl_BaseInterface*)) epv->f__cast;
 
2074
  e1->f__delete      = (void (*)(void*,sidl_BaseInterface*)) epv->f__delete;
 
2075
  e1->f__getURL      = (char* (*)(void*,sidl_BaseInterface*)) epv->f__getURL;
 
2076
  e1->f__raddRef     = (void (*)(void*,sidl_BaseInterface*)) epv->f__raddRef;
 
2077
  e1->f__isRemote    = (sidl_bool (*)(void*,
 
2078
    sidl_BaseInterface*)) epv->f__isRemote;
 
2079
  e1->f__set_hooks   = (void (*)(void*,int32_t,
 
2080
    sidl_BaseInterface*)) epv->f__set_hooks;
 
2081
  e1->f__exec        = (void (*)(void*,const char*,
 
2082
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
 
2083
    struct sidl_BaseInterface__object **)) epv->f__exec;
 
2084
  e1->f_addRef       = (void (*)(void*,
 
2085
    struct sidl_BaseInterface__object **)) epv->f_addRef;
 
2086
  e1->f_deleteRef    = (void (*)(void*,
 
2087
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2088
  e1->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
 
2089
    struct sidl_BaseInterface__object **)) epv->f_isSame;
 
2090
  e1->f_isType       = (sidl_bool (*)(void*,const char*,
 
2091
    struct sidl_BaseInterface__object **)) epv->f_isType;
 
2092
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,
 
2093
    struct sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2094
 
 
2095
  s_remote_initialized = 1;
 
2096
}
 
2097
 
 
2098
/* Create an instance that connects to an existing remote object. */
 
2099
static struct bHYPRE_Vector__object*
 
2100
bHYPRE_Vector__remoteConnect(const char *url, sidl_bool ar,
 
2101
  sidl_BaseInterface *_ex)
 
2102
{
 
2103
  struct bHYPRE__Vector__object* self;
 
2104
 
 
2105
  struct bHYPRE__Vector__object* s0;
 
2106
 
 
2107
  struct bHYPRE__Vector__remote* r_obj;
 
2108
  sidl_rmi_InstanceHandle instance = NULL;
 
2109
  char* objectID = NULL;
 
2110
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
 
2111
  if(objectID) {
 
2112
    sidl_BaseInterface bi = 
 
2113
      (sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(
 
2114
      objectID, _ex);
 
2115
    if(ar) {
 
2116
      sidl_BaseInterface_addRef(bi, _ex);
 
2117
    }
 
2118
    return bHYPRE_Vector__rmicast(bi, _ex);
 
2119
  }
 
2120
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, ar, _ex );
 
2121
  if ( instance == NULL) { return NULL; }
 
2122
  self =
 
2123
    (struct bHYPRE__Vector__object*) malloc(
 
2124
      sizeof(struct bHYPRE__Vector__object));
 
2125
 
 
2126
  r_obj =
 
2127
    (struct bHYPRE__Vector__remote*) malloc(
 
2128
      sizeof(struct bHYPRE__Vector__remote));
 
2129
 
 
2130
  r_obj->d_refcount = 1;
 
2131
  r_obj->d_ih = instance;
 
2132
  s0 =                          self;
 
2133
 
 
2134
  LOCK_STATIC_GLOBALS;
 
2135
  if (!s_remote_initialized) {
 
2136
    bHYPRE__Vector__init_remote_epv();
 
2137
  }
 
2138
  UNLOCK_STATIC_GLOBALS;
 
2139
 
 
2140
  s0->d_bhypre_vector.d_epv    = &s_rem_epv__bhypre_vector;
 
2141
  s0->d_bhypre_vector.d_object = (void*) self;
 
2142
 
 
2143
  s0->d_sidl_baseinterface.d_epv    = &s_rem_epv__sidl_baseinterface;
 
2144
  s0->d_sidl_baseinterface.d_object = (void*) self;
 
2145
 
 
2146
  s0->d_data = (void*) r_obj;
 
2147
  s0->d_epv  = &s_rem_epv__bhypre__vector;
 
2148
 
 
2149
  self->d_data = (void*) r_obj;
 
2150
 
 
2151
  return bHYPRE_Vector__rmicast(self, _ex);
 
2152
}
 
2153
/* Create an instance that uses an already existing  */
 
2154
/* InstanceHandel to connect to an existing remote object. */
 
2155
static struct bHYPRE_Vector__object*
 
2156
bHYPRE_Vector__IHConnect(sidl_rmi_InstanceHandle instance,
 
2157
  sidl_BaseInterface *_ex)
 
2158
{
 
2159
  struct bHYPRE__Vector__object* self;
 
2160
 
 
2161
  struct bHYPRE__Vector__object* s0;
 
2162
 
 
2163
  struct bHYPRE__Vector__remote* r_obj;
 
2164
  self =
 
2165
    (struct bHYPRE__Vector__object*) malloc(
 
2166
      sizeof(struct bHYPRE__Vector__object));
 
2167
 
 
2168
  r_obj =
 
2169
    (struct bHYPRE__Vector__remote*) malloc(
 
2170
      sizeof(struct bHYPRE__Vector__remote));
 
2171
 
 
2172
  r_obj->d_refcount = 1;
 
2173
  r_obj->d_ih = instance;
 
2174
  s0 =                          self;
 
2175
 
 
2176
  LOCK_STATIC_GLOBALS;
 
2177
  if (!s_remote_initialized) {
 
2178
    bHYPRE__Vector__init_remote_epv();
 
2179
  }
 
2180
  UNLOCK_STATIC_GLOBALS;
 
2181
 
 
2182
  s0->d_bhypre_vector.d_epv    = &s_rem_epv__bhypre_vector;
 
2183
  s0->d_bhypre_vector.d_object = (void*) self;
 
2184
 
 
2185
  s0->d_sidl_baseinterface.d_epv    = &s_rem_epv__sidl_baseinterface;
 
2186
  s0->d_sidl_baseinterface.d_object = (void*) self;
 
2187
 
 
2188
  s0->d_data = (void*) r_obj;
 
2189
  s0->d_epv  = &s_rem_epv__bhypre__vector;
 
2190
 
 
2191
  self->d_data = (void*) r_obj;
 
2192
 
 
2193
  sidl_rmi_InstanceHandle_addRef(instance, _ex);
 
2194
  return bHYPRE_Vector__rmicast(self, _ex);
 
2195
}
 
2196
/*
 
2197
 * Cast method for interface and class type conversions.
 
2198
 */
 
2199
 
 
2200
struct bHYPRE_Vector__object*
 
2201
bHYPRE_Vector__rmicast(
 
2202
  void* obj,
 
2203
  sidl_BaseInterface* _ex)
 
2204
{
 
2205
  struct bHYPRE_Vector__object* cast = NULL;
 
2206
 
 
2207
  *_ex = NULL;
 
2208
  if(!connect_loaded) {
 
2209
    sidl_rmi_ConnectRegistry_registerConnect("bHYPRE.Vector",
 
2210
      (void*)bHYPRE_Vector__IHConnect, _ex);
 
2211
    connect_loaded = 1;
 
2212
  }
 
2213
  if (obj != NULL) {
 
2214
    struct sidl_BaseInterface__object* base = (struct 
 
2215
      sidl_BaseInterface__object*) obj;
 
2216
    cast = (struct bHYPRE_Vector__object*) (*base->d_epv->f__cast)(
 
2217
      base->d_object,
 
2218
      "bHYPRE.Vector", _ex); SIDL_CHECK(*_ex);
 
2219
  }
 
2220
 
 
2221
  return cast;
 
2222
  EXIT:
 
2223
  return NULL;
 
2224
}
 
2225
 
 
2226
/*
 
2227
 * RMI connector function for the class.
 
2228
 */
 
2229
 
 
2230
struct bHYPRE_Vector__object*
 
2231
bHYPRE_Vector__connectI(const char* url, sidl_bool ar,
 
2232
  struct sidl_BaseInterface__object **_ex)
 
2233
{
 
2234
  return bHYPRE_Vector__remoteConnect(url, ar, _ex);
 
2235
}
 
2236