← Back to branch summary

~ubuntu-branches/ubuntu/raring/babel/raring-proposed

« back to all changes in this revision

Viewing changes to runtime/sidlx/sidlx_rmi_OutOfAddressesException_Stub.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam C. Powell, IV
  • Date: 2008-08-01 07:56:58 UTC
  • mfrom: (3.1.2 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080801075658-9ezcrbh8dcs8lg70
Tags: 1.2.0.dfsg-6
http://bugs.debian.org/483324
Added libparsifal-dev as dependency to libsidl-dev (closes: #483324).

Show diffs side-by-side

added added

removed removed

Lines of Context:
runtime/sidlx/sidlx_rmi_OutOfAddressesException_Stub.c
 
1
/*
 
2
 * File:          sidlx_rmi_OutOfAddressesException_Stub.c
 
3
 * Symbol:        sidlx.rmi.OutOfAddressesException-v0.1
 
4
 * Symbol Type:   class
 
5
 * Babel Version: 1.2.0
 
6
 * Description:   Client-side glue code for sidlx.rmi.OutOfAddressesException
 
7
 * 
 
8
 * WARNING: Automatically generated; changes will be lost
 
9
 * 
 
10
 */
 
11
 
 
12
#include "sidlx_rmi_OutOfAddressesException.h"
 
13
#include "sidlx_rmi_OutOfAddressesException_IOR.h"
 
14
#ifndef included_sidl_interface_IOR_h
 
15
#include "sidl_interface_IOR.h"
 
16
#endif
 
17
#ifndef included_sidl_rmi_InstanceHandle_h
 
18
#include "sidl_rmi_InstanceHandle.h"
 
19
#endif
 
20
#ifndef included_sidl_rmi_ConnectRegistry_h
 
21
#include "sidl_rmi_ConnectRegistry.h"
 
22
#endif
 
23
#include "sidl_Exception.h"
 
24
#ifndef included_sidl_interface_IOR_h
 
25
#include "sidl_interface_IOR.h"
 
26
#endif
 
27
#include <stddef.h>
 
28
#include <string.h>
 
29
#include "sidl_BaseInterface_IOR.h"
 
30
#include "babel_config.h"
 
31
#ifdef SIDL_DYNAMIC_LIBRARY
 
32
#include <stdio.h>
 
33
#include <stdlib.h>
 
34
#include "sidl_Loader.h"
 
35
#endif
 
36
 
 
37
#define LANG_SPECIFIC_INIT()
 
38
 
 
39
/*
 
40
 * Hold pointer to IOR functions.
 
41
 */
 
42
 
 
43
static const struct sidlx_rmi_OutOfAddressesException__external *_externals = 
 
44
  NULL;
 
45
/*
 
46
 * Lookup the symbol to get the IOR functions.
 
47
 */
 
48
 
 
49
static const struct sidlx_rmi_OutOfAddressesException__external* _loadIOR(void)
 
50
/*
 
51
 * Return pointer to internal IOR functions.
 
52
 */
 
53
 
 
54
{
 
55
#ifdef SIDL_STATIC_LIBRARY
 
56
  _externals = sidlx_rmi_OutOfAddressesException__externals();
 
57
#else
 
58
  _externals = (struct 
 
59
    sidlx_rmi_OutOfAddressesException__external*)sidl_dynamicLoadIOR(
 
60
    "sidlx.rmi.OutOfAddressesException",
 
61
    "sidlx_rmi_OutOfAddressesException__externals") ;
 
62
  sidl_checkIORVersion("sidlx.rmi.OutOfAddressesException", 
 
63
    _externals->d_ior_major_version, _externals->d_ior_minor_version, 2, 0);
 
64
#endif
 
65
  return _externals;
 
66
}
 
67
 
 
68
#define _getExternals() (_externals ? _externals : _loadIOR())
 
69
 
 
70
/*
 
71
 * Constructor function for the class.
 
72
 */
 
73
 
 
74
sidlx_rmi_OutOfAddressesException
 
75
sidlx_rmi_OutOfAddressesException__create(sidl_BaseInterface* _ex)
 
76
{
 
77
  return (*(_getExternals()->createObject))(NULL,_ex);
 
78
}
 
79
 
 
80
/**
 
81
 * Wraps up the private data struct pointer (struct sidlx_rmi_OutOfAddressesException__data) passed in rather than running the constructor.
 
82
 */
 
83
sidlx_rmi_OutOfAddressesException
 
84
sidlx_rmi_OutOfAddressesException__wrapObj(void* data, sidl_BaseInterface* _ex)
 
85
{
 
86
  return (*(_getExternals()->createObject))(data,_ex);
 
87
}
 
88
 
 
89
#ifdef WITH_RMI
 
90
 
 
91
static sidlx_rmi_OutOfAddressesException 
 
92
  sidlx_rmi_OutOfAddressesException__remoteCreate(const char* url, 
 
93
  sidl_BaseInterface *_ex);
 
94
/*
 
95
 * RMI constructor function for the class.
 
96
 */
 
97
 
 
98
sidlx_rmi_OutOfAddressesException
 
99
sidlx_rmi_OutOfAddressesException__createRemote(const char* url, 
 
100
  sidl_BaseInterface *_ex)
 
101
{
 
102
  return sidlx_rmi_OutOfAddressesException__remoteCreate(url, _ex);
 
103
}
 
104
 
 
105
static struct sidlx_rmi_OutOfAddressesException__object* 
 
106
  sidlx_rmi_OutOfAddressesException__remoteConnect(const char* url, sidl_bool 
 
107
  ar, sidl_BaseInterface *_ex);
 
108
static struct sidlx_rmi_OutOfAddressesException__object* 
 
109
  sidlx_rmi_OutOfAddressesException__IHConnect(struct 
 
110
  sidl_rmi_InstanceHandle__object* instance, sidl_BaseInterface *_ex);
 
111
/*
 
112
 * RMI connector function for the class.
 
113
 */
 
114
 
 
115
sidlx_rmi_OutOfAddressesException
 
116
sidlx_rmi_OutOfAddressesException__connect(const char* url, sidl_BaseInterface 
 
117
  *_ex)
 
118
{
 
119
  return sidlx_rmi_OutOfAddressesException__remoteConnect(url, TRUE, _ex);
 
120
}
 
121
 
 
122
#endif /*WITH_RMI*/
 
123
 
 
124
/*
 
125
 * Method:  getHopCount[]
 
126
 */
 
127
 
 
128
SIDL_C_INLINE_DEFN
 
129
int32_t
 
130
sidlx_rmi_OutOfAddressesException_getHopCount(
 
131
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
132
  /* out */ sidl_BaseInterface *_ex)
 
133
#if SIDL_C_INLINE_REPEAT_DEFN
 
134
{
 
135
  int32_t _result;
 
136
  _result = (*self->d_epv->f_getHopCount)(
 
137
    self,
 
138
    _ex);
 
139
  return _result;
 
140
}
 
141
#else /* ISO C 1999 inline semantics */
 
142
;
 
143
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
144
 
 
145
/*
 
146
 * Method:  setErrno[]
 
147
 */
 
148
 
 
149
SIDL_C_INLINE_DEFN
 
150
void
 
151
sidlx_rmi_OutOfAddressesException_setErrno(
 
152
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
153
  /* in */ int32_t err,
 
154
  /* out */ sidl_BaseInterface *_ex)
 
155
#if SIDL_C_INLINE_REPEAT_DEFN
 
156
{
 
157
  (*self->d_epv->f_setErrno)(
 
158
    self,
 
159
    err,
 
160
    _ex);
 
161
}
 
162
#else /* ISO C 1999 inline semantics */
 
163
;
 
164
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
165
 
 
166
/*
 
167
 * Method:  getErrno[]
 
168
 */
 
169
 
 
170
SIDL_C_INLINE_DEFN
 
171
int32_t
 
172
sidlx_rmi_OutOfAddressesException_getErrno(
 
173
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
174
  /* out */ sidl_BaseInterface *_ex)
 
175
#if SIDL_C_INLINE_REPEAT_DEFN
 
176
{
 
177
  int32_t _result;
 
178
  _result = (*self->d_epv->f_getErrno)(
 
179
    self,
 
180
    _ex);
 
181
  return _result;
 
182
}
 
183
#else /* ISO C 1999 inline semantics */
 
184
;
 
185
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
186
 
 
187
/*
 
188
 * <p>
 
189
 * Add one to the intrinsic reference count in the underlying object.
 
190
 * Object in <code>sidl</code> have an intrinsic reference count.
 
191
 * Objects continue to exist as long as the reference count is
 
192
 * positive. Clients should call this method whenever they
 
193
 * create another ongoing reference to an object or interface.
 
194
 * </p>
 
195
 * <p>
 
196
 * This does not have a return value because there is no language
 
197
 * independent type that can refer to an interface or a
 
198
 * class.
 
199
 * </p>
 
200
 */
 
201
 
 
202
SIDL_C_INLINE_DEFN
 
203
void
 
204
sidlx_rmi_OutOfAddressesException_addRef(
 
205
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
206
  /* out */ sidl_BaseInterface *_ex)
 
207
#if SIDL_C_INLINE_REPEAT_DEFN
 
208
{
 
209
  (*self->d_epv->f_addRef)(
 
210
    self,
 
211
    _ex);
 
212
}
 
213
#else /* ISO C 1999 inline semantics */
 
214
;
 
215
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
216
 
 
217
/*
 
218
 * Decrease by one the intrinsic reference count in the underlying
 
219
 * object, and delete the object if the reference is non-positive.
 
220
 * Objects in <code>sidl</code> have an intrinsic reference count.
 
221
 * Clients should call this method whenever they remove a
 
222
 * reference to an object or interface.
 
223
 */
 
224
 
 
225
SIDL_C_INLINE_DEFN
 
226
void
 
227
sidlx_rmi_OutOfAddressesException_deleteRef(
 
228
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
229
  /* out */ sidl_BaseInterface *_ex)
 
230
#if SIDL_C_INLINE_REPEAT_DEFN
 
231
{
 
232
  (*self->d_epv->f_deleteRef)(
 
233
    self,
 
234
    _ex);
 
235
}
 
236
#else /* ISO C 1999 inline semantics */
 
237
;
 
238
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
239
 
 
240
/*
 
241
 * Return true if and only if <code>obj</code> refers to the same
 
242
 * object as this object.
 
243
 */
 
244
 
 
245
SIDL_C_INLINE_DEFN
 
246
sidl_bool
 
247
sidlx_rmi_OutOfAddressesException_isSame(
 
248
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
249
  /* in */ sidl_BaseInterface iobj,
 
250
  /* out */ sidl_BaseInterface *_ex)
 
251
#if SIDL_C_INLINE_REPEAT_DEFN
 
252
{
 
253
  sidl_bool _result;
 
254
  _result = (*self->d_epv->f_isSame)(
 
255
    self,
 
256
    iobj,
 
257
    _ex);
 
258
  return _result;
 
259
}
 
260
#else /* ISO C 1999 inline semantics */
 
261
;
 
262
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
263
 
 
264
/*
 
265
 * Return whether this object is an instance of the specified type.
 
266
 * The string name must be the <code>sidl</code> type name.  This
 
267
 * routine will return <code>true</code> if and only if a cast to
 
268
 * the string type name would succeed.
 
269
 */
 
270
 
 
271
SIDL_C_INLINE_DEFN
 
272
sidl_bool
 
273
sidlx_rmi_OutOfAddressesException_isType(
 
274
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
275
  /* in */ const char* name,
 
276
  /* out */ sidl_BaseInterface *_ex)
 
277
#if SIDL_C_INLINE_REPEAT_DEFN
 
278
{
 
279
  sidl_bool _result;
 
280
  _result = (*self->d_epv->f_isType)(
 
281
    self,
 
282
    name,
 
283
    _ex);
 
284
  return _result;
 
285
}
 
286
#else /* ISO C 1999 inline semantics */
 
287
;
 
288
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
289
 
 
290
/*
 
291
 * Return the meta-data about the class implementing this interface.
 
292
 */
 
293
 
 
294
SIDL_C_INLINE_DEFN
 
295
sidl_ClassInfo
 
296
sidlx_rmi_OutOfAddressesException_getClassInfo(
 
297
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
298
  /* out */ sidl_BaseInterface *_ex)
 
299
#if SIDL_C_INLINE_REPEAT_DEFN
 
300
{
 
301
  sidl_ClassInfo _result;
 
302
  _result = (*self->d_epv->f_getClassInfo)(
 
303
    self,
 
304
    _ex);
 
305
  return _result;
 
306
}
 
307
#else /* ISO C 1999 inline semantics */
 
308
;
 
309
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
310
 
 
311
/*
 
312
 * Return the message associated with the exception.
 
313
 */
 
314
 
 
315
SIDL_C_INLINE_DEFN
 
316
char*
 
317
sidlx_rmi_OutOfAddressesException_getNote(
 
318
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
319
  /* out */ sidl_BaseInterface *_ex)
 
320
#if SIDL_C_INLINE_REPEAT_DEFN
 
321
{
 
322
  char* _result;
 
323
  _result = (*self->d_epv->f_getNote)(
 
324
    self,
 
325
    _ex);
 
326
  return _result;
 
327
}
 
328
#else /* ISO C 1999 inline semantics */
 
329
;
 
330
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
331
 
 
332
/*
 
333
 * Set the message associated with the exception.
 
334
 */
 
335
 
 
336
SIDL_C_INLINE_DEFN
 
337
void
 
338
sidlx_rmi_OutOfAddressesException_setNote(
 
339
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
340
  /* in */ const char* message,
 
341
  /* out */ sidl_BaseInterface *_ex)
 
342
#if SIDL_C_INLINE_REPEAT_DEFN
 
343
{
 
344
  (*self->d_epv->f_setNote)(
 
345
    self,
 
346
    message,
 
347
    _ex);
 
348
}
 
349
#else /* ISO C 1999 inline semantics */
 
350
;
 
351
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
352
 
 
353
/*
 
354
 * Returns formatted string containing the concatenation of all 
 
355
 * tracelines.
 
356
 */
 
357
 
 
358
SIDL_C_INLINE_DEFN
 
359
char*
 
360
sidlx_rmi_OutOfAddressesException_getTrace(
 
361
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
362
  /* out */ sidl_BaseInterface *_ex)
 
363
#if SIDL_C_INLINE_REPEAT_DEFN
 
364
{
 
365
  char* _result;
 
366
  _result = (*self->d_epv->f_getTrace)(
 
367
    self,
 
368
    _ex);
 
369
  return _result;
 
370
}
 
371
#else /* ISO C 1999 inline semantics */
 
372
;
 
373
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
374
 
 
375
/*
 
376
 * Adds a stringified entry/line to the stack trace.
 
377
 */
 
378
 
 
379
SIDL_C_INLINE_DEFN
 
380
void
 
381
sidlx_rmi_OutOfAddressesException_addLine(
 
382
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
383
  /* in */ const char* traceline,
 
384
  /* out */ sidl_BaseInterface *_ex)
 
385
#if SIDL_C_INLINE_REPEAT_DEFN
 
386
{
 
387
  (*self->d_epv->f_addLine)(
 
388
    self,
 
389
    traceline,
 
390
    _ex);
 
391
}
 
392
#else /* ISO C 1999 inline semantics */
 
393
;
 
394
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
395
 
 
396
/*
 
397
 * Formats and adds an entry to the stack trace based on the 
 
398
 * file name, line number, and method name.
 
399
 */
 
400
 
 
401
SIDL_C_INLINE_DEFN
 
402
void
 
403
sidlx_rmi_OutOfAddressesException_add(
 
404
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
405
  /* in */ const char* filename,
 
406
  /* in */ int32_t lineno,
 
407
  /* in */ const char* methodname,
 
408
  /* out */ sidl_BaseInterface *_ex)
 
409
#if SIDL_C_INLINE_REPEAT_DEFN
 
410
{
 
411
  (*self->d_epv->f_add)(
 
412
    self,
 
413
    filename,
 
414
    lineno,
 
415
    methodname,
 
416
    _ex);
 
417
}
 
418
#else /* ISO C 1999 inline semantics */
 
419
;
 
420
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
421
 
 
422
/*
 
423
 * Method:  packObj[]
 
424
 */
 
425
 
 
426
SIDL_C_INLINE_DEFN
 
427
void
 
428
sidlx_rmi_OutOfAddressesException_packObj(
 
429
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
430
  /* in */ sidl_io_Serializer ser,
 
431
  /* out */ sidl_BaseInterface *_ex)
 
432
#if SIDL_C_INLINE_REPEAT_DEFN
 
433
{
 
434
  (*self->d_epv->f_packObj)(
 
435
    self,
 
436
    ser,
 
437
    _ex);
 
438
}
 
439
#else /* ISO C 1999 inline semantics */
 
440
;
 
441
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
442
 
 
443
/*
 
444
 * Method:  unpackObj[]
 
445
 */
 
446
 
 
447
SIDL_C_INLINE_DEFN
 
448
void
 
449
sidlx_rmi_OutOfAddressesException_unpackObj(
 
450
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
451
  /* in */ sidl_io_Deserializer des,
 
452
  /* out */ sidl_BaseInterface *_ex)
 
453
#if SIDL_C_INLINE_REPEAT_DEFN
 
454
{
 
455
  (*self->d_epv->f_unpackObj)(
 
456
    self,
 
457
    des,
 
458
    _ex);
 
459
}
 
460
#else /* ISO C 1999 inline semantics */
 
461
;
 
462
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
463
 
 
464
/*
 
465
 * Cast method for interface and class type conversions.
 
466
 */
 
467
 
 
468
sidlx_rmi_OutOfAddressesException
 
469
sidlx_rmi_OutOfAddressesException__cast(
 
470
  void* obj,
 
471
  sidl_BaseInterface* _ex)
 
472
{
 
473
  sidlx_rmi_OutOfAddressesException cast = NULL;
 
474
 
 
475
#ifdef WITH_RMI
 
476
  static int connect_loaded = 0;
 
477
  if(!connect_loaded) {
 
478
    connect_loaded = 1;
 
479
    sidl_rmi_ConnectRegistry_registerConnect(
 
480
      "sidlx.rmi.OutOfAddressesException", (
 
481
      void*)sidlx_rmi_OutOfAddressesException__IHConnect,_ex);SIDL_CHECK(*_ex);
 
482
  }
 
483
#endif /*WITH_RMI*/
 
484
  if (obj != NULL) {
 
485
    sidl_BaseInterface base = (sidl_BaseInterface) obj;
 
486
    cast = (sidlx_rmi_OutOfAddressesException) (*base->d_epv->f__cast)(
 
487
      base->d_object,
 
488
      "sidlx.rmi.OutOfAddressesException", _ex); SIDL_CHECK(*_ex);
 
489
  }
 
490
 
 
491
  EXIT:
 
492
  return cast;
 
493
}
 
494
 
 
495
/*
 
496
 * String cast method for interface and class type conversions.
 
497
 */
 
498
 
 
499
void*
 
500
sidlx_rmi_OutOfAddressesException__cast2(
 
501
  void* obj,
 
502
  const char* type,
 
503
  sidl_BaseInterface* _ex)
 
504
{
 
505
  void* cast = NULL;
 
506
 
 
507
  if (obj != NULL) {
 
508
    sidl_BaseInterface base = (sidl_BaseInterface) obj;
 
509
    cast = (*base->d_epv->f__cast)(base->d_object, type, _ex); SIDL_CHECK(*_ex);
 
510
  }
 
511
 
 
512
  EXIT:
 
513
  return cast;
 
514
}
 
515
/*
 
516
 * Select and execute a method by name
 
517
 */
 
518
 
 
519
SIDL_C_INLINE_DEFN
 
520
void
 
521
sidlx_rmi_OutOfAddressesException__exec(
 
522
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
523
  /* in */ const char* methodName,
 
524
  /* in */ sidl_rmi_Call inArgs,
 
525
  /* in */ sidl_rmi_Return outArgs,
 
526
  /* out */ sidl_BaseInterface *_ex)
 
527
#if SIDL_C_INLINE_REPEAT_DEFN
 
528
{
 
529
  (*self->d_epv->f__exec)(
 
530
    self,
 
531
    methodName,
 
532
    inArgs,
 
533
    outArgs,
 
534
    _ex);
 
535
}
 
536
#else /* ISO C 1999 inline semantics */
 
537
;
 
538
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
539
 
 
540
 
 
541
/*
 
542
 * Get the URL of the Implementation of this object (for RMI)
 
543
 */
 
544
 
 
545
SIDL_C_INLINE_DEFN
 
546
char*
 
547
sidlx_rmi_OutOfAddressesException__getURL(
 
548
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
549
  /* out */ sidl_BaseInterface *_ex)
 
550
#if SIDL_C_INLINE_REPEAT_DEFN
 
551
{
 
552
  char* _result;
 
553
  _result = (*self->d_epv->f__getURL)(
 
554
    self,
 
555
    _ex);
 
556
  return _result;
 
557
}
 
558
#else /* ISO C 1999 inline semantics */
 
559
;
 
560
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
561
 
 
562
 
 
563
/*
 
564
 * On a remote object, addrefs the remote instance.
 
565
 */
 
566
 
 
567
SIDL_C_INLINE_DEFN
 
568
void
 
569
sidlx_rmi_OutOfAddressesException__raddRef(
 
570
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
571
  /* out */ sidl_BaseInterface *_ex)
 
572
#if SIDL_C_INLINE_REPEAT_DEFN
 
573
{
 
574
  (*self->d_epv->f__raddRef)(
 
575
    self,
 
576
    _ex);
 
577
}
 
578
#else /* ISO C 1999 inline semantics */
 
579
;
 
580
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
581
 
 
582
 
 
583
/*
 
584
 * Method to set whether or not method hooks should be invoked.
 
585
 */
 
586
 
 
587
SIDL_C_INLINE_DEFN
 
588
void
 
589
sidlx_rmi_OutOfAddressesException__set_hooks(
 
590
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
591
  /* in */ sidl_bool on,
 
592
  /* out */ sidl_BaseInterface *_ex)
 
593
#if SIDL_C_INLINE_REPEAT_DEFN
 
594
{
 
595
  (*self->d_epv->f__set_hooks)(
 
596
    self,
 
597
    on,
 
598
    _ex);
 
599
}
 
600
#else /* ISO C 1999 inline semantics */
 
601
;
 
602
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
603
 
 
604
/*
 
605
 * TRUE if this object is remote, false if local
 
606
 */
 
607
 
 
608
SIDL_C_INLINE_DEFN
 
609
sidl_bool
 
610
sidlx_rmi_OutOfAddressesException__isRemote(
 
611
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
612
  /* out */ sidl_BaseInterface *_ex)
 
613
#if SIDL_C_INLINE_REPEAT_DEFN
 
614
{
 
615
  sidl_bool _result;
 
616
  _result = (*self->d_epv->f__isRemote)(
 
617
    self,
 
618
    _ex);
 
619
  return _result;
 
620
}
 
621
#else /* ISO C 1999 inline semantics */
 
622
;
 
623
#endif /* SIDL_C_INLINE_REPEAT_DEFN */
 
624
 
 
625
 
 
626
/*
 
627
 * TRUE if this object is remote, false if local
 
628
 */
 
629
 
 
630
sidl_bool
 
631
sidlx_rmi_OutOfAddressesException__isLocal(
 
632
  /* in */ sidlx_rmi_OutOfAddressesException self,
 
633
  /* out */ sidl_BaseInterface *_ex)
 
634
{
 
635
  return !sidlx_rmi_OutOfAddressesException__isRemote(self,_ex);
 
636
}
 
637
 
 
638
/**
 
639
 * Create a contiguous array of the given dimension with specified
 
640
 * index bounds in column-major order. This array
 
641
 * owns and manages its data.
 
642
 * This function initializes the contents of the array to
 
643
 * NULL.
 
644
 */
 
645
struct sidlx_rmi_OutOfAddressesException__array*
 
646
sidlx_rmi_OutOfAddressesException__array_createCol(
 
647
  int32_t       dimen,
 
648
  const int32_t lower[],
 
649
  const int32_t upper[])
 
650
{
 
651
  return (struct 
 
652
    sidlx_rmi_OutOfAddressesException__array*)sidl_interface__array_createCol(
 
653
    dimen, lower, upper);
 
654
}
 
655
 
 
656
/**
 
657
 * Create a contiguous array of the given dimension with specified
 
658
 * index bounds in row-major order. This array
 
659
 * owns and manages its data.
 
660
 * This function initializes the contents of the array to
 
661
 * NULL.
 
662
 */
 
663
struct sidlx_rmi_OutOfAddressesException__array*
 
664
sidlx_rmi_OutOfAddressesException__array_createRow(
 
665
  int32_t       dimen,
 
666
  const int32_t lower[],
 
667
  const int32_t upper[])
 
668
{
 
669
  return (struct 
 
670
    sidlx_rmi_OutOfAddressesException__array*)sidl_interface__array_createRow(
 
671
    dimen, lower, upper);
 
672
}
 
673
 
 
674
/**
 
675
 * Create a contiguous one-dimensional array with a lower index
 
676
 * of 0 and an upper index of len-1. This array
 
677
 * owns and manages its data.
 
678
 * This function initializes the contents of the array to
 
679
 * NULL.
 
680
 */
 
681
struct sidlx_rmi_OutOfAddressesException__array*
 
682
sidlx_rmi_OutOfAddressesException__array_create1d(int32_t len)
 
683
{
 
684
  return (struct 
 
685
    sidlx_rmi_OutOfAddressesException__array*)sidl_interface__array_create1d(
 
686
    len);
 
687
}
 
688
 
 
689
/**
 
690
 * Create a dense one-dimensional vector with a lower
 
691
 * index of 0 and an upper index of len-1. The initial data for this
 
692
 * new array is copied from data. This will increment the reference
 
693
 * count of each non-NULL object/interface reference in data.
 
694
 * 
 
695
 * This array owns and manages its data.
 
696
 */
 
697
struct sidlx_rmi_OutOfAddressesException__array*
 
698
sidlx_rmi_OutOfAddressesException__array_create1dInit(
 
699
  int32_t len, 
 
700
  sidlx_rmi_OutOfAddressesException* data)
 
701
{
 
702
  return (struct 
 
703
    sidlx_rmi_OutOfAddressesException__array*)sidl_interface__array_create1dInit
 
704
    (len, (struct sidl_BaseInterface__object **)data);
 
705
}
 
706
 
 
707
/**
 
708
 * Create a contiguous two-dimensional array in column-major
 
709
 * order with a lower index of (0,0) and an upper index of
 
710
 * (m-1,n-1). This array owns and manages its data.
 
711
 * This function initializes the contents of the array to
 
712
 * NULL.
 
713
 */
 
714
struct sidlx_rmi_OutOfAddressesException__array*
 
715
sidlx_rmi_OutOfAddressesException__array_create2dCol(int32_t m, int32_t n)
 
716
{
 
717
  return (struct 
 
718
    sidlx_rmi_OutOfAddressesException__array*)sidl_interface__array_create2dCol(
 
719
    m, n);
 
720
}
 
721
 
 
722
/**
 
723
 * Create a contiguous two-dimensional array in row-major
 
724
 * order with a lower index of (0,0) and an upper index of
 
725
 * (m-1,n-1). This array owns and manages its data.
 
726
 * This function initializes the contents of the array to
 
727
 * NULL.
 
728
 */
 
729
struct sidlx_rmi_OutOfAddressesException__array*
 
730
sidlx_rmi_OutOfAddressesException__array_create2dRow(int32_t m, int32_t n)
 
731
{
 
732
  return (struct 
 
733
    sidlx_rmi_OutOfAddressesException__array*)sidl_interface__array_create2dRow(
 
734
    m, n);
 
735
}
 
736
 
 
737
/**
 
738
 * Create an array that uses data (memory) from another
 
739
 * source. The initial contents are determined by the
 
740
 * data being borrowed.
 
741
 * Any time an element in the borrowed array is replaced
 
742
 * via a set call, deleteRef will be called on the
 
743
 * value being replaced if it is not NULL.
 
744
 */
 
745
struct sidlx_rmi_OutOfAddressesException__array*
 
746
sidlx_rmi_OutOfAddressesException__array_borrow(
 
747
  sidlx_rmi_OutOfAddressesException* firstElement,
 
748
  int32_t       dimen,
 
749
  const int32_t lower[],
 
750
  const int32_t upper[],
 
751
  const int32_t stride[])
 
752
{
 
753
  return (struct 
 
754
    sidlx_rmi_OutOfAddressesException__array*)sidl_interface__array_borrow(
 
755
    (struct sidl_BaseInterface__object **)
 
756
    firstElement, dimen, lower, upper, stride);
 
757
}
 
758
 
 
759
/**
 
760
 * If array is borrowed, allocate a new self-sufficient
 
761
 * array and copy the borrowed array into the new array;
 
762
 * otherwise, increment the reference count and return
 
763
 * the array passed in. Use this whenever you want to
 
764
 * make a copy of a method argument because arrays
 
765
 * passed into methods aren't guaranteed to exist after
 
766
 * the method call.
 
767
 */
 
768
struct sidlx_rmi_OutOfAddressesException__array*
 
769
sidlx_rmi_OutOfAddressesException__array_smartCopy(
 
770
  struct sidlx_rmi_OutOfAddressesException__array *array)
 
771
{
 
772
  return (struct sidlx_rmi_OutOfAddressesException__array*)
 
773
    sidl_interface__array_smartCopy((struct sidl_interface__array *)array);
 
774
}
 
775
 
 
776
/**
 
777
 * Increment the array's internal reference count by one.
 
778
 */
 
779
void
 
780
sidlx_rmi_OutOfAddressesException__array_addRef(
 
781
  struct sidlx_rmi_OutOfAddressesException__array* array)
 
782
{
 
783
  sidl_interface__array_addRef((struct sidl_interface__array *)array);
 
784
}
 
785
 
 
786
/**
 
787
 * Decrement the array's internal reference count by one.
 
788
 * If the reference count goes to zero, destroy the array.
 
789
 * If the array isn't borrowed, this releases all the
 
790
 * object references held by the array.
 
791
 */
 
792
void
 
793
sidlx_rmi_OutOfAddressesException__array_deleteRef(
 
794
  struct sidlx_rmi_OutOfAddressesException__array* array)
 
795
{
 
796
  sidl_interface__array_deleteRef((struct sidl_interface__array *)array);
 
797
}
 
798
 
 
799
/**
 
800
 * Retrieve element i1 of a(n) 1-dimensional array.
 
801
 */
 
802
sidlx_rmi_OutOfAddressesException
 
803
sidlx_rmi_OutOfAddressesException__array_get1(
 
804
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
805
  const int32_t i1)
 
806
{
 
807
  return (sidlx_rmi_OutOfAddressesException)
 
808
    sidl_interface__array_get1((const struct sidl_interface__array *)array
 
809
    , i1);
 
810
}
 
811
 
 
812
/**
 
813
 * Retrieve element (i1,i2) of a(n) 2-dimensional array.
 
814
 */
 
815
sidlx_rmi_OutOfAddressesException
 
816
sidlx_rmi_OutOfAddressesException__array_get2(
 
817
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
818
  const int32_t i1,
 
819
  const int32_t i2)
 
820
{
 
821
  return (sidlx_rmi_OutOfAddressesException)
 
822
    sidl_interface__array_get2((const struct sidl_interface__array *)array
 
823
    , i1, i2);
 
824
}
 
825
 
 
826
/**
 
827
 * Retrieve element (i1,i2,i3) of a(n) 3-dimensional array.
 
828
 */
 
829
sidlx_rmi_OutOfAddressesException
 
830
sidlx_rmi_OutOfAddressesException__array_get3(
 
831
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
832
  const int32_t i1,
 
833
  const int32_t i2,
 
834
  const int32_t i3)
 
835
{
 
836
  return (sidlx_rmi_OutOfAddressesException)
 
837
    sidl_interface__array_get3((const struct sidl_interface__array *)array
 
838
    , i1, i2, i3);
 
839
}
 
840
 
 
841
/**
 
842
 * Retrieve element (i1,i2,i3,i4) of a(n) 4-dimensional array.
 
843
 */
 
844
sidlx_rmi_OutOfAddressesException
 
845
sidlx_rmi_OutOfAddressesException__array_get4(
 
846
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
847
  const int32_t i1,
 
848
  const int32_t i2,
 
849
  const int32_t i3,
 
850
  const int32_t i4)
 
851
{
 
852
  return (sidlx_rmi_OutOfAddressesException)
 
853
    sidl_interface__array_get4((const struct sidl_interface__array *)array
 
854
    , i1, i2, i3, i4);
 
855
}
 
856
 
 
857
/**
 
858
 * Retrieve element (i1,i2,i3,i4,i5) of a(n) 5-dimensional array.
 
859
 */
 
860
sidlx_rmi_OutOfAddressesException
 
861
sidlx_rmi_OutOfAddressesException__array_get5(
 
862
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
863
  const int32_t i1,
 
864
  const int32_t i2,
 
865
  const int32_t i3,
 
866
  const int32_t i4,
 
867
  const int32_t i5)
 
868
{
 
869
  return (sidlx_rmi_OutOfAddressesException)
 
870
    sidl_interface__array_get5((const struct sidl_interface__array *)array
 
871
    , i1, i2, i3, i4, i5);
 
872
}
 
873
 
 
874
/**
 
875
 * Retrieve element (i1,i2,i3,i4,i5,i6) of a(n) 6-dimensional array.
 
876
 */
 
877
sidlx_rmi_OutOfAddressesException
 
878
sidlx_rmi_OutOfAddressesException__array_get6(
 
879
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
880
  const int32_t i1,
 
881
  const int32_t i2,
 
882
  const int32_t i3,
 
883
  const int32_t i4,
 
884
  const int32_t i5,
 
885
  const int32_t i6)
 
886
{
 
887
  return (sidlx_rmi_OutOfAddressesException)
 
888
    sidl_interface__array_get6((const struct sidl_interface__array *)array
 
889
    , i1, i2, i3, i4, i5, i6);
 
890
}
 
891
 
 
892
/**
 
893
 * Retrieve element (i1,i2,i3,i4,i5,i6,i7) of a(n) 7-dimensional array.
 
894
 */
 
895
sidlx_rmi_OutOfAddressesException
 
896
sidlx_rmi_OutOfAddressesException__array_get7(
 
897
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
898
  const int32_t i1,
 
899
  const int32_t i2,
 
900
  const int32_t i3,
 
901
  const int32_t i4,
 
902
  const int32_t i5,
 
903
  const int32_t i6,
 
904
  const int32_t i7)
 
905
{
 
906
  return (sidlx_rmi_OutOfAddressesException)
 
907
    sidl_interface__array_get7((const struct sidl_interface__array *)array
 
908
    , i1, i2, i3, i4, i5, i6, i7);
 
909
}
 
910
 
 
911
/**
 
912
 * Retrieve element indices of an n-dimensional array.
 
913
 * indices is assumed to have the right number of elements
 
914
 * for the dimension of array.
 
915
 */
 
916
sidlx_rmi_OutOfAddressesException
 
917
sidlx_rmi_OutOfAddressesException__array_get(
 
918
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
919
  const int32_t indices[])
 
920
{
 
921
  return (sidlx_rmi_OutOfAddressesException)
 
922
    sidl_interface__array_get((const struct sidl_interface__array *)array, 
 
923
      indices);
 
924
}
 
925
 
 
926
/**
 
927
 * Set element i1 of a(n) 1-dimensional array to value.
 
928
 */
 
929
void
 
930
sidlx_rmi_OutOfAddressesException__array_set1(
 
931
  struct sidlx_rmi_OutOfAddressesException__array* array,
 
932
  const int32_t i1,
 
933
  sidlx_rmi_OutOfAddressesException const value)
 
934
{
 
935
  sidl_interface__array_set1((struct sidl_interface__array *)array
 
936
  , i1, (struct sidl_BaseInterface__object *)value);
 
937
}
 
938
 
 
939
/**
 
940
 * Set element (i1,i2) of a(n) 2-dimensional array to value.
 
941
 */
 
942
void
 
943
sidlx_rmi_OutOfAddressesException__array_set2(
 
944
  struct sidlx_rmi_OutOfAddressesException__array* array,
 
945
  const int32_t i1,
 
946
  const int32_t i2,
 
947
  sidlx_rmi_OutOfAddressesException const value)
 
948
{
 
949
  sidl_interface__array_set2((struct sidl_interface__array *)array
 
950
  , i1, i2, (struct sidl_BaseInterface__object *)value);
 
951
}
 
952
 
 
953
/**
 
954
 * Set element (i1,i2,i3) of a(n) 3-dimensional array to value.
 
955
 */
 
956
void
 
957
sidlx_rmi_OutOfAddressesException__array_set3(
 
958
  struct sidlx_rmi_OutOfAddressesException__array* array,
 
959
  const int32_t i1,
 
960
  const int32_t i2,
 
961
  const int32_t i3,
 
962
  sidlx_rmi_OutOfAddressesException const value)
 
963
{
 
964
  sidl_interface__array_set3((struct sidl_interface__array *)array
 
965
  , i1, i2, i3, (struct sidl_BaseInterface__object *)value);
 
966
}
 
967
 
 
968
/**
 
969
 * Set element (i1,i2,i3,i4) of a(n) 4-dimensional array to value.
 
970
 */
 
971
void
 
972
sidlx_rmi_OutOfAddressesException__array_set4(
 
973
  struct sidlx_rmi_OutOfAddressesException__array* array,
 
974
  const int32_t i1,
 
975
  const int32_t i2,
 
976
  const int32_t i3,
 
977
  const int32_t i4,
 
978
  sidlx_rmi_OutOfAddressesException const value)
 
979
{
 
980
  sidl_interface__array_set4((struct sidl_interface__array *)array
 
981
  , i1, i2, i3, i4, (struct sidl_BaseInterface__object *)value);
 
982
}
 
983
 
 
984
/**
 
985
 * Set element (i1,i2,i3,i4,i5) of a(n) 5-dimensional array to value.
 
986
 */
 
987
void
 
988
sidlx_rmi_OutOfAddressesException__array_set5(
 
989
  struct sidlx_rmi_OutOfAddressesException__array* array,
 
990
  const int32_t i1,
 
991
  const int32_t i2,
 
992
  const int32_t i3,
 
993
  const int32_t i4,
 
994
  const int32_t i5,
 
995
  sidlx_rmi_OutOfAddressesException const value)
 
996
{
 
997
  sidl_interface__array_set5((struct sidl_interface__array *)array
 
998
  , i1, i2, i3, i4, i5, (struct sidl_BaseInterface__object *)value);
 
999
}
 
1000
 
 
1001
/**
 
1002
 * Set element (i1,i2,i3,i4,i5,i6) of a(n) 6-dimensional array to value.
 
1003
 */
 
1004
void
 
1005
sidlx_rmi_OutOfAddressesException__array_set6(
 
1006
  struct sidlx_rmi_OutOfAddressesException__array* array,
 
1007
  const int32_t i1,
 
1008
  const int32_t i2,
 
1009
  const int32_t i3,
 
1010
  const int32_t i4,
 
1011
  const int32_t i5,
 
1012
  const int32_t i6,
 
1013
  sidlx_rmi_OutOfAddressesException const value)
 
1014
{
 
1015
  sidl_interface__array_set6((struct sidl_interface__array *)array
 
1016
  , i1, i2, i3, i4, i5, i6, (struct sidl_BaseInterface__object *)value);
 
1017
}
 
1018
 
 
1019
/**
 
1020
 * Set element (i1,i2,i3,i4,i5,i6,i7) of a(n) 7-dimensional array to value.
 
1021
 */
 
1022
void
 
1023
sidlx_rmi_OutOfAddressesException__array_set7(
 
1024
  struct sidlx_rmi_OutOfAddressesException__array* array,
 
1025
  const int32_t i1,
 
1026
  const int32_t i2,
 
1027
  const int32_t i3,
 
1028
  const int32_t i4,
 
1029
  const int32_t i5,
 
1030
  const int32_t i6,
 
1031
  const int32_t i7,
 
1032
  sidlx_rmi_OutOfAddressesException const value)
 
1033
{
 
1034
  sidl_interface__array_set7((struct sidl_interface__array *)array
 
1035
  , i1, i2, i3, i4, i5, i6, i7, (struct sidl_BaseInterface__object *)value);
 
1036
}
 
1037
 
 
1038
/**
 
1039
 * Set element indices of an n-dimensional array to value.indices is assumed to have the right number of elements
 
1040
 * for the dimension of array.
 
1041
 */
 
1042
void
 
1043
sidlx_rmi_OutOfAddressesException__array_set(
 
1044
  struct sidlx_rmi_OutOfAddressesException__array* array,
 
1045
  const int32_t indices[],
 
1046
  sidlx_rmi_OutOfAddressesException const value)
 
1047
{
 
1048
  sidl_interface__array_set((struct sidl_interface__array *)array, indices, (
 
1049
    struct sidl_BaseInterface__object *)value);
 
1050
}
 
1051
 
 
1052
/**
 
1053
 * Return the dimension of array. If the array pointer is
 
1054
 * NULL, zero is returned.
 
1055
 */
 
1056
int32_t
 
1057
sidlx_rmi_OutOfAddressesException__array_dimen(
 
1058
  const struct sidlx_rmi_OutOfAddressesException__array* array)
 
1059
{
 
1060
  return sidl_interface__array_dimen((struct sidl_interface__array *)array);
 
1061
}
 
1062
 
 
1063
/**
 
1064
 * Return the lower bound of dimension ind.
 
1065
 * If ind is not a valid dimension, 0 is returned.
 
1066
 * The valid range for ind is from 0 to dimen-1.
 
1067
 */
 
1068
int32_t
 
1069
sidlx_rmi_OutOfAddressesException__array_lower(
 
1070
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
1071
  const int32_t ind)
 
1072
{
 
1073
  return sidl_interface__array_lower((struct sidl_interface__array *)array, 
 
1074
    ind);
 
1075
}
 
1076
 
 
1077
/**
 
1078
 * Return the upper bound of dimension ind.
 
1079
 * If ind is not a valid dimension, -1 is returned.
 
1080
 * The valid range for ind is from 0 to dimen-1.
 
1081
 */
 
1082
int32_t
 
1083
sidlx_rmi_OutOfAddressesException__array_upper(
 
1084
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
1085
  const int32_t ind)
 
1086
{
 
1087
  return sidl_interface__array_upper((struct sidl_interface__array *)array, 
 
1088
    ind);
 
1089
}
 
1090
 
 
1091
/**
 
1092
 * Return the length of dimension ind.
 
1093
 * If ind is not a valid dimension, -1 is returned.
 
1094
 * The valid range for ind is from 0 to dimen-1.
 
1095
 */
 
1096
int32_t
 
1097
sidlx_rmi_OutOfAddressesException__array_length(
 
1098
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
1099
  const int32_t ind)
 
1100
{
 
1101
  return sidl_interface__array_length((struct sidl_interface__array *)array, 
 
1102
    ind);
 
1103
}
 
1104
 
 
1105
/**
 
1106
 * Return the stride of dimension ind.
 
1107
 * If ind is not a valid dimension, 0 is returned.
 
1108
 * The valid range for ind is from 0 to dimen-1.
 
1109
 */
 
1110
int32_t
 
1111
sidlx_rmi_OutOfAddressesException__array_stride(
 
1112
  const struct sidlx_rmi_OutOfAddressesException__array* array,
 
1113
  const int32_t ind)
 
1114
{
 
1115
  return sidl_interface__array_stride((struct sidl_interface__array *)array, 
 
1116
    ind);
 
1117
}
 
1118
 
 
1119
/**
 
1120
 * Return a true value iff the array is a contiguous
 
1121
 * column-major ordered array. A NULL array argument
 
1122
 * causes 0 to be returned.
 
1123
 */
 
1124
int
 
1125
sidlx_rmi_OutOfAddressesException__array_isColumnOrder(
 
1126
  const struct sidlx_rmi_OutOfAddressesException__array* array)
 
1127
{
 
1128
  return sidl_interface__array_isColumnOrder((struct sidl_interface__array 
 
1129
    *)array);
 
1130
}
 
1131
 
 
1132
/**
 
1133
 * Return a true value iff the array is a contiguous
 
1134
 * row-major ordered array. A NULL array argument
 
1135
 * causes 0 to be returned.
 
1136
 */
 
1137
int
 
1138
sidlx_rmi_OutOfAddressesException__array_isRowOrder(
 
1139
  const struct sidlx_rmi_OutOfAddressesException__array* array)
 
1140
{
 
1141
  return sidl_interface__array_isRowOrder((struct sidl_interface__array 
 
1142
    *)array);
 
1143
}
 
1144
 
 
1145
/**
 
1146
 * Copy the contents of one array (src) to a second array
 
1147
 * (dest). For the copy to take place, both arrays must
 
1148
 * exist and be of the same dimension. This method will
 
1149
 * not modify dest's size, index bounds, or stride; only
 
1150
 * the array element values of dest may be changed by
 
1151
 * this function. No part of src is ever changed by copy.
 
1152
 * 
 
1153
 * On exit, dest[i][j][k]... = src[i][j][k]... for all
 
1154
 * indices i,j,k...  that are in both arrays. If dest and
 
1155
 * src have no indices in common, nothing is copied. For
 
1156
 * example, if src is a 1-d array with elements 0-5 and
 
1157
 * dest is a 1-d array with elements 2-3, this function
 
1158
 * will make the following assignments:
 
1159
 *   dest[2] = src[2],
 
1160
 *   dest[3] = src[3].
 
1161
 * The function copied the elements that both arrays have
 
1162
 * in common.  If dest had elements 4-10, this function
 
1163
 * will make the following assignments:
 
1164
 *   dest[4] = src[4],
 
1165
 *   dest[5] = src[5].
 
1166
 */
 
1167
void
 
1168
sidlx_rmi_OutOfAddressesException__array_copy(
 
1169
  const struct sidlx_rmi_OutOfAddressesException__array* src,
 
1170
  struct sidlx_rmi_OutOfAddressesException__array* dest)
 
1171
{
 
1172
  sidl_interface__array_copy((const struct sidl_interface__array *)src,
 
1173
                             (struct sidl_interface__array *)dest);
 
1174
}
 
1175
 
 
1176
/**
 
1177
 * Create a sub-array of another array. This resulting
 
1178
 * array shares data with the original array. The new
 
1179
 * array can be of the same dimension or potentially
 
1180
 * less assuming the original array has dimension
 
1181
 * greater than 1.  If you are removing dimension,
 
1182
 * indicate the dimensions to remove by setting
 
1183
 * numElem[i] to zero for any dimension i wthat should
 
1184
 * go away in the new array.  The meaning of each
 
1185
 * argument is covered below.
 
1186
 * 
 
1187
 * src       the array to be created will be a subset
 
1188
 *           of this array. If this argument is NULL,
 
1189
 *           NULL will be returned. The array returned
 
1190
 *           borrows data from src, so modifying src or
 
1191
 *           the returned array will modify both
 
1192
 *           arrays.
 
1193
 * 
 
1194
 * dimen     this argument must be greater than zero
 
1195
 *           and less than or equal to the dimension of
 
1196
 *           src. An illegal value will cause a NULL
 
1197
 *           return value.
 
1198
 * 
 
1199
 * numElem   this specifies how many elements from src
 
1200
 *           should be taken in each dimension. A zero
 
1201
 *           entry indicates that the dimension should
 
1202
 *           not appear in the new array.  This
 
1203
 *           argument should be an array with an entry
 
1204
 *           for each dimension of src.  Passing NULL
 
1205
 *           here will cause NULL to be returned.  If
 
1206
 *           srcStart[i] + numElem[i]*srcStride[i] is
 
1207
 *           greater than upper[i] for src or if
 
1208
 *           srcStart[i] + numElem[i]*srcStride[i] is
 
1209
 *           less than lower[i] for src, NULL will be
 
1210
 *           returned.
 
1211
 * 
 
1212
 * srcStart  this array holds the coordinates of the
 
1213
 *           first element of the new array. If this
 
1214
 *           argument is NULL, the first element of src
 
1215
 *           will be the first element of the new
 
1216
 *           array. If non-NULL, this argument should
 
1217
 *           be an array with an entry for each
 
1218
 *           dimension of src.  If srcStart[i] is less
 
1219
 *           than lower[i] for the array src, NULL will
 
1220
 *           be returned.
 
1221
 * 
 
1222
 * srcStride this array lets you specify the stride
 
1223
 *           between elements in each dimension of
 
1224
 *           src. This stride is relative to the
 
1225
 *           coordinate system of the src array. If
 
1226
 *           this argument is NULL, the stride is taken
 
1227
 *           to be one in each dimension.  If non-NULL,
 
1228
 *           this argument should be an array with an
 
1229
 *           entry for each dimension of src.
 
1230
 * 
 
1231
 * newLower  this argument is like lower in a create
 
1232
 *           method. It sets the coordinates for the
 
1233
 *           first element in the new array.  If this
 
1234
 *           argument is NULL, the values indicated by
 
1235
 *           srcStart will be used. If non-NULL, this
 
1236
 *           should be an array with dimen elements.
 
1237
 */
 
1238
struct sidlx_rmi_OutOfAddressesException__array*
 
1239
sidlx_rmi_OutOfAddressesException__array_slice(
 
1240
  struct sidlx_rmi_OutOfAddressesException__array* src,
 
1241
  int32_t        dimen,
 
1242
  const int32_t  numElem[],
 
1243
  const int32_t  *srcStart,
 
1244
  const int32_t  *srcStride,
 
1245
  const int32_t  *newStart)
 
1246
{
 
1247
  return (struct sidlx_rmi_OutOfAddressesException__array*)
 
1248
    sidl_interface__array_slice((struct sidl_interface__array *)src,
 
1249
                                dimen, numElem, srcStart, srcStride, newStart);
 
1250
}
 
1251
 
 
1252
/**
 
1253
 * If necessary, convert a general matrix into a matrix
 
1254
 * with the required properties. This checks the
 
1255
 * dimension and ordering of the matrix.  If both these
 
1256
 * match, it simply returns a new reference to the
 
1257
 * existing matrix. If the dimension of the incoming
 
1258
 * array doesn't match, it returns NULL. If the ordering
 
1259
 * of the incoming array doesn't match the specification,
 
1260
 * a new array is created with the desired ordering and
 
1261
 * the content of the incoming array is copied to the new
 
1262
 * array.
 
1263
 * 
 
1264
 * The ordering parameter should be one of the constants
 
1265
 * defined in enum sidl_array_ordering
 
1266
 * (e.g. sidl_general_order, sidl_column_major_order, or
 
1267
 * sidl_row_major_order). If you specify
 
1268
 * sidl_general_order, this routine will only check the
 
1269
 * dimension because any matrix is sidl_general_order.
 
1270
 * 
 
1271
 * The caller assumes ownership of the returned reference
 
1272
 * unless it's NULL.
 
1273
 */
 
1274
struct sidlx_rmi_OutOfAddressesException__array*
 
1275
sidlx_rmi_OutOfAddressesException__array_ensure(
 
1276
  struct sidlx_rmi_OutOfAddressesException__array* src,
 
1277
  int32_t dimen,
 
1278
  int     ordering)
 
1279
{
 
1280
  return (struct sidlx_rmi_OutOfAddressesException__array*)
 
1281
    sidl_interface__array_ensure((struct sidl_interface__array *)src, dimen, 
 
1282
      ordering);
 
1283
}
 
1284
 
 
1285
#ifdef WITH_RMI
 
1286
 
 
1287
#include <stdlib.h>
 
1288
#include <string.h>
 
1289
#include <stdio.h>
 
1290
#ifndef included_sidl_BaseClass_h
 
1291
#include "sidl_BaseClass.h"
 
1292
#endif
 
1293
#ifndef included_sidl_ClassInfo_h
 
1294
#include "sidl_ClassInfo.h"
 
1295
#endif
 
1296
#ifndef included_sidl_rmi_ProtocolFactory_h
 
1297
#include "sidl_rmi_ProtocolFactory.h"
 
1298
#endif
 
1299
#ifndef included_sidl_rmi_InstanceRegistry_h
 
1300
#include "sidl_rmi_InstanceRegistry.h"
 
1301
#endif
 
1302
#ifndef included_sidl_rmi_InstanceHandle_h
 
1303
#include "sidl_rmi_InstanceHandle.h"
 
1304
#endif
 
1305
#ifndef included_sidl_rmi_Invocation_h
 
1306
#include "sidl_rmi_Invocation.h"
 
1307
#endif
 
1308
#ifndef included_sidl_rmi_Response_h
 
1309
#include "sidl_rmi_Response.h"
 
1310
#endif
 
1311
#ifndef included_sidl_rmi_ServerRegistry_h
 
1312
#include "sidl_rmi_ServerRegistry.h"
 
1313
#endif
 
1314
#ifndef included_sidl_rmi_ConnectRegistry_h
 
1315
#include "sidl_rmi_ConnectRegistry.h"
 
1316
#endif
 
1317
#ifndef included_sidl_io_Serializable_h
 
1318
#include "sidl_io_Serializable.h"
 
1319
#endif
 
1320
#ifndef included_sidl_MemAllocException_h
 
1321
#include "sidl_MemAllocException.h"
 
1322
#endif
 
1323
#ifndef included_sidl_NotImplementedException_h
 
1324
#include "sidl_NotImplementedException.h"
 
1325
#endif
 
1326
#include "sidl_Exception.h"
 
1327
 
 
1328
#ifndef NULL
 
1329
#define NULL 0
 
1330
#endif
 
1331
 
 
1332
#include "sidl_thread.h"
 
1333
#ifdef HAVE_PTHREAD
 
1334
static struct sidl_recursive_mutex_t sidlx_rmi_OutOfAddressesException__mutex= SIDL_RECURSIVE_MUTEX_INITIALIZER;
 
1335
#define LOCK_STATIC_GLOBALS sidl_recursive_mutex_lock( &sidlx_rmi_OutOfAddressesException__mutex )
 
1336
#define UNLOCK_STATIC_GLOBALS sidl_recursive_mutex_unlock( &sidlx_rmi_OutOfAddressesException__mutex )
 
1337
/* #define HAVE_LOCKED_STATIC_GLOBALS (sidl_recursive_mutex_trylock( &sidlx_rmi_OutOfAddressesException__mutex )==EDEADLOCK) */
 
1338
#else
 
1339
#define LOCK_STATIC_GLOBALS
 
1340
#define UNLOCK_STATIC_GLOBALS
 
1341
/* #define HAVE_LOCKED_STATIC_GLOBALS (1) */
 
1342
#endif
 
1343
 
 
1344
/* Static variables to hold version of IOR */
 
1345
static const int32_t s_IOR_MAJOR_VERSION = 2;
 
1346
static const int32_t s_IOR_MINOR_VERSION = 0;
 
1347
 
 
1348
/* Static variables for managing EPV initialization. */
 
1349
static int s_remote_initialized = 0;
 
1350
 
 
1351
static struct sidlx_rmi_OutOfAddressesException__epv 
 
1352
  s_rem_epv__sidlx_rmi_outofaddressesexception;
 
1353
 
 
1354
static struct sidl_BaseClass__epv  s_rem_epv__sidl_baseclass;
 
1355
 
 
1356
static struct sidl_BaseException__epv  s_rem_epv__sidl_baseexception;
 
1357
 
 
1358
static struct sidl_BaseInterface__epv  s_rem_epv__sidl_baseinterface;
 
1359
 
 
1360
static struct sidl_RuntimeException__epv  s_rem_epv__sidl_runtimeexception;
 
1361
 
 
1362
static struct sidl_SIDLException__epv  s_rem_epv__sidl_sidlexception;
 
1363
 
 
1364
static struct sidl_io_IOException__epv  s_rem_epv__sidl_io_ioexception;
 
1365
 
 
1366
static struct sidl_io_Serializable__epv  s_rem_epv__sidl_io_serializable;
 
1367
 
 
1368
static struct sidl_rmi_NetworkException__epv  
 
1369
  s_rem_epv__sidl_rmi_networkexception;
 
1370
 
 
1371
static struct sidl_rmi_ProtocolException__epv  
 
1372
  s_rem_epv__sidl_rmi_protocolexception;
 
1373
 
 
1374
static struct sidlx_rmi_RecoverableException__epv  
 
1375
  s_rem_epv__sidlx_rmi_recoverableexception;
 
1376
 
 
1377
 
 
1378
/* REMOTE CAST: dynamic type casting for remote objects. */
 
1379
static void* remote_sidlx_rmi_OutOfAddressesException__cast(
 
1380
  struct sidlx_rmi_OutOfAddressesException__object* self,
 
1381
  const char* name, sidl_BaseInterface* _ex)
 
1382
{
 
1383
  int cmp;
 
1384
  void* cast = NULL;
 
1385
  *_ex = NULL; /* default to no exception */
 
1386
  cmp = strcmp(name, "sidl.io.IOException");
 
1387
  if (!cmp) {
 
1388
    (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1389
    cast = ((struct sidl_io_IOException__object*)self);
 
1390
    return cast;
 
1391
  }
 
1392
  else if (cmp < 0) {
 
1393
    cmp = strcmp(name, "sidl.BaseInterface");
 
1394
    if (!cmp) {
 
1395
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1396
      cast = &((
 
1397
        *self).d_sidlx_rmi_recoverableexception.d_sidl_rmi_protocolexception.d_sidl_rmi_networkexception.d_sidl_io_ioexception.d_sidl_sidlexception.d_sidl_baseclass.d_sidl_baseinterface);
 
1398
      return cast;
 
1399
    }
 
1400
    else if (cmp < 0) {
 
1401
      cmp = strcmp(name, "sidl.BaseException");
 
1402
      if (!cmp) {
 
1403
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1404
        cast = &((
 
1405
          *self).d_sidlx_rmi_recoverableexception.d_sidl_rmi_protocolexception.d_sidl_rmi_networkexception.d_sidl_io_ioexception.d_sidl_sidlexception.d_sidl_baseexception);
 
1406
        return cast;
 
1407
      }
 
1408
      else if (cmp < 0) {
 
1409
        cmp = strcmp(name, "sidl.BaseClass");
 
1410
        if (!cmp) {
 
1411
          (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1412
          cast = ((struct sidl_BaseClass__object*)self);
 
1413
          return cast;
 
1414
        }
 
1415
      }
 
1416
    }
 
1417
    else if (cmp > 0) {
 
1418
      cmp = strcmp(name, "sidl.SIDLException");
 
1419
      if (!cmp) {
 
1420
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1421
        cast = ((struct sidl_SIDLException__object*)self);
 
1422
        return cast;
 
1423
      }
 
1424
      else if (cmp < 0) {
 
1425
        cmp = strcmp(name, "sidl.RuntimeException");
 
1426
        if (!cmp) {
 
1427
          (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1428
          cast = &((
 
1429
            *self).d_sidlx_rmi_recoverableexception.d_sidl_rmi_protocolexception.d_sidl_rmi_networkexception.d_sidl_io_ioexception.d_sidl_runtimeexception);
 
1430
          return cast;
 
1431
        }
 
1432
      }
 
1433
    }
 
1434
  }
 
1435
  else if (cmp > 0) {
 
1436
    cmp = strcmp(name, "sidl.rmi.ProtocolException");
 
1437
    if (!cmp) {
 
1438
      (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1439
      cast = ((struct sidl_rmi_ProtocolException__object*)self);
 
1440
      return cast;
 
1441
    }
 
1442
    else if (cmp < 0) {
 
1443
      cmp = strcmp(name, "sidl.rmi.NetworkException");
 
1444
      if (!cmp) {
 
1445
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1446
        cast = ((struct sidl_rmi_NetworkException__object*)self);
 
1447
        return cast;
 
1448
      }
 
1449
      else if (cmp < 0) {
 
1450
        cmp = strcmp(name, "sidl.io.Serializable");
 
1451
        if (!cmp) {
 
1452
          (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1453
          cast = &((
 
1454
            *self).d_sidlx_rmi_recoverableexception.d_sidl_rmi_protocolexception.d_sidl_rmi_networkexception.d_sidl_io_ioexception.d_sidl_sidlexception.d_sidl_io_serializable);
 
1455
          return cast;
 
1456
        }
 
1457
      }
 
1458
    }
 
1459
    else if (cmp > 0) {
 
1460
      cmp = strcmp(name, "sidlx.rmi.RecoverableException");
 
1461
      if (!cmp) {
 
1462
        (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1463
        cast = ((struct sidlx_rmi_RecoverableException__object*)self);
 
1464
        return cast;
 
1465
      }
 
1466
      else if (cmp < 0) {
 
1467
        cmp = strcmp(name, "sidlx.rmi.OutOfAddressesException");
 
1468
        if (!cmp) {
 
1469
          (*self->d_epv->f_addRef)(self, _ex); SIDL_CHECK(*_ex);
 
1470
          cast = ((struct sidlx_rmi_OutOfAddressesException__object*)self);
 
1471
          return cast;
 
1472
        }
 
1473
      }
 
1474
    }
 
1475
  }
 
1476
  if ((*self->d_epv->f_isType)(self,name, _ex)) {
 
1477
    void* (*func)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1478
      sidl_BaseInterface__object**) = 
 
1479
      (void* (*)(struct sidl_rmi_InstanceHandle__object*, struct 
 
1480
        sidl_BaseInterface__object**)) 
 
1481
      sidl_rmi_ConnectRegistry_getConnect(name, _ex);SIDL_CHECK(*_ex);
 
1482
    cast =  (*func)(((struct 
 
1483
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih, _ex);
 
1484
  }
 
1485
 
 
1486
  return cast;
 
1487
  EXIT:
 
1488
  return NULL;
 
1489
}
 
1490
 
 
1491
/* REMOTE DELETE: call the remote destructor for the object. */
 
1492
static void remote_sidlx_rmi_OutOfAddressesException__delete(
 
1493
  struct sidlx_rmi_OutOfAddressesException__object* self,
 
1494
  struct sidl_BaseInterface__object* *_ex)
 
1495
{
 
1496
  *_ex = NULL;
 
1497
  free((void*) self);
 
1498
}
 
1499
 
 
1500
/* REMOTE GETURL: call the getURL function for the object. */
 
1501
static char* remote_sidlx_rmi_OutOfAddressesException__getURL(
 
1502
  struct sidlx_rmi_OutOfAddressesException__object* self, struct 
 
1503
    sidl_BaseInterface__object* *_ex)
 
1504
{
 
1505
  struct sidl_rmi_InstanceHandle__object *conn = ((struct 
 
1506
    sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
1507
  *_ex = NULL;
 
1508
  if(conn != NULL) {
 
1509
    return sidl_rmi_InstanceHandle_getObjectURL(conn, _ex);
 
1510
  }
 
1511
  return NULL;
 
1512
}
 
1513
 
 
1514
/* REMOTE ADDREF: For internal babel use only! Remote addRef. */
 
1515
static void remote_sidlx_rmi_OutOfAddressesException__raddRef(
 
1516
  struct sidlx_rmi_OutOfAddressesException__object* self,struct 
 
1517
    sidl_BaseInterface__object* *_ex)
 
1518
{
 
1519
  struct sidl_BaseException__object* netex = NULL;
 
1520
  /* initialize a new invocation */
 
1521
  struct sidl_BaseInterface__object* _throwaway = NULL;
 
1522
  struct sidl_rmi_InstanceHandle__object *_conn = ((struct 
 
1523
    sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
1524
  sidl_rmi_Response _rsvp = NULL;
 
1525
  sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
1526
    "addRef", _ex ); SIDL_CHECK(*_ex);
 
1527
  /* send actual RMI request */
 
1528
  _rsvp = sidl_rmi_Invocation_invokeMethod(_inv,_ex);SIDL_CHECK(*_ex);
 
1529
  /* Check for exceptions */
 
1530
  netex = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);
 
1531
  if(netex != NULL) {
 
1532
    *_ex = (struct sidl_BaseInterface__object*)netex;
 
1533
    return;
 
1534
  }
 
1535
 
 
1536
  /* cleanup and return */
 
1537
  EXIT:
 
1538
  if(_inv) { sidl_rmi_Invocation_deleteRef(_inv,&_throwaway); }
 
1539
  if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp,&_throwaway); }
 
1540
  return;
 
1541
}
 
1542
 
 
1543
/* REMOTE ISREMOTE: returns true if this object is Remote (it is). */
 
1544
static sidl_bool
 
1545
remote_sidlx_rmi_OutOfAddressesException__isRemote(
 
1546
    struct sidlx_rmi_OutOfAddressesException__object* self, 
 
1547
    struct sidl_BaseInterface__object* *_ex) {
 
1548
  *_ex = NULL;
 
1549
  return TRUE;
 
1550
}
 
1551
 
 
1552
/* REMOTE METHOD STUB:_set_hooks */
 
1553
static void
 
1554
remote_sidlx_rmi_OutOfAddressesException__set_hooks(
 
1555
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
1556
  /* in */ sidl_bool on,
 
1557
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
1558
{
 
1559
  LANG_SPECIFIC_INIT();
 
1560
  *_ex = NULL;
 
1561
  {
 
1562
    /* initialize a new invocation */
 
1563
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
1564
    sidl_BaseException _be = NULL;
 
1565
    sidl_rmi_Response _rsvp = NULL;
 
1566
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1567
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
1568
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
1569
      "_set_hooks", _ex ); SIDL_CHECK(*_ex);
 
1570
 
 
1571
    /* pack in and inout arguments */
 
1572
    sidl_rmi_Invocation_packBool( _inv, "on", on, _ex);SIDL_CHECK(*_ex);
 
1573
 
 
1574
    /* send actual RMI request */
 
1575
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1576
 
 
1577
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1578
    if(_be != NULL) {
 
1579
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
1580
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException._set_hooks.", &throwaway_exception);
 
1581
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
1582
        &throwaway_exception);
 
1583
      goto EXIT;
 
1584
    }
 
1585
 
 
1586
    /* unpack out and inout arguments */
 
1587
 
 
1588
    /* cleanup and return */
 
1589
    EXIT:
 
1590
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1591
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1592
    return;
 
1593
  }
 
1594
}
 
1595
 
 
1596
/* REMOTE EXEC: call the exec function for the object. */
 
1597
static void remote_sidlx_rmi_OutOfAddressesException__exec(
 
1598
  struct sidlx_rmi_OutOfAddressesException__object* self,const char* methodName,
 
1599
  sidl_rmi_Call inArgs,
 
1600
  sidl_rmi_Return outArgs,
 
1601
  struct sidl_BaseInterface__object* *_ex)
 
1602
{
 
1603
  *_ex = NULL;
 
1604
}
 
1605
 
 
1606
/* REMOTE METHOD STUB:getHopCount */
 
1607
static int32_t
 
1608
remote_sidlx_rmi_OutOfAddressesException_getHopCount(
 
1609
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
1610
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
1611
{
 
1612
  LANG_SPECIFIC_INIT();
 
1613
  *_ex = NULL;
 
1614
  {
 
1615
    /* initialize a new invocation */
 
1616
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
1617
    sidl_BaseException _be = NULL;
 
1618
    sidl_rmi_Response _rsvp = NULL;
 
1619
    int32_t _retval = 0;
 
1620
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1621
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
1622
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
1623
      "getHopCount", _ex ); SIDL_CHECK(*_ex);
 
1624
 
 
1625
    /* pack in and inout arguments */
 
1626
 
 
1627
    /* send actual RMI request */
 
1628
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1629
 
 
1630
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1631
    if(_be != NULL) {
 
1632
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
1633
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.getHopCount.", &throwaway_exception);
 
1634
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
1635
        &throwaway_exception);
 
1636
      goto EXIT;
 
1637
    }
 
1638
 
 
1639
    /* extract return value */
 
1640
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1641
      *_ex);
 
1642
 
 
1643
    /* unpack out and inout arguments */
 
1644
 
 
1645
    /* cleanup and return */
 
1646
    EXIT:
 
1647
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1648
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1649
    return _retval;
 
1650
  }
 
1651
}
 
1652
 
 
1653
/* REMOTE METHOD STUB:setErrno */
 
1654
static void
 
1655
remote_sidlx_rmi_OutOfAddressesException_setErrno(
 
1656
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
1657
  /* in */ int32_t err,
 
1658
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
1659
{
 
1660
  LANG_SPECIFIC_INIT();
 
1661
  *_ex = NULL;
 
1662
  {
 
1663
    /* initialize a new invocation */
 
1664
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
1665
    sidl_BaseException _be = NULL;
 
1666
    sidl_rmi_Response _rsvp = NULL;
 
1667
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1668
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
1669
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
1670
      "setErrno", _ex ); SIDL_CHECK(*_ex);
 
1671
 
 
1672
    /* pack in and inout arguments */
 
1673
    sidl_rmi_Invocation_packInt( _inv, "err", err, _ex);SIDL_CHECK(*_ex);
 
1674
 
 
1675
    /* send actual RMI request */
 
1676
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1677
 
 
1678
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1679
    if(_be != NULL) {
 
1680
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
1681
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.setErrno.", &throwaway_exception);
 
1682
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
1683
        &throwaway_exception);
 
1684
      goto EXIT;
 
1685
    }
 
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;
 
1694
  }
 
1695
}
 
1696
 
 
1697
/* REMOTE METHOD STUB:getErrno */
 
1698
static int32_t
 
1699
remote_sidlx_rmi_OutOfAddressesException_getErrno(
 
1700
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
1701
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
1702
{
 
1703
  LANG_SPECIFIC_INIT();
 
1704
  *_ex = NULL;
 
1705
  {
 
1706
    /* initialize a new invocation */
 
1707
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
1708
    sidl_BaseException _be = NULL;
 
1709
    sidl_rmi_Response _rsvp = NULL;
 
1710
    int32_t _retval = 0;
 
1711
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1712
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
1713
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
1714
      "getErrno", _ex ); SIDL_CHECK(*_ex);
 
1715
 
 
1716
    /* pack in and inout arguments */
 
1717
 
 
1718
    /* send actual RMI request */
 
1719
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1720
 
 
1721
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1722
    if(_be != NULL) {
 
1723
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
1724
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.getErrno.", &throwaway_exception);
 
1725
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
1726
        &throwaway_exception);
 
1727
      goto EXIT;
 
1728
    }
 
1729
 
 
1730
    /* extract return value */
 
1731
    sidl_rmi_Response_unpackInt( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1732
      *_ex);
 
1733
 
 
1734
    /* unpack out and inout arguments */
 
1735
 
 
1736
    /* cleanup and return */
 
1737
    EXIT:
 
1738
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1739
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1740
    return _retval;
 
1741
  }
 
1742
}
 
1743
 
 
1744
/* REMOTE METHOD STUB:addRef */
 
1745
static void
 
1746
remote_sidlx_rmi_OutOfAddressesException_addRef(
 
1747
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
1748
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
1749
{
 
1750
  LANG_SPECIFIC_INIT();
 
1751
  *_ex = NULL;
 
1752
  {
 
1753
    struct sidlx_rmi_OutOfAddressesException__remote* r_obj = (struct 
 
1754
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data;
 
1755
    LOCK_STATIC_GLOBALS;
 
1756
    r_obj->d_refcount++;
 
1757
#ifdef SIDL_DEBUG_REFCOUNT
 
1758
    fprintf(stderr, "babel: addRef %p new count %d (type %s)\n",r_obj, r_obj->d_refcount, "sidlx.rmi.OutOfAddressesException Remote Stub");
 
1759
#endif /* SIDL_DEBUG_REFCOUNT */ 
 
1760
    UNLOCK_STATIC_GLOBALS;
 
1761
  }
 
1762
}
 
1763
 
 
1764
/* REMOTE METHOD STUB:deleteRef */
 
1765
static void
 
1766
remote_sidlx_rmi_OutOfAddressesException_deleteRef(
 
1767
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
1768
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
1769
{
 
1770
  LANG_SPECIFIC_INIT();
 
1771
  *_ex = NULL;
 
1772
  {
 
1773
    struct sidlx_rmi_OutOfAddressesException__remote* r_obj = (struct 
 
1774
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data;
 
1775
    LOCK_STATIC_GLOBALS;
 
1776
    r_obj->d_refcount--;
 
1777
#ifdef SIDL_DEBUG_REFCOUNT
 
1778
    fprintf(stderr, "babel: deleteRef %p new count %d (type %s)\n",r_obj, r_obj->d_refcount, "sidlx.rmi.OutOfAddressesException Remote Stub");
 
1779
#endif /* SIDL_DEBUG_REFCOUNT */ 
 
1780
    if(r_obj->d_refcount == 0) {
 
1781
      sidl_rmi_InstanceHandle_deleteRef(r_obj->d_ih, _ex);
 
1782
      free(r_obj);
 
1783
      free(self);
 
1784
    }
 
1785
    UNLOCK_STATIC_GLOBALS;
 
1786
  }
 
1787
}
 
1788
 
 
1789
/* REMOTE METHOD STUB:isSame */
 
1790
static sidl_bool
 
1791
remote_sidlx_rmi_OutOfAddressesException_isSame(
 
1792
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
1793
  /* in */ struct sidl_BaseInterface__object* iobj,
 
1794
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
1795
{
 
1796
  LANG_SPECIFIC_INIT();
 
1797
  *_ex = NULL;
 
1798
  {
 
1799
    /* initialize a new invocation */
 
1800
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
1801
    sidl_BaseException _be = NULL;
 
1802
    sidl_rmi_Response _rsvp = NULL;
 
1803
    sidl_bool _retval = FALSE;
 
1804
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1805
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
1806
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
1807
      "isSame", _ex ); SIDL_CHECK(*_ex);
 
1808
 
 
1809
    /* pack in and inout arguments */
 
1810
    if(iobj){
 
1811
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)iobj, 
 
1812
        _ex);SIDL_CHECK(*_ex);
 
1813
      sidl_rmi_Invocation_packString( _inv, "iobj", _url, _ex);SIDL_CHECK(*_ex);
 
1814
      free((void*)_url);
 
1815
    } else {
 
1816
      sidl_rmi_Invocation_packString( _inv, "iobj", NULL, _ex);SIDL_CHECK(*_ex);
 
1817
    }
 
1818
 
 
1819
    /* send actual RMI request */
 
1820
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1821
 
 
1822
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1823
    if(_be != NULL) {
 
1824
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
1825
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.isSame.", &throwaway_exception);
 
1826
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
1827
        &throwaway_exception);
 
1828
      goto EXIT;
 
1829
    }
 
1830
 
 
1831
    /* extract return value */
 
1832
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1833
      *_ex);
 
1834
 
 
1835
    /* unpack out and inout arguments */
 
1836
 
 
1837
    /* cleanup and return */
 
1838
    EXIT:
 
1839
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1840
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1841
    return _retval;
 
1842
  }
 
1843
}
 
1844
 
 
1845
/* REMOTE METHOD STUB:isType */
 
1846
static sidl_bool
 
1847
remote_sidlx_rmi_OutOfAddressesException_isType(
 
1848
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
1849
  /* in */ const char* name,
 
1850
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
1851
{
 
1852
  LANG_SPECIFIC_INIT();
 
1853
  *_ex = NULL;
 
1854
  {
 
1855
    /* initialize a new invocation */
 
1856
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
1857
    sidl_BaseException _be = NULL;
 
1858
    sidl_rmi_Response _rsvp = NULL;
 
1859
    sidl_bool _retval = FALSE;
 
1860
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1861
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
1862
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
1863
      "isType", _ex ); SIDL_CHECK(*_ex);
 
1864
 
 
1865
    /* pack in and inout arguments */
 
1866
    sidl_rmi_Invocation_packString( _inv, "name", name, _ex);SIDL_CHECK(*_ex);
 
1867
 
 
1868
    /* send actual RMI request */
 
1869
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1870
 
 
1871
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1872
    if(_be != NULL) {
 
1873
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
1874
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.isType.", &throwaway_exception);
 
1875
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
1876
        &throwaway_exception);
 
1877
      goto EXIT;
 
1878
    }
 
1879
 
 
1880
    /* extract return value */
 
1881
    sidl_rmi_Response_unpackBool( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1882
      *_ex);
 
1883
 
 
1884
    /* unpack out and inout arguments */
 
1885
 
 
1886
    /* cleanup and return */
 
1887
    EXIT:
 
1888
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1889
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1890
    return _retval;
 
1891
  }
 
1892
}
 
1893
 
 
1894
/* REMOTE METHOD STUB:getClassInfo */
 
1895
static struct sidl_ClassInfo__object*
 
1896
remote_sidlx_rmi_OutOfAddressesException_getClassInfo(
 
1897
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
1898
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
1899
{
 
1900
  LANG_SPECIFIC_INIT();
 
1901
  *_ex = NULL;
 
1902
  {
 
1903
    /* initialize a new invocation */
 
1904
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
1905
    sidl_BaseException _be = NULL;
 
1906
    sidl_rmi_Response _rsvp = NULL;
 
1907
    char*_retval_str = NULL;
 
1908
    struct sidl_ClassInfo__object* _retval = 0;
 
1909
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1910
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
1911
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
1912
      "getClassInfo", _ex ); SIDL_CHECK(*_ex);
 
1913
 
 
1914
    /* pack in and inout arguments */
 
1915
 
 
1916
    /* send actual RMI request */
 
1917
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1918
 
 
1919
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1920
    if(_be != NULL) {
 
1921
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
1922
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.getClassInfo.", &throwaway_exception);
 
1923
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
1924
        &throwaway_exception);
 
1925
      goto EXIT;
 
1926
    }
 
1927
 
 
1928
    /* extract return value */
 
1929
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval_str, 
 
1930
      _ex);SIDL_CHECK(*_ex);
 
1931
    _retval = sidl_ClassInfo__connectI(_retval_str, FALSE, _ex);SIDL_CHECK(
 
1932
      *_ex);
 
1933
 
 
1934
    /* unpack out and inout arguments */
 
1935
 
 
1936
    /* cleanup and return */
 
1937
    EXIT:
 
1938
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1939
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1940
    return _retval;
 
1941
  }
 
1942
}
 
1943
 
 
1944
/* REMOTE METHOD STUB:getNote */
 
1945
static char*
 
1946
remote_sidlx_rmi_OutOfAddressesException_getNote(
 
1947
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
1948
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
1949
{
 
1950
  LANG_SPECIFIC_INIT();
 
1951
  *_ex = NULL;
 
1952
  {
 
1953
    /* initialize a new invocation */
 
1954
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
1955
    sidl_BaseException _be = NULL;
 
1956
    sidl_rmi_Response _rsvp = NULL;
 
1957
    char* _retval = 0;
 
1958
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
1959
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
1960
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
1961
      "getNote", _ex ); SIDL_CHECK(*_ex);
 
1962
 
 
1963
    /* pack in and inout arguments */
 
1964
 
 
1965
    /* send actual RMI request */
 
1966
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
1967
 
 
1968
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
1969
    if(_be != NULL) {
 
1970
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
1971
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.getNote.", &throwaway_exception);
 
1972
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
1973
        &throwaway_exception);
 
1974
      goto EXIT;
 
1975
    }
 
1976
 
 
1977
    /* extract return value */
 
1978
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
1979
      *_ex);
 
1980
 
 
1981
    /* unpack out and inout arguments */
 
1982
 
 
1983
    /* cleanup and return */
 
1984
    EXIT:
 
1985
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
1986
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
1987
    return _retval;
 
1988
  }
 
1989
}
 
1990
 
 
1991
/* REMOTE METHOD STUB:setNote */
 
1992
static void
 
1993
remote_sidlx_rmi_OutOfAddressesException_setNote(
 
1994
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
1995
  /* in */ const char* message,
 
1996
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
1997
{
 
1998
  LANG_SPECIFIC_INIT();
 
1999
  *_ex = NULL;
 
2000
  {
 
2001
    /* initialize a new invocation */
 
2002
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
2003
    sidl_BaseException _be = NULL;
 
2004
    sidl_rmi_Response _rsvp = NULL;
 
2005
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
2006
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
2007
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
2008
      "setNote", _ex ); SIDL_CHECK(*_ex);
 
2009
 
 
2010
    /* pack in and inout arguments */
 
2011
    sidl_rmi_Invocation_packString( _inv, "message", message, _ex);SIDL_CHECK(
 
2012
      *_ex);
 
2013
 
 
2014
    /* send actual RMI request */
 
2015
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
2016
 
 
2017
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
2018
    if(_be != NULL) {
 
2019
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
2020
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.setNote.", &throwaway_exception);
 
2021
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
2022
        &throwaway_exception);
 
2023
      goto EXIT;
 
2024
    }
 
2025
 
 
2026
    /* unpack out and inout arguments */
 
2027
 
 
2028
    /* cleanup and return */
 
2029
    EXIT:
 
2030
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
2031
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
2032
    return;
 
2033
  }
 
2034
}
 
2035
 
 
2036
/* REMOTE METHOD STUB:getTrace */
 
2037
static char*
 
2038
remote_sidlx_rmi_OutOfAddressesException_getTrace(
 
2039
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
2040
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
2041
{
 
2042
  LANG_SPECIFIC_INIT();
 
2043
  *_ex = NULL;
 
2044
  {
 
2045
    /* initialize a new invocation */
 
2046
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
2047
    sidl_BaseException _be = NULL;
 
2048
    sidl_rmi_Response _rsvp = NULL;
 
2049
    char* _retval = 0;
 
2050
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
2051
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
2052
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
2053
      "getTrace", _ex ); SIDL_CHECK(*_ex);
 
2054
 
 
2055
    /* pack in and inout arguments */
 
2056
 
 
2057
    /* send actual RMI request */
 
2058
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
2059
 
 
2060
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
2061
    if(_be != NULL) {
 
2062
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
2063
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.getTrace.", &throwaway_exception);
 
2064
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
2065
        &throwaway_exception);
 
2066
      goto EXIT;
 
2067
    }
 
2068
 
 
2069
    /* extract return value */
 
2070
    sidl_rmi_Response_unpackString( _rsvp, "_retval", &_retval, _ex);SIDL_CHECK(
 
2071
      *_ex);
 
2072
 
 
2073
    /* unpack out and inout arguments */
 
2074
 
 
2075
    /* cleanup and return */
 
2076
    EXIT:
 
2077
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
2078
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
2079
    return _retval;
 
2080
  }
 
2081
}
 
2082
 
 
2083
/* REMOTE METHOD STUB:addLine */
 
2084
static void
 
2085
remote_sidlx_rmi_OutOfAddressesException_addLine(
 
2086
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
2087
  /* in */ const char* traceline,
 
2088
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
2089
{
 
2090
  LANG_SPECIFIC_INIT();
 
2091
  *_ex = NULL;
 
2092
  {
 
2093
    /* initialize a new invocation */
 
2094
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
2095
    sidl_BaseException _be = NULL;
 
2096
    sidl_rmi_Response _rsvp = NULL;
 
2097
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
2098
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
2099
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
2100
      "addLine", _ex ); SIDL_CHECK(*_ex);
 
2101
 
 
2102
    /* pack in and inout arguments */
 
2103
    sidl_rmi_Invocation_packString( _inv, "traceline", traceline, 
 
2104
      _ex);SIDL_CHECK(*_ex);
 
2105
 
 
2106
    /* send actual RMI request */
 
2107
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
2108
 
 
2109
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
2110
    if(_be != NULL) {
 
2111
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
2112
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.addLine.", &throwaway_exception);
 
2113
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
2114
        &throwaway_exception);
 
2115
      goto EXIT;
 
2116
    }
 
2117
 
 
2118
    /* unpack out and inout arguments */
 
2119
 
 
2120
    /* cleanup and return */
 
2121
    EXIT:
 
2122
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
2123
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
2124
    return;
 
2125
  }
 
2126
}
 
2127
 
 
2128
/* REMOTE METHOD STUB:add */
 
2129
static void
 
2130
remote_sidlx_rmi_OutOfAddressesException_add(
 
2131
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
2132
  /* in */ const char* filename,
 
2133
  /* in */ int32_t lineno,
 
2134
  /* in */ const char* methodname,
 
2135
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
2136
{
 
2137
  LANG_SPECIFIC_INIT();
 
2138
  *_ex = NULL;
 
2139
  {
 
2140
    /* initialize a new invocation */
 
2141
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
2142
    sidl_BaseException _be = NULL;
 
2143
    sidl_rmi_Response _rsvp = NULL;
 
2144
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
2145
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
2146
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
2147
      "add", _ex ); SIDL_CHECK(*_ex);
 
2148
 
 
2149
    /* pack in and inout arguments */
 
2150
    sidl_rmi_Invocation_packString( _inv, "filename", filename, _ex);SIDL_CHECK(
 
2151
      *_ex);
 
2152
    sidl_rmi_Invocation_packInt( _inv, "lineno", lineno, _ex);SIDL_CHECK(*_ex);
 
2153
    sidl_rmi_Invocation_packString( _inv, "methodname", methodname, 
 
2154
      _ex);SIDL_CHECK(*_ex);
 
2155
 
 
2156
    /* send actual RMI request */
 
2157
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
2158
 
 
2159
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
2160
    if(_be != NULL) {
 
2161
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
2162
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.add.", &throwaway_exception);
 
2163
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
2164
        &throwaway_exception);
 
2165
      goto EXIT;
 
2166
    }
 
2167
 
 
2168
    /* unpack out and inout arguments */
 
2169
 
 
2170
    /* cleanup and return */
 
2171
    EXIT:
 
2172
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
2173
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
2174
    return;
 
2175
  }
 
2176
}
 
2177
 
 
2178
/* REMOTE METHOD STUB:packObj */
 
2179
static void
 
2180
remote_sidlx_rmi_OutOfAddressesException_packObj(
 
2181
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
2182
  /* in */ struct sidl_io_Serializer__object* ser,
 
2183
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
2184
{
 
2185
  LANG_SPECIFIC_INIT();
 
2186
  *_ex = NULL;
 
2187
  {
 
2188
    /* initialize a new invocation */
 
2189
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
2190
    sidl_BaseException _be = NULL;
 
2191
    sidl_rmi_Response _rsvp = NULL;
 
2192
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
2193
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
2194
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
2195
      "packObj", _ex ); SIDL_CHECK(*_ex);
 
2196
 
 
2197
    /* pack in and inout arguments */
 
2198
    if(ser){
 
2199
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)ser, 
 
2200
        _ex);SIDL_CHECK(*_ex);
 
2201
      sidl_rmi_Invocation_packString( _inv, "ser", _url, _ex);SIDL_CHECK(*_ex);
 
2202
      free((void*)_url);
 
2203
    } else {
 
2204
      sidl_rmi_Invocation_packString( _inv, "ser", NULL, _ex);SIDL_CHECK(*_ex);
 
2205
    }
 
2206
 
 
2207
    /* send actual RMI request */
 
2208
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
2209
 
 
2210
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
2211
    if(_be != NULL) {
 
2212
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
2213
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.packObj.", &throwaway_exception);
 
2214
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
2215
        &throwaway_exception);
 
2216
      goto EXIT;
 
2217
    }
 
2218
 
 
2219
    /* unpack out and inout arguments */
 
2220
 
 
2221
    /* cleanup and return */
 
2222
    EXIT:
 
2223
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
2224
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
2225
    return;
 
2226
  }
 
2227
}
 
2228
 
 
2229
/* REMOTE METHOD STUB:unpackObj */
 
2230
static void
 
2231
remote_sidlx_rmi_OutOfAddressesException_unpackObj(
 
2232
  /* in */ struct sidlx_rmi_OutOfAddressesException__object *self ,
 
2233
  /* in */ struct sidl_io_Deserializer__object* des,
 
2234
  /* out */ struct sidl_BaseInterface__object * *_ex)
 
2235
{
 
2236
  LANG_SPECIFIC_INIT();
 
2237
  *_ex = NULL;
 
2238
  {
 
2239
    /* initialize a new invocation */
 
2240
    struct sidl_BaseInterface__object* _throwaway = NULL;
 
2241
    sidl_BaseException _be = NULL;
 
2242
    sidl_rmi_Response _rsvp = NULL;
 
2243
    struct sidl_rmi_InstanceHandle__object * _conn = ((struct 
 
2244
      sidlx_rmi_OutOfAddressesException__remote*)self->d_data)->d_ih;
 
2245
    sidl_rmi_Invocation _inv = sidl_rmi_InstanceHandle_createInvocation( _conn, 
 
2246
      "unpackObj", _ex ); SIDL_CHECK(*_ex);
 
2247
 
 
2248
    /* pack in and inout arguments */
 
2249
    if(des){
 
2250
      char* _url = sidl_BaseInterface__getURL((sidl_BaseInterface)des, 
 
2251
        _ex);SIDL_CHECK(*_ex);
 
2252
      sidl_rmi_Invocation_packString( _inv, "des", _url, _ex);SIDL_CHECK(*_ex);
 
2253
      free((void*)_url);
 
2254
    } else {
 
2255
      sidl_rmi_Invocation_packString( _inv, "des", NULL, _ex);SIDL_CHECK(*_ex);
 
2256
    }
 
2257
 
 
2258
    /* send actual RMI request */
 
2259
    _rsvp = sidl_rmi_Invocation_invokeMethod(_inv, _ex);SIDL_CHECK(*_ex);
 
2260
 
 
2261
    _be = sidl_rmi_Response_getExceptionThrown(_rsvp, _ex);SIDL_CHECK(*_ex);
 
2262
    if(_be != NULL) {
 
2263
      struct sidl_BaseInterface__object* throwaway_exception = NULL;
 
2264
sidl_BaseException_addLine(_be, "Exception unserialized from sidlx.rmi.OutOfAddressesException.unpackObj.", &throwaway_exception);
 
2265
      *_ex = (struct sidl_BaseInterface__object*) sidl_BaseInterface__cast(_be,
 
2266
        &throwaway_exception);
 
2267
      goto EXIT;
 
2268
    }
 
2269
 
 
2270
    /* unpack out and inout arguments */
 
2271
 
 
2272
    /* cleanup and return */
 
2273
    EXIT:
 
2274
    if(_inv) { sidl_rmi_Invocation_deleteRef(_inv, &_throwaway); }
 
2275
    if(_rsvp) { sidl_rmi_Response_deleteRef(_rsvp, &_throwaway); }
 
2276
    return;
 
2277
  }
 
2278
}
 
2279
 
 
2280
/* REMOTE EPV: create remote entry point vectors (EPVs). */
 
2281
static void sidlx_rmi_OutOfAddressesException__init_remote_epv(void)
 
2282
{
 
2283
  /* assert( HAVE_LOCKED_STATIC_GLOBALS ); */
 
2284
  struct sidlx_rmi_OutOfAddressesException__epv* epv = 
 
2285
    &s_rem_epv__sidlx_rmi_outofaddressesexception;
 
2286
  struct sidl_BaseClass__epv*                    e0  = 
 
2287
    &s_rem_epv__sidl_baseclass;
 
2288
  struct sidl_BaseException__epv*                e1  = 
 
2289
    &s_rem_epv__sidl_baseexception;
 
2290
  struct sidl_BaseInterface__epv*                e2  = 
 
2291
    &s_rem_epv__sidl_baseinterface;
 
2292
  struct sidl_RuntimeException__epv*             e3  = 
 
2293
    &s_rem_epv__sidl_runtimeexception;
 
2294
  struct sidl_SIDLException__epv*                e4  = 
 
2295
    &s_rem_epv__sidl_sidlexception;
 
2296
  struct sidl_io_IOException__epv*               e5  = 
 
2297
    &s_rem_epv__sidl_io_ioexception;
 
2298
  struct sidl_io_Serializable__epv*              e6  = 
 
2299
    &s_rem_epv__sidl_io_serializable;
 
2300
  struct sidl_rmi_NetworkException__epv*         e7  = 
 
2301
    &s_rem_epv__sidl_rmi_networkexception;
 
2302
  struct sidl_rmi_ProtocolException__epv*        e8  = 
 
2303
    &s_rem_epv__sidl_rmi_protocolexception;
 
2304
  struct sidlx_rmi_RecoverableException__epv*    e9  = 
 
2305
    &s_rem_epv__sidlx_rmi_recoverableexception;
 
2306
 
 
2307
  epv->f__cast             = remote_sidlx_rmi_OutOfAddressesException__cast;
 
2308
  epv->f__delete           = remote_sidlx_rmi_OutOfAddressesException__delete;
 
2309
  epv->f__exec             = remote_sidlx_rmi_OutOfAddressesException__exec;
 
2310
  epv->f__getURL           = remote_sidlx_rmi_OutOfAddressesException__getURL;
 
2311
  epv->f__raddRef          = remote_sidlx_rmi_OutOfAddressesException__raddRef;
 
2312
  epv->f__isRemote         = remote_sidlx_rmi_OutOfAddressesException__isRemote;
 
2313
  epv->f__set_hooks        = 
 
2314
    remote_sidlx_rmi_OutOfAddressesException__set_hooks;
 
2315
  epv->f__ctor             = NULL;
 
2316
  epv->f__ctor2            = NULL;
 
2317
  epv->f__dtor             = NULL;
 
2318
  epv->f_getHopCount       = 
 
2319
    remote_sidlx_rmi_OutOfAddressesException_getHopCount;
 
2320
  epv->f_setErrno          = remote_sidlx_rmi_OutOfAddressesException_setErrno;
 
2321
  epv->f_getErrno          = remote_sidlx_rmi_OutOfAddressesException_getErrno;
 
2322
  epv->f_addRef            = remote_sidlx_rmi_OutOfAddressesException_addRef;
 
2323
  epv->f_deleteRef         = remote_sidlx_rmi_OutOfAddressesException_deleteRef;
 
2324
  epv->f_isSame            = remote_sidlx_rmi_OutOfAddressesException_isSame;
 
2325
  epv->f_isType            = remote_sidlx_rmi_OutOfAddressesException_isType;
 
2326
  epv->f_getClassInfo      = 
 
2327
    remote_sidlx_rmi_OutOfAddressesException_getClassInfo;
 
2328
  epv->f_getNote           = remote_sidlx_rmi_OutOfAddressesException_getNote;
 
2329
  epv->f_setNote           = remote_sidlx_rmi_OutOfAddressesException_setNote;
 
2330
  epv->f_getTrace          = remote_sidlx_rmi_OutOfAddressesException_getTrace;
 
2331
  epv->f_addLine           = remote_sidlx_rmi_OutOfAddressesException_addLine;
 
2332
  epv->f_add               = remote_sidlx_rmi_OutOfAddressesException_add;
 
2333
  epv->f_packObj           = remote_sidlx_rmi_OutOfAddressesException_packObj;
 
2334
  epv->f_unpackObj         = remote_sidlx_rmi_OutOfAddressesException_unpackObj;
 
2335
 
 
2336
  e0->f__cast        = (void* (*)(struct sidl_BaseClass__object*,const char*, 
 
2337
    struct sidl_BaseInterface__object**)) epv->f__cast;
 
2338
  e0->f__delete      = (void (*)(struct sidl_BaseClass__object*,struct 
 
2339
    sidl_BaseInterface__object**)) epv->f__delete;
 
2340
  e0->f__getURL      = (char* (*)(struct sidl_BaseClass__object*,struct 
 
2341
    sidl_BaseInterface__object**)) epv->f__getURL;
 
2342
  e0->f__raddRef     = (void (*)(struct sidl_BaseClass__object*,struct 
 
2343
    sidl_BaseInterface__object**)) epv->f__raddRef;
 
2344
  e0->f__isRemote    = (sidl_bool (*)(struct sidl_BaseClass__object*,struct 
 
2345
    sidl_BaseInterface__object**)) epv->f__isRemote;
 
2346
  e0->f__set_hooks   = (void (*)(struct sidl_BaseClass__object*,int32_t, struct 
 
2347
    sidl_BaseInterface__object**)) epv->f__set_hooks;
 
2348
  e0->f__exec        = (void (*)(struct sidl_BaseClass__object*,const char*,
 
2349
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2350
    sidl_BaseInterface__object **)) epv->f__exec;
 
2351
  e0->f_addRef       = (void (*)(struct sidl_BaseClass__object*,struct 
 
2352
    sidl_BaseInterface__object **)) epv->f_addRef;
 
2353
  e0->f_deleteRef    = (void (*)(struct sidl_BaseClass__object*,struct 
 
2354
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2355
  e0->f_isSame       = (sidl_bool (*)(struct sidl_BaseClass__object*,struct 
 
2356
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2357
    epv->f_isSame;
 
2358
  e0->f_isType       = (sidl_bool (*)(struct sidl_BaseClass__object*,const 
 
2359
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
2360
  e0->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
 
2361
    sidl_BaseClass__object*,struct sidl_BaseInterface__object **)) 
 
2362
    epv->f_getClassInfo;
 
2363
 
 
2364
  e1->f__cast        = (void* (*)(void*,const char*, struct 
 
2365
    sidl_BaseInterface__object**)) epv->f__cast;
 
2366
  e1->f__delete      = (void (*)(void*,struct sidl_BaseInterface__object**)) 
 
2367
    epv->f__delete;
 
2368
  e1->f__getURL      = (char* (*)(void*,struct sidl_BaseInterface__object**)) 
 
2369
    epv->f__getURL;
 
2370
  e1->f__raddRef     = (void (*)(void*,struct sidl_BaseInterface__object**)) 
 
2371
    epv->f__raddRef;
 
2372
  e1->f__isRemote    = (sidl_bool (*)(void*,struct 
 
2373
    sidl_BaseInterface__object**)) epv->f__isRemote;
 
2374
  e1->f__set_hooks   = (void (*)(void*,int32_t, struct 
 
2375
    sidl_BaseInterface__object**)) epv->f__set_hooks;
 
2376
  e1->f__exec        = (void (*)(void*,const char*,struct 
 
2377
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2378
    sidl_BaseInterface__object **)) epv->f__exec;
 
2379
  e1->f_getNote      = (char* (*)(void*,struct sidl_BaseInterface__object **)) 
 
2380
    epv->f_getNote;
 
2381
  e1->f_setNote      = (void (*)(void*,const char*,struct 
 
2382
    sidl_BaseInterface__object **)) epv->f_setNote;
 
2383
  e1->f_getTrace     = (char* (*)(void*,struct sidl_BaseInterface__object **)) 
 
2384
    epv->f_getTrace;
 
2385
  e1->f_addLine      = (void (*)(void*,const char*,struct 
 
2386
    sidl_BaseInterface__object **)) epv->f_addLine;
 
2387
  e1->f_add          = (void (*)(void*,const char*,int32_t,const char*,struct 
 
2388
    sidl_BaseInterface__object **)) epv->f_add;
 
2389
  e1->f_packObj      = (void (*)(void*,struct sidl_io_Serializer__object*,
 
2390
    struct sidl_BaseInterface__object **)) epv->f_packObj;
 
2391
  e1->f_unpackObj    = (void (*)(void*,struct sidl_io_Deserializer__object*,
 
2392
    struct sidl_BaseInterface__object **)) epv->f_unpackObj;
 
2393
  e1->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2394
    epv->f_addRef;
 
2395
  e1->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2396
    epv->f_deleteRef;
 
2397
  e1->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
 
2398
    struct sidl_BaseInterface__object **)) epv->f_isSame;
 
2399
  e1->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
2400
    sidl_BaseInterface__object **)) epv->f_isType;
 
2401
  e1->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2402
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2403
 
 
2404
  e2->f__cast        = (void* (*)(void*,const char*, struct 
 
2405
    sidl_BaseInterface__object**)) epv->f__cast;
 
2406
  e2->f__delete      = (void (*)(void*,struct sidl_BaseInterface__object**)) 
 
2407
    epv->f__delete;
 
2408
  e2->f__getURL      = (char* (*)(void*,struct sidl_BaseInterface__object**)) 
 
2409
    epv->f__getURL;
 
2410
  e2->f__raddRef     = (void (*)(void*,struct sidl_BaseInterface__object**)) 
 
2411
    epv->f__raddRef;
 
2412
  e2->f__isRemote    = (sidl_bool (*)(void*,struct 
 
2413
    sidl_BaseInterface__object**)) epv->f__isRemote;
 
2414
  e2->f__set_hooks   = (void (*)(void*,int32_t, struct 
 
2415
    sidl_BaseInterface__object**)) epv->f__set_hooks;
 
2416
  e2->f__exec        = (void (*)(void*,const char*,struct 
 
2417
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2418
    sidl_BaseInterface__object **)) epv->f__exec;
 
2419
  e2->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2420
    epv->f_addRef;
 
2421
  e2->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2422
    epv->f_deleteRef;
 
2423
  e2->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
 
2424
    struct sidl_BaseInterface__object **)) epv->f_isSame;
 
2425
  e2->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
2426
    sidl_BaseInterface__object **)) epv->f_isType;
 
2427
  e2->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2428
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2429
 
 
2430
  e3->f__cast        = (void* (*)(void*,const char*, struct 
 
2431
    sidl_BaseInterface__object**)) epv->f__cast;
 
2432
  e3->f__delete      = (void (*)(void*,struct sidl_BaseInterface__object**)) 
 
2433
    epv->f__delete;
 
2434
  e3->f__getURL      = (char* (*)(void*,struct sidl_BaseInterface__object**)) 
 
2435
    epv->f__getURL;
 
2436
  e3->f__raddRef     = (void (*)(void*,struct sidl_BaseInterface__object**)) 
 
2437
    epv->f__raddRef;
 
2438
  e3->f__isRemote    = (sidl_bool (*)(void*,struct 
 
2439
    sidl_BaseInterface__object**)) epv->f__isRemote;
 
2440
  e3->f__set_hooks   = (void (*)(void*,int32_t, struct 
 
2441
    sidl_BaseInterface__object**)) epv->f__set_hooks;
 
2442
  e3->f__exec        = (void (*)(void*,const char*,struct 
 
2443
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2444
    sidl_BaseInterface__object **)) epv->f__exec;
 
2445
  e3->f_getNote      = (char* (*)(void*,struct sidl_BaseInterface__object **)) 
 
2446
    epv->f_getNote;
 
2447
  e3->f_setNote      = (void (*)(void*,const char*,struct 
 
2448
    sidl_BaseInterface__object **)) epv->f_setNote;
 
2449
  e3->f_getTrace     = (char* (*)(void*,struct sidl_BaseInterface__object **)) 
 
2450
    epv->f_getTrace;
 
2451
  e3->f_addLine      = (void (*)(void*,const char*,struct 
 
2452
    sidl_BaseInterface__object **)) epv->f_addLine;
 
2453
  e3->f_add          = (void (*)(void*,const char*,int32_t,const char*,struct 
 
2454
    sidl_BaseInterface__object **)) epv->f_add;
 
2455
  e3->f_packObj      = (void (*)(void*,struct sidl_io_Serializer__object*,
 
2456
    struct sidl_BaseInterface__object **)) epv->f_packObj;
 
2457
  e3->f_unpackObj    = (void (*)(void*,struct sidl_io_Deserializer__object*,
 
2458
    struct sidl_BaseInterface__object **)) epv->f_unpackObj;
 
2459
  e3->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2460
    epv->f_addRef;
 
2461
  e3->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2462
    epv->f_deleteRef;
 
2463
  e3->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
 
2464
    struct sidl_BaseInterface__object **)) epv->f_isSame;
 
2465
  e3->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
2466
    sidl_BaseInterface__object **)) epv->f_isType;
 
2467
  e3->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2468
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2469
 
 
2470
  e4->f__cast        = (void* (*)(struct sidl_SIDLException__object*,const 
 
2471
    char*, struct sidl_BaseInterface__object**)) epv->f__cast;
 
2472
  e4->f__delete      = (void (*)(struct sidl_SIDLException__object*,struct 
 
2473
    sidl_BaseInterface__object**)) epv->f__delete;
 
2474
  e4->f__getURL      = (char* (*)(struct sidl_SIDLException__object*,struct 
 
2475
    sidl_BaseInterface__object**)) epv->f__getURL;
 
2476
  e4->f__raddRef     = (void (*)(struct sidl_SIDLException__object*,struct 
 
2477
    sidl_BaseInterface__object**)) epv->f__raddRef;
 
2478
  e4->f__isRemote    = (sidl_bool (*)(struct sidl_SIDLException__object*,struct 
 
2479
    sidl_BaseInterface__object**)) epv->f__isRemote;
 
2480
  e4->f__set_hooks   = (void (*)(struct sidl_SIDLException__object*,int32_t, 
 
2481
    struct sidl_BaseInterface__object**)) epv->f__set_hooks;
 
2482
  e4->f__exec        = (void (*)(struct sidl_SIDLException__object*,const char*,
 
2483
    struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2484
    sidl_BaseInterface__object **)) epv->f__exec;
 
2485
  e4->f_addRef       = (void (*)(struct sidl_SIDLException__object*,struct 
 
2486
    sidl_BaseInterface__object **)) epv->f_addRef;
 
2487
  e4->f_deleteRef    = (void (*)(struct sidl_SIDLException__object*,struct 
 
2488
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2489
  e4->f_isSame       = (sidl_bool (*)(struct sidl_SIDLException__object*,struct 
 
2490
    sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2491
    epv->f_isSame;
 
2492
  e4->f_isType       = (sidl_bool (*)(struct sidl_SIDLException__object*,const 
 
2493
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
2494
  e4->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
 
2495
    sidl_SIDLException__object*,struct sidl_BaseInterface__object **)) 
 
2496
    epv->f_getClassInfo;
 
2497
  e4->f_getNote      = (char* (*)(struct sidl_SIDLException__object*,struct 
 
2498
    sidl_BaseInterface__object **)) epv->f_getNote;
 
2499
  e4->f_setNote      = (void (*)(struct sidl_SIDLException__object*,const char*,
 
2500
    struct sidl_BaseInterface__object **)) epv->f_setNote;
 
2501
  e4->f_getTrace     = (char* (*)(struct sidl_SIDLException__object*,struct 
 
2502
    sidl_BaseInterface__object **)) epv->f_getTrace;
 
2503
  e4->f_addLine      = (void (*)(struct sidl_SIDLException__object*,const char*,
 
2504
    struct sidl_BaseInterface__object **)) epv->f_addLine;
 
2505
  e4->f_add          = (void (*)(struct sidl_SIDLException__object*,const char*,
 
2506
    int32_t,const char*,struct sidl_BaseInterface__object **)) epv->f_add;
 
2507
  e4->f_packObj      = (void (*)(struct sidl_SIDLException__object*,struct 
 
2508
    sidl_io_Serializer__object*,struct sidl_BaseInterface__object **)) 
 
2509
    epv->f_packObj;
 
2510
  e4->f_unpackObj    = (void (*)(struct sidl_SIDLException__object*,struct 
 
2511
    sidl_io_Deserializer__object*,struct sidl_BaseInterface__object **)) 
 
2512
    epv->f_unpackObj;
 
2513
 
 
2514
  e5->f__cast        = (void* (*)(struct sidl_io_IOException__object*,const 
 
2515
    char*, struct sidl_BaseInterface__object**)) epv->f__cast;
 
2516
  e5->f__delete      = (void (*)(struct sidl_io_IOException__object*,struct 
 
2517
    sidl_BaseInterface__object**)) epv->f__delete;
 
2518
  e5->f__getURL      = (char* (*)(struct sidl_io_IOException__object*,struct 
 
2519
    sidl_BaseInterface__object**)) epv->f__getURL;
 
2520
  e5->f__raddRef     = (void (*)(struct sidl_io_IOException__object*,struct 
 
2521
    sidl_BaseInterface__object**)) epv->f__raddRef;
 
2522
  e5->f__isRemote    = (sidl_bool (*)(struct sidl_io_IOException__object*,
 
2523
    struct sidl_BaseInterface__object**)) epv->f__isRemote;
 
2524
  e5->f__set_hooks   = (void (*)(struct sidl_io_IOException__object*,int32_t, 
 
2525
    struct sidl_BaseInterface__object**)) epv->f__set_hooks;
 
2526
  e5->f__exec        = (void (*)(struct sidl_io_IOException__object*,const 
 
2527
    char*,struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2528
    sidl_BaseInterface__object **)) epv->f__exec;
 
2529
  e5->f_addRef       = (void (*)(struct sidl_io_IOException__object*,struct 
 
2530
    sidl_BaseInterface__object **)) epv->f_addRef;
 
2531
  e5->f_deleteRef    = (void (*)(struct sidl_io_IOException__object*,struct 
 
2532
    sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2533
  e5->f_isSame       = (sidl_bool (*)(struct sidl_io_IOException__object*,
 
2534
    struct sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2535
    epv->f_isSame;
 
2536
  e5->f_isType       = (sidl_bool (*)(struct sidl_io_IOException__object*,const 
 
2537
    char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
2538
  e5->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
 
2539
    sidl_io_IOException__object*,struct sidl_BaseInterface__object **)) 
 
2540
    epv->f_getClassInfo;
 
2541
  e5->f_getNote      = (char* (*)(struct sidl_io_IOException__object*,struct 
 
2542
    sidl_BaseInterface__object **)) epv->f_getNote;
 
2543
  e5->f_setNote      = (void (*)(struct sidl_io_IOException__object*,const 
 
2544
    char*,struct sidl_BaseInterface__object **)) epv->f_setNote;
 
2545
  e5->f_getTrace     = (char* (*)(struct sidl_io_IOException__object*,struct 
 
2546
    sidl_BaseInterface__object **)) epv->f_getTrace;
 
2547
  e5->f_addLine      = (void (*)(struct sidl_io_IOException__object*,const 
 
2548
    char*,struct sidl_BaseInterface__object **)) epv->f_addLine;
 
2549
  e5->f_add          = (void (*)(struct sidl_io_IOException__object*,const 
 
2550
    char*,int32_t,const char*,struct sidl_BaseInterface__object **)) epv->f_add;
 
2551
  e5->f_packObj      = (void (*)(struct sidl_io_IOException__object*,struct 
 
2552
    sidl_io_Serializer__object*,struct sidl_BaseInterface__object **)) 
 
2553
    epv->f_packObj;
 
2554
  e5->f_unpackObj    = (void (*)(struct sidl_io_IOException__object*,struct 
 
2555
    sidl_io_Deserializer__object*,struct sidl_BaseInterface__object **)) 
 
2556
    epv->f_unpackObj;
 
2557
 
 
2558
  e6->f__cast        = (void* (*)(void*,const char*, struct 
 
2559
    sidl_BaseInterface__object**)) epv->f__cast;
 
2560
  e6->f__delete      = (void (*)(void*,struct sidl_BaseInterface__object**)) 
 
2561
    epv->f__delete;
 
2562
  e6->f__getURL      = (char* (*)(void*,struct sidl_BaseInterface__object**)) 
 
2563
    epv->f__getURL;
 
2564
  e6->f__raddRef     = (void (*)(void*,struct sidl_BaseInterface__object**)) 
 
2565
    epv->f__raddRef;
 
2566
  e6->f__isRemote    = (sidl_bool (*)(void*,struct 
 
2567
    sidl_BaseInterface__object**)) epv->f__isRemote;
 
2568
  e6->f__set_hooks   = (void (*)(void*,int32_t, struct 
 
2569
    sidl_BaseInterface__object**)) epv->f__set_hooks;
 
2570
  e6->f__exec        = (void (*)(void*,const char*,struct 
 
2571
    sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,struct 
 
2572
    sidl_BaseInterface__object **)) epv->f__exec;
 
2573
  e6->f_packObj      = (void (*)(void*,struct sidl_io_Serializer__object*,
 
2574
    struct sidl_BaseInterface__object **)) epv->f_packObj;
 
2575
  e6->f_unpackObj    = (void (*)(void*,struct sidl_io_Deserializer__object*,
 
2576
    struct sidl_BaseInterface__object **)) epv->f_unpackObj;
 
2577
  e6->f_addRef       = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2578
    epv->f_addRef;
 
2579
  e6->f_deleteRef    = (void (*)(void*,struct sidl_BaseInterface__object **)) 
 
2580
    epv->f_deleteRef;
 
2581
  e6->f_isSame       = (sidl_bool (*)(void*,struct sidl_BaseInterface__object*,
 
2582
    struct sidl_BaseInterface__object **)) epv->f_isSame;
 
2583
  e6->f_isType       = (sidl_bool (*)(void*,const char*,struct 
 
2584
    sidl_BaseInterface__object **)) epv->f_isType;
 
2585
  e6->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(void*,struct 
 
2586
    sidl_BaseInterface__object **)) epv->f_getClassInfo;
 
2587
 
 
2588
  e7->f__cast        = (void* (*)(struct sidl_rmi_NetworkException__object*,
 
2589
    const char*, struct sidl_BaseInterface__object**)) epv->f__cast;
 
2590
  e7->f__delete      = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2591
    struct sidl_BaseInterface__object**)) epv->f__delete;
 
2592
  e7->f__getURL      = (char* (*)(struct sidl_rmi_NetworkException__object*,
 
2593
    struct sidl_BaseInterface__object**)) epv->f__getURL;
 
2594
  e7->f__raddRef     = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2595
    struct sidl_BaseInterface__object**)) epv->f__raddRef;
 
2596
  e7->f__isRemote    = (sidl_bool (*)(struct sidl_rmi_NetworkException__object*,
 
2597
    struct sidl_BaseInterface__object**)) epv->f__isRemote;
 
2598
  e7->f__set_hooks   = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2599
    int32_t, struct sidl_BaseInterface__object**)) epv->f__set_hooks;
 
2600
  e7->f__exec        = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2601
    const char*,struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
 
2602
    struct sidl_BaseInterface__object **)) epv->f__exec;
 
2603
  e7->f_getHopCount  = (int32_t (*)(struct sidl_rmi_NetworkException__object*,
 
2604
    struct sidl_BaseInterface__object **)) epv->f_getHopCount;
 
2605
  e7->f_setErrno     = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2606
    int32_t,struct sidl_BaseInterface__object **)) epv->f_setErrno;
 
2607
  e7->f_getErrno     = (int32_t (*)(struct sidl_rmi_NetworkException__object*,
 
2608
    struct sidl_BaseInterface__object **)) epv->f_getErrno;
 
2609
  e7->f_addRef       = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2610
    struct sidl_BaseInterface__object **)) epv->f_addRef;
 
2611
  e7->f_deleteRef    = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2612
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2613
  e7->f_isSame       = (sidl_bool (*)(struct sidl_rmi_NetworkException__object*,
 
2614
    struct sidl_BaseInterface__object*,struct sidl_BaseInterface__object **)) 
 
2615
    epv->f_isSame;
 
2616
  e7->f_isType       = (sidl_bool (*)(struct sidl_rmi_NetworkException__object*,
 
2617
    const char*,struct sidl_BaseInterface__object **)) epv->f_isType;
 
2618
  e7->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
 
2619
    sidl_rmi_NetworkException__object*,struct sidl_BaseInterface__object **)) 
 
2620
    epv->f_getClassInfo;
 
2621
  e7->f_getNote      = (char* (*)(struct sidl_rmi_NetworkException__object*,
 
2622
    struct sidl_BaseInterface__object **)) epv->f_getNote;
 
2623
  e7->f_setNote      = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2624
    const char*,struct sidl_BaseInterface__object **)) epv->f_setNote;
 
2625
  e7->f_getTrace     = (char* (*)(struct sidl_rmi_NetworkException__object*,
 
2626
    struct sidl_BaseInterface__object **)) epv->f_getTrace;
 
2627
  e7->f_addLine      = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2628
    const char*,struct sidl_BaseInterface__object **)) epv->f_addLine;
 
2629
  e7->f_add          = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2630
    const char*,int32_t,const char*,struct sidl_BaseInterface__object **)) 
 
2631
    epv->f_add;
 
2632
  e7->f_packObj      = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2633
    struct sidl_io_Serializer__object*,struct sidl_BaseInterface__object **)) 
 
2634
    epv->f_packObj;
 
2635
  e7->f_unpackObj    = (void (*)(struct sidl_rmi_NetworkException__object*,
 
2636
    struct sidl_io_Deserializer__object*,struct sidl_BaseInterface__object **)) 
 
2637
    epv->f_unpackObj;
 
2638
 
 
2639
  e8->f__cast        = (void* (*)(struct sidl_rmi_ProtocolException__object*,
 
2640
    const char*, struct sidl_BaseInterface__object**)) epv->f__cast;
 
2641
  e8->f__delete      = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2642
    struct sidl_BaseInterface__object**)) epv->f__delete;
 
2643
  e8->f__getURL      = (char* (*)(struct sidl_rmi_ProtocolException__object*,
 
2644
    struct sidl_BaseInterface__object**)) epv->f__getURL;
 
2645
  e8->f__raddRef     = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2646
    struct sidl_BaseInterface__object**)) epv->f__raddRef;
 
2647
  e8->f__isRemote    = (sidl_bool (*)(struct 
 
2648
    sidl_rmi_ProtocolException__object*,struct sidl_BaseInterface__object**)) 
 
2649
    epv->f__isRemote;
 
2650
  e8->f__set_hooks   = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2651
    int32_t, struct sidl_BaseInterface__object**)) epv->f__set_hooks;
 
2652
  e8->f__exec        = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2653
    const char*,struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
 
2654
    struct sidl_BaseInterface__object **)) epv->f__exec;
 
2655
  e8->f_getHopCount  = (int32_t (*)(struct sidl_rmi_ProtocolException__object*,
 
2656
    struct sidl_BaseInterface__object **)) epv->f_getHopCount;
 
2657
  e8->f_setErrno     = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2658
    int32_t,struct sidl_BaseInterface__object **)) epv->f_setErrno;
 
2659
  e8->f_getErrno     = (int32_t (*)(struct sidl_rmi_ProtocolException__object*,
 
2660
    struct sidl_BaseInterface__object **)) epv->f_getErrno;
 
2661
  e8->f_addRef       = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2662
    struct sidl_BaseInterface__object **)) epv->f_addRef;
 
2663
  e8->f_deleteRef    = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2664
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2665
  e8->f_isSame       = (sidl_bool (*)(struct 
 
2666
    sidl_rmi_ProtocolException__object*,struct sidl_BaseInterface__object*,
 
2667
    struct sidl_BaseInterface__object **)) epv->f_isSame;
 
2668
  e8->f_isType       = (sidl_bool (*)(struct 
 
2669
    sidl_rmi_ProtocolException__object*,const char*,struct 
 
2670
    sidl_BaseInterface__object **)) epv->f_isType;
 
2671
  e8->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
 
2672
    sidl_rmi_ProtocolException__object*,struct sidl_BaseInterface__object **)) 
 
2673
    epv->f_getClassInfo;
 
2674
  e8->f_getNote      = (char* (*)(struct sidl_rmi_ProtocolException__object*,
 
2675
    struct sidl_BaseInterface__object **)) epv->f_getNote;
 
2676
  e8->f_setNote      = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2677
    const char*,struct sidl_BaseInterface__object **)) epv->f_setNote;
 
2678
  e8->f_getTrace     = (char* (*)(struct sidl_rmi_ProtocolException__object*,
 
2679
    struct sidl_BaseInterface__object **)) epv->f_getTrace;
 
2680
  e8->f_addLine      = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2681
    const char*,struct sidl_BaseInterface__object **)) epv->f_addLine;
 
2682
  e8->f_add          = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2683
    const char*,int32_t,const char*,struct sidl_BaseInterface__object **)) 
 
2684
    epv->f_add;
 
2685
  e8->f_packObj      = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2686
    struct sidl_io_Serializer__object*,struct sidl_BaseInterface__object **)) 
 
2687
    epv->f_packObj;
 
2688
  e8->f_unpackObj    = (void (*)(struct sidl_rmi_ProtocolException__object*,
 
2689
    struct sidl_io_Deserializer__object*,struct sidl_BaseInterface__object **)) 
 
2690
    epv->f_unpackObj;
 
2691
 
 
2692
  e9->f__cast        = (void* (*)(struct 
 
2693
    sidlx_rmi_RecoverableException__object*,const char*, struct 
 
2694
    sidl_BaseInterface__object**)) epv->f__cast;
 
2695
  e9->f__delete      = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2696
    struct sidl_BaseInterface__object**)) epv->f__delete;
 
2697
  e9->f__getURL      = (char* (*)(struct 
 
2698
    sidlx_rmi_RecoverableException__object*,struct 
 
2699
    sidl_BaseInterface__object**)) epv->f__getURL;
 
2700
  e9->f__raddRef     = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2701
    struct sidl_BaseInterface__object**)) epv->f__raddRef;
 
2702
  e9->f__isRemote    = (sidl_bool (*)(struct 
 
2703
    sidlx_rmi_RecoverableException__object*,struct 
 
2704
    sidl_BaseInterface__object**)) epv->f__isRemote;
 
2705
  e9->f__set_hooks   = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2706
    int32_t, struct sidl_BaseInterface__object**)) epv->f__set_hooks;
 
2707
  e9->f__exec        = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2708
    const char*,struct sidl_rmi_Call__object*,struct sidl_rmi_Return__object*,
 
2709
    struct sidl_BaseInterface__object **)) epv->f__exec;
 
2710
  e9->f_getHopCount  = (int32_t (*)(struct 
 
2711
    sidlx_rmi_RecoverableException__object*,struct sidl_BaseInterface__object 
 
2712
    **)) epv->f_getHopCount;
 
2713
  e9->f_setErrno     = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2714
    int32_t,struct sidl_BaseInterface__object **)) epv->f_setErrno;
 
2715
  e9->f_getErrno     = (int32_t (*)(struct 
 
2716
    sidlx_rmi_RecoverableException__object*,struct sidl_BaseInterface__object 
 
2717
    **)) epv->f_getErrno;
 
2718
  e9->f_addRef       = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2719
    struct sidl_BaseInterface__object **)) epv->f_addRef;
 
2720
  e9->f_deleteRef    = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2721
    struct sidl_BaseInterface__object **)) epv->f_deleteRef;
 
2722
  e9->f_isSame       = (sidl_bool (*)(struct 
 
2723
    sidlx_rmi_RecoverableException__object*,struct sidl_BaseInterface__object*,
 
2724
    struct sidl_BaseInterface__object **)) epv->f_isSame;
 
2725
  e9->f_isType       = (sidl_bool (*)(struct 
 
2726
    sidlx_rmi_RecoverableException__object*,const char*,struct 
 
2727
    sidl_BaseInterface__object **)) epv->f_isType;
 
2728
  e9->f_getClassInfo = (struct sidl_ClassInfo__object* (*)(struct 
 
2729
    sidlx_rmi_RecoverableException__object*,struct sidl_BaseInterface__object 
 
2730
    **)) epv->f_getClassInfo;
 
2731
  e9->f_getNote      = (char* (*)(struct 
 
2732
    sidlx_rmi_RecoverableException__object*,struct sidl_BaseInterface__object 
 
2733
    **)) epv->f_getNote;
 
2734
  e9->f_setNote      = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2735
    const char*,struct sidl_BaseInterface__object **)) epv->f_setNote;
 
2736
  e9->f_getTrace     = (char* (*)(struct 
 
2737
    sidlx_rmi_RecoverableException__object*,struct sidl_BaseInterface__object 
 
2738
    **)) epv->f_getTrace;
 
2739
  e9->f_addLine      = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2740
    const char*,struct sidl_BaseInterface__object **)) epv->f_addLine;
 
2741
  e9->f_add          = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2742
    const char*,int32_t,const char*,struct sidl_BaseInterface__object **)) 
 
2743
    epv->f_add;
 
2744
  e9->f_packObj      = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2745
    struct sidl_io_Serializer__object*,struct sidl_BaseInterface__object **)) 
 
2746
    epv->f_packObj;
 
2747
  e9->f_unpackObj    = (void (*)(struct sidlx_rmi_RecoverableException__object*,
 
2748
    struct sidl_io_Deserializer__object*,struct sidl_BaseInterface__object **)) 
 
2749
    epv->f_unpackObj;
 
2750
 
 
2751
  s_remote_initialized = 1;
 
2752
}
 
2753
 
 
2754
/* Create an instance that connects to an existing remote object. */
 
2755
static struct sidlx_rmi_OutOfAddressesException__object*
 
2756
sidlx_rmi_OutOfAddressesException__remoteConnect(const char *url, sidl_bool ar, 
 
2757
  struct sidl_BaseInterface__object* *_ex)
 
2758
{
 
2759
  struct sidlx_rmi_OutOfAddressesException__object* self = NULL;
 
2760
 
 
2761
  struct sidlx_rmi_OutOfAddressesException__object* s0;
 
2762
  struct sidlx_rmi_RecoverableException__object* s1;
 
2763
  struct sidl_rmi_ProtocolException__object* s2;
 
2764
  struct sidl_rmi_NetworkException__object* s3;
 
2765
  struct sidl_io_IOException__object* s4;
 
2766
  struct sidl_SIDLException__object* s5;
 
2767
  struct sidl_BaseClass__object* s6;
 
2768
 
 
2769
  struct sidlx_rmi_OutOfAddressesException__remote* r_obj = NULL;
 
2770
  sidl_rmi_InstanceHandle instance = NULL;
 
2771
  char* objectID = NULL;
 
2772
  objectID = NULL;
 
2773
  *_ex = NULL;
 
2774
  if(url == NULL) {return NULL;}
 
2775
  objectID = sidl_rmi_ServerRegistry_isLocalObject(url, _ex);
 
2776
  if(objectID) {
 
2777
    struct sidlx_rmi_OutOfAddressesException__object* retobj = NULL;
 
2778
    struct sidl_BaseInterface__object *throwaway_exception;
 
2779
    sidl_BaseInterface bi = (
 
2780
      sidl_BaseInterface)sidl_rmi_InstanceRegistry_getInstanceByString(objectID,
 
2781
      _ex); SIDL_CHECK(*_ex);
 
2782
    (*bi->d_epv->f_deleteRef)(bi->d_object, &throwaway_exception);
 
2783
    retobj = (struct sidlx_rmi_OutOfAddressesException__object*) (
 
2784
      *bi->d_epv->f__cast)(bi->d_object, "sidlx.rmi.OutOfAddressesException", 
 
2785
      _ex);
 
2786
    if(!ar) { 
 
2787
      (*bi->d_epv->f_deleteRef)(bi->d_object, &throwaway_exception);
 
2788
    }
 
2789
    return retobj;
 
2790
  }
 
2791
  instance = sidl_rmi_ProtocolFactory_connectInstance(url, 
 
2792
    "sidlx.rmi.OutOfAddressesException", ar, _ex ); SIDL_CHECK(*_ex);
 
2793
  if ( instance == NULL) { return NULL; }
 
2794
  self =
 
2795
    (struct sidlx_rmi_OutOfAddressesException__object*) malloc(
 
2796
      sizeof(struct sidlx_rmi_OutOfAddressesException__object));
 
2797
 
 
2798
  r_obj =
 
2799
    (struct sidlx_rmi_OutOfAddressesException__remote*) malloc(
 
2800
      sizeof(struct sidlx_rmi_OutOfAddressesException__remote));
 
2801
 
 
2802
  if(!self || !r_obj) {
 
2803
    sidl_MemAllocException ex = sidl_MemAllocException_getSingletonException(
 
2804
      _ex);
 
2805
    SIDL_CHECK(*_ex);
 
2806
    sidl_MemAllocException_setNote(ex, "Out of memory.", _ex); SIDL_CHECK(*_ex);
 
2807
    sidl_MemAllocException_add(ex, __FILE__, __LINE__, 
 
2808
      "sidlx.rmi.OutOfAddressesException.EPVgeneration", _ex);
 
2809
    SIDL_CHECK(*_ex);
 
2810
    *_ex = (struct sidl_BaseInterface__object*)ex;
 
2811
    goto EXIT;
 
2812
  }
 
2813
 
 
2814
  r_obj->d_refcount = 1;
 
2815
  r_obj->d_ih = instance;
 
2816
  s0 =                                             self;
 
2817
  s1 =                                             
 
2818
    &s0->d_sidlx_rmi_recoverableexception;
 
2819
  s2 =                                             
 
2820
    &s1->d_sidl_rmi_protocolexception;
 
2821
  s3 =                                             
 
2822
    &s2->d_sidl_rmi_networkexception;
 
2823
  s4 =                                             &s3->d_sidl_io_ioexception;
 
2824
  s5 =                                             &s4->d_sidl_sidlexception;
 
2825
  s6 =                                             &s5->d_sidl_baseclass;
 
2826
 
 
2827
  LOCK_STATIC_GLOBALS;
 
2828
  if (!s_remote_initialized) {
 
2829
    sidlx_rmi_OutOfAddressesException__init_remote_epv();
 
2830
  }
 
2831
  UNLOCK_STATIC_GLOBALS;
 
2832
 
 
2833
  s6->d_sidl_baseinterface.d_epv    = &s_rem_epv__sidl_baseinterface;
 
2834
  s6->d_sidl_baseinterface.d_object = (void*) self;
 
2835
 
 
2836
  s6->d_data = (void*) r_obj;
 
2837
  s6->d_epv  = &s_rem_epv__sidl_baseclass;
 
2838
 
 
2839
  s5->d_sidl_baseexception.d_epv    = &s_rem_epv__sidl_baseexception;
 
2840
  s5->d_sidl_baseexception.d_object = (void*) self;
 
2841
 
 
2842
  s5->d_sidl_io_serializable.d_epv    = &s_rem_epv__sidl_io_serializable;
 
2843
  s5->d_sidl_io_serializable.d_object = (void*) self;
 
2844
 
 
2845
  s5->d_data = (void*) r_obj;
 
2846
  s5->d_epv  = &s_rem_epv__sidl_sidlexception;
 
2847
 
 
2848
  s4->d_sidl_runtimeexception.d_epv    = &s_rem_epv__sidl_runtimeexception;
 
2849
  s4->d_sidl_runtimeexception.d_object = (void*) self;
 
2850
 
 
2851
  s4->d_data = (void*) r_obj;
 
2852
  s4->d_epv  = &s_rem_epv__sidl_io_ioexception;
 
2853
 
 
2854
  s3->d_data = (void*) r_obj;
 
2855
  s3->d_epv  = &s_rem_epv__sidl_rmi_networkexception;
 
2856
 
 
2857
  s2->d_data = (void*) r_obj;
 
2858
  s2->d_epv  = &s_rem_epv__sidl_rmi_protocolexception;
 
2859
 
 
2860
  s1->d_data = (void*) r_obj;
 
2861
  s1->d_epv  = &s_rem_epv__sidlx_rmi_recoverableexception;
 
2862
 
 
2863
  s0->d_data = (void*) r_obj;
 
2864
  s0->d_epv  = &s_rem_epv__sidlx_rmi_outofaddressesexception;
 
2865
 
 
2866
  self->d_data = (void*) r_obj;
 
2867
 
 
2868
  return self;
 
2869
  EXIT:
 
2870
  if(self) { free(self); }
 
2871
  if(r_obj) { free(r_obj); }
 
2872
  return NULL;
 
2873
}
 
2874
/* Create an instance that uses an already existing  */
 
2875
/* InstanceHandle to connect to an existing remote object. */
 
2876
static struct sidlx_rmi_OutOfAddressesException__object*
 
2877
sidlx_rmi_OutOfAddressesException__IHConnect(sidl_rmi_InstanceHandle instance, 
 
2878
  struct sidl_BaseInterface__object* *_ex)
 
2879
{
 
2880
  struct sidlx_rmi_OutOfAddressesException__object* self = NULL;
 
2881
 
 
2882
  struct sidlx_rmi_OutOfAddressesException__object* s0;
 
2883
  struct sidlx_rmi_RecoverableException__object* s1;
 
2884
  struct sidl_rmi_ProtocolException__object* s2;
 
2885
  struct sidl_rmi_NetworkException__object* s3;
 
2886
  struct sidl_io_IOException__object* s4;
 
2887
  struct sidl_SIDLException__object* s5;
 
2888
  struct sidl_BaseClass__object* s6;
 
2889
 
 
2890
  struct sidlx_rmi_OutOfAddressesException__remote* r_obj = NULL;
 
2891
  self =
 
2892
    (struct sidlx_rmi_OutOfAddressesException__object*) malloc(
 
2893
      sizeof(struct sidlx_rmi_OutOfAddressesException__object));
 
2894
 
 
2895
  r_obj =
 
2896
    (struct sidlx_rmi_OutOfAddressesException__remote*) malloc(
 
2897
      sizeof(struct sidlx_rmi_OutOfAddressesException__remote));
 
2898
 
 
2899
  if(!self || !r_obj) {
 
2900
    sidl_MemAllocException ex = sidl_MemAllocException_getSingletonException(
 
2901
      _ex);
 
2902
    SIDL_CHECK(*_ex);
 
2903
    sidl_MemAllocException_setNote(ex, "Out of memory.", _ex); SIDL_CHECK(*_ex);
 
2904
    sidl_MemAllocException_add(ex, __FILE__, __LINE__, 
 
2905
      "sidlx.rmi.OutOfAddressesException.EPVgeneration", _ex);
 
2906
    SIDL_CHECK(*_ex);
 
2907
    *_ex = (struct sidl_BaseInterface__object*)ex;
 
2908
    goto EXIT;
 
2909
  }
 
2910
 
 
2911
  r_obj->d_refcount = 1;
 
2912
  r_obj->d_ih = instance;
 
2913
  s0 =                                             self;
 
2914
  s1 =                                             
 
2915
    &s0->d_sidlx_rmi_recoverableexception;
 
2916
  s2 =                                             
 
2917
    &s1->d_sidl_rmi_protocolexception;
 
2918
  s3 =                                             
 
2919
    &s2->d_sidl_rmi_networkexception;
 
2920
  s4 =                                             &s3->d_sidl_io_ioexception;
 
2921
  s5 =                                             &s4->d_sidl_sidlexception;
 
2922
  s6 =                                             &s5->d_sidl_baseclass;
 
2923
 
 
2924
  LOCK_STATIC_GLOBALS;
 
2925
  if (!s_remote_initialized) {
 
2926
    sidlx_rmi_OutOfAddressesException__init_remote_epv();
 
2927
  }
 
2928
  UNLOCK_STATIC_GLOBALS;
 
2929
 
 
2930
  s6->d_sidl_baseinterface.d_epv    = &s_rem_epv__sidl_baseinterface;
 
2931
  s6->d_sidl_baseinterface.d_object = (void*) self;
 
2932
 
 
2933
  s6->d_data = (void*) r_obj;
 
2934
  s6->d_epv  = &s_rem_epv__sidl_baseclass;
 
2935
 
 
2936
  s5->d_sidl_baseexception.d_epv    = &s_rem_epv__sidl_baseexception;
 
2937
  s5->d_sidl_baseexception.d_object = (void*) self;
 
2938
 
 
2939
  s5->d_sidl_io_serializable.d_epv    = &s_rem_epv__sidl_io_serializable;
 
2940
  s5->d_sidl_io_serializable.d_object = (void*) self;
 
2941
 
 
2942
  s5->d_data = (void*) r_obj;
 
2943
  s5->d_epv  = &s_rem_epv__sidl_sidlexception;
 
2944
 
 
2945
  s4->d_sidl_runtimeexception.d_epv    = &s_rem_epv__sidl_runtimeexception;
 
2946
  s4->d_sidl_runtimeexception.d_object = (void*) self;
 
2947
 
 
2948
  s4->d_data = (void*) r_obj;
 
2949
  s4->d_epv  = &s_rem_epv__sidl_io_ioexception;
 
2950
 
 
2951
  s3->d_data = (void*) r_obj;
 
2952
  s3->d_epv  = &s_rem_epv__sidl_rmi_networkexception;
 
2953
 
 
2954
  s2->d_data = (void*) r_obj;
 
2955
  s2->d_epv  = &s_rem_epv__sidl_rmi_protocolexception;
 
2956
 
 
2957
  s1->d_data = (void*) r_obj;
 
2958
  s1->d_epv  = &s_rem_epv__sidlx_rmi_recoverableexception;
 
2959
 
 
2960
  s0->d_data = (void*) r_obj;
 
2961
  s0->d_epv  = &s_rem_epv__sidlx_rmi_outofaddressesexception;
 
2962
 
 
2963
  self->d_data = (void*) r_obj;
 
2964
 
 
2965
  sidl_rmi_InstanceHandle_addRef(instance,_ex);SIDL_CHECK(*_ex);
 
2966
  return self;
 
2967
  EXIT:
 
2968
  if(self) { free(self); }
 
2969
  if(r_obj) { free(r_obj); }
 
2970
  return NULL;
 
2971
}
 
2972
/* REMOTE: generate remote instance given URL string. */
 
2973
static struct sidlx_rmi_OutOfAddressesException__object*
 
2974
sidlx_rmi_OutOfAddressesException__remoteCreate(const char *url, struct 
 
2975
  sidl_BaseInterface__object **_ex)
 
2976
{
 
2977
  struct sidl_BaseInterface__object* _throwaway_exception = NULL;
 
2978
  struct sidlx_rmi_OutOfAddressesException__object* self = NULL;
 
2979
 
 
2980
  struct sidlx_rmi_OutOfAddressesException__object* s0;
 
2981
  struct sidlx_rmi_RecoverableException__object* s1;
 
2982
  struct sidl_rmi_ProtocolException__object* s2;
 
2983
  struct sidl_rmi_NetworkException__object* s3;
 
2984
  struct sidl_io_IOException__object* s4;
 
2985
  struct sidl_SIDLException__object* s5;
 
2986
  struct sidl_BaseClass__object* s6;
 
2987
 
 
2988
  struct sidlx_rmi_OutOfAddressesException__remote* r_obj = NULL;
 
2989
  sidl_rmi_InstanceHandle instance = sidl_rmi_ProtocolFactory_createInstance(
 
2990
    url, "sidlx.rmi.OutOfAddressesException", _ex ); SIDL_CHECK(*_ex);
 
2991
  if ( instance == NULL) { return NULL; }
 
2992
  self =
 
2993
    (struct sidlx_rmi_OutOfAddressesException__object*) malloc(
 
2994
      sizeof(struct sidlx_rmi_OutOfAddressesException__object));
 
2995
 
 
2996
  r_obj =
 
2997
    (struct sidlx_rmi_OutOfAddressesException__remote*) malloc(
 
2998
      sizeof(struct sidlx_rmi_OutOfAddressesException__remote));
 
2999
 
 
3000
  if(!self || !r_obj) {
 
3001
    sidl_MemAllocException ex = sidl_MemAllocException_getSingletonException(
 
3002
      _ex);
 
3003
    SIDL_CHECK(*_ex);
 
3004
    sidl_MemAllocException_setNote(ex, "Out of memory.", _ex); SIDL_CHECK(*_ex);
 
3005
    sidl_MemAllocException_add(ex, __FILE__, __LINE__, 
 
3006
      "sidlx.rmi.OutOfAddressesException.EPVgeneration", _ex);
 
3007
    SIDL_CHECK(*_ex);
 
3008
    *_ex = (struct sidl_BaseInterface__object*)ex;
 
3009
    goto EXIT;
 
3010
  }
 
3011
 
 
3012
  r_obj->d_refcount = 1;
 
3013
  r_obj->d_ih = instance;
 
3014
  s0 =                                             self;
 
3015
  s1 =                                             
 
3016
    &s0->d_sidlx_rmi_recoverableexception;
 
3017
  s2 =                                             
 
3018
    &s1->d_sidl_rmi_protocolexception;
 
3019
  s3 =                                             
 
3020
    &s2->d_sidl_rmi_networkexception;
 
3021
  s4 =                                             &s3->d_sidl_io_ioexception;
 
3022
  s5 =                                             &s4->d_sidl_sidlexception;
 
3023
  s6 =                                             &s5->d_sidl_baseclass;
 
3024
 
 
3025
  LOCK_STATIC_GLOBALS;
 
3026
  if (!s_remote_initialized) {
 
3027
    sidlx_rmi_OutOfAddressesException__init_remote_epv();
 
3028
  }
 
3029
  UNLOCK_STATIC_GLOBALS;
 
3030
 
 
3031
  s6->d_sidl_baseinterface.d_epv    = &s_rem_epv__sidl_baseinterface;
 
3032
  s6->d_sidl_baseinterface.d_object = (void*) self;
 
3033
 
 
3034
  s6->d_data = (void*) r_obj;
 
3035
  s6->d_epv  = &s_rem_epv__sidl_baseclass;
 
3036
 
 
3037
  s5->d_sidl_baseexception.d_epv    = &s_rem_epv__sidl_baseexception;
 
3038
  s5->d_sidl_baseexception.d_object = (void*) self;
 
3039
 
 
3040
  s5->d_sidl_io_serializable.d_epv    = &s_rem_epv__sidl_io_serializable;
 
3041
  s5->d_sidl_io_serializable.d_object = (void*) self;
 
3042
 
 
3043
  s5->d_data = (void*) r_obj;
 
3044
  s5->d_epv  = &s_rem_epv__sidl_sidlexception;
 
3045
 
 
3046
  s4->d_sidl_runtimeexception.d_epv    = &s_rem_epv__sidl_runtimeexception;
 
3047
  s4->d_sidl_runtimeexception.d_object = (void*) self;
 
3048
 
 
3049
  s4->d_data = (void*) r_obj;
 
3050
  s4->d_epv  = &s_rem_epv__sidl_io_ioexception;
 
3051
 
 
3052
  s3->d_data = (void*) r_obj;
 
3053
  s3->d_epv  = &s_rem_epv__sidl_rmi_networkexception;
 
3054
 
 
3055
  s2->d_data = (void*) r_obj;
 
3056
  s2->d_epv  = &s_rem_epv__sidl_rmi_protocolexception;
 
3057
 
 
3058
  s1->d_data = (void*) r_obj;
 
3059
  s1->d_epv  = &s_rem_epv__sidlx_rmi_recoverableexception;
 
3060
 
 
3061
  s0->d_data = (void*) r_obj;
 
3062
  s0->d_epv  = &s_rem_epv__sidlx_rmi_outofaddressesexception;
 
3063
 
 
3064
  self->d_data = (void*) r_obj;
 
3065
 
 
3066
  return self;
 
3067
  EXIT:
 
3068
  if(instance) { sidl_rmi_InstanceHandle_deleteRef(instance, 
 
3069
    &_throwaway_exception); }
 
3070
  if(self) { free(self); }
 
3071
  if(r_obj) { free(r_obj); }
 
3072
  return NULL;
 
3073
}
 
3074
/*
 
3075
 * RMI connector function for the class.
 
3076
 */
 
3077
 
 
3078
struct sidlx_rmi_OutOfAddressesException__object*
 
3079
sidlx_rmi_OutOfAddressesException__connectI(const char* url, sidl_bool ar, 
 
3080
  struct sidl_BaseInterface__object **_ex)
 
3081
{
 
3082
  return sidlx_rmi_OutOfAddressesException__remoteConnect(url, ar, _ex);
 
3083
}
 
3084
 
 
3085
 
 
3086
#endif /*WITH_RMI*/