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

« back to all changes in this revision

Viewing changes to runtime/sidlx/sidlx_rmi_UnexpectedCloseException.h

  • 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
Added libparsifal-dev as dependency to libsidl-dev (closes: #483324).

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 * File:          sidlx_rmi_UnexpectedCloseException.h
 
3
 * Symbol:        sidlx.rmi.UnexpectedCloseException-v0.1
 
4
 * Symbol Type:   class
 
5
 * Babel Version: 1.2.0
 
6
 * Description:   Client-side glue code for sidlx.rmi.UnexpectedCloseException
 
7
 * 
 
8
 * WARNING: Automatically generated; changes will be lost
 
9
 * 
 
10
 */
 
11
 
 
12
#ifndef included_sidlx_rmi_UnexpectedCloseException_h
 
13
#define included_sidlx_rmi_UnexpectedCloseException_h
 
14
 
 
15
/**
 
16
 * Symbol "sidlx.rmi.UnexpectedCloseException" (version 0.1)
 
17
 */
 
18
struct sidlx_rmi_UnexpectedCloseException__object;
 
19
struct sidlx_rmi_UnexpectedCloseException__array;
 
20
typedef struct sidlx_rmi_UnexpectedCloseException__object* 
 
21
  sidlx_rmi_UnexpectedCloseException;
 
22
 
 
23
/*
 
24
 * Includes for all header dependencies.
 
25
 */
 
26
 
 
27
#ifndef included_sidl_header_h
 
28
#include "sidl_header.h"
 
29
#endif
 
30
#ifndef included_sidl_BaseException_h
 
31
#include "sidl_BaseException.h"
 
32
#endif
 
33
#ifndef included_sidl_BaseInterface_h
 
34
#include "sidl_BaseInterface.h"
 
35
#endif
 
36
#ifndef included_sidl_ClassInfo_h
 
37
#include "sidl_ClassInfo.h"
 
38
#endif
 
39
#ifndef included_sidl_RuntimeException_h
 
40
#include "sidl_RuntimeException.h"
 
41
#endif
 
42
#ifndef included_sidl_SIDLException_h
 
43
#include "sidl_SIDLException.h"
 
44
#endif
 
45
#ifndef included_sidl_io_Deserializer_h
 
46
#include "sidl_io_Deserializer.h"
 
47
#endif
 
48
#ifndef included_sidl_io_Serializer_h
 
49
#include "sidl_io_Serializer.h"
 
50
#endif
 
51
 
 
52
#ifndef included_sidl_rmi_Call_h
 
53
#include "sidl_rmi_Call.h"
 
54
#endif
 
55
#ifndef included_sidl_rmi_Return_h
 
56
#include "sidl_rmi_Return.h"
 
57
#endif
 
58
#ifdef SIDL_C_HAS_INLINE
 
59
#ifndef included_sidlx_rmi_UnexpectedCloseException_IOR_h
 
60
#include "sidlx_rmi_UnexpectedCloseException_IOR.h"
 
61
#endif
 
62
#endif /* SIDL_C_HAS_INLINE */
 
63
#ifdef __cplusplus
 
64
extern "C" {
 
65
#endif
 
66
 
 
67
/**
 
68
 * Constructor function for the class.
 
69
 */
 
70
struct sidlx_rmi_UnexpectedCloseException__object*
 
71
sidlx_rmi_UnexpectedCloseException__create(sidl_BaseInterface* _ex);
 
72
 
 
73
/**
 
74
 * Wraps up the private data struct pointer (struct sidlx_rmi_UnexpectedCloseException__data) passed in rather than running the constructor.
 
75
 */
 
76
sidlx_rmi_UnexpectedCloseException
 
77
sidlx_rmi_UnexpectedCloseException__wrapObj(void * data, sidl_BaseInterface 
 
78
  *_ex);
 
79
 
 
80
#ifdef WITH_RMI
 
81
 
 
82
/**
 
83
 * RMI constructor function for the class.
 
84
 */
 
85
sidlx_rmi_UnexpectedCloseException
 
86
sidlx_rmi_UnexpectedCloseException__createRemote(const char * url, 
 
87
  sidl_BaseInterface *_ex);
 
88
 
 
89
/**
 
90
 * RMI connector function for the class.(addrefs)
 
91
 */
 
92
sidlx_rmi_UnexpectedCloseException
 
93
sidlx_rmi_UnexpectedCloseException__connect(const char *, sidl_BaseInterface 
 
94
  *_ex);
 
95
 
 
96
 
 
97
#endif /*WITH_RMI*/
 
98
/**
 
99
 * Method:  getHopCount[]
 
100
 */
 
101
SIDL_C_INLINE_DECL
 
102
int32_t
 
103
sidlx_rmi_UnexpectedCloseException_getHopCount(
 
104
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
105
  /* out */ sidl_BaseInterface *_ex)
 
106
#ifdef SIDL_C_HAS_INLINE
 
107
{
 
108
  int32_t _result;
 
109
  _result = (*self->d_epv->f_getHopCount)(
 
110
    self,
 
111
    _ex);
 
112
  return _result;
 
113
}
 
114
#else
 
115
;
 
116
#endif /* SIDL_C_HAS_INLINE */
 
117
 
 
118
 
 
119
/**
 
120
 * Method:  setErrno[]
 
121
 */
 
122
SIDL_C_INLINE_DECL
 
123
void
 
124
sidlx_rmi_UnexpectedCloseException_setErrno(
 
125
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
126
  /* in */ int32_t err,
 
127
  /* out */ sidl_BaseInterface *_ex)
 
128
#ifdef SIDL_C_HAS_INLINE
 
129
{
 
130
  (*self->d_epv->f_setErrno)(
 
131
    self,
 
132
    err,
 
133
    _ex);
 
134
}
 
135
#else
 
136
;
 
137
#endif /* SIDL_C_HAS_INLINE */
 
138
 
 
139
 
 
140
/**
 
141
 * Method:  getErrno[]
 
142
 */
 
143
SIDL_C_INLINE_DECL
 
144
int32_t
 
145
sidlx_rmi_UnexpectedCloseException_getErrno(
 
146
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
147
  /* out */ sidl_BaseInterface *_ex)
 
148
#ifdef SIDL_C_HAS_INLINE
 
149
{
 
150
  int32_t _result;
 
151
  _result = (*self->d_epv->f_getErrno)(
 
152
    self,
 
153
    _ex);
 
154
  return _result;
 
155
}
 
156
#else
 
157
;
 
158
#endif /* SIDL_C_HAS_INLINE */
 
159
 
 
160
 
 
161
/**
 
162
 * <p>
 
163
 * Add one to the intrinsic reference count in the underlying object.
 
164
 * Object in <code>sidl</code> have an intrinsic reference count.
 
165
 * Objects continue to exist as long as the reference count is
 
166
 * positive. Clients should call this method whenever they
 
167
 * create another ongoing reference to an object or interface.
 
168
 * </p>
 
169
 * <p>
 
170
 * This does not have a return value because there is no language
 
171
 * independent type that can refer to an interface or a
 
172
 * class.
 
173
 * </p>
 
174
 */
 
175
SIDL_C_INLINE_DECL
 
176
void
 
177
sidlx_rmi_UnexpectedCloseException_addRef(
 
178
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
179
  /* out */ sidl_BaseInterface *_ex)
 
180
#ifdef SIDL_C_HAS_INLINE
 
181
{
 
182
  (*self->d_epv->f_addRef)(
 
183
    self,
 
184
    _ex);
 
185
}
 
186
#else
 
187
;
 
188
#endif /* SIDL_C_HAS_INLINE */
 
189
 
 
190
 
 
191
/**
 
192
 * Decrease by one the intrinsic reference count in the underlying
 
193
 * object, and delete the object if the reference is non-positive.
 
194
 * Objects in <code>sidl</code> have an intrinsic reference count.
 
195
 * Clients should call this method whenever they remove a
 
196
 * reference to an object or interface.
 
197
 */
 
198
SIDL_C_INLINE_DECL
 
199
void
 
200
sidlx_rmi_UnexpectedCloseException_deleteRef(
 
201
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
202
  /* out */ sidl_BaseInterface *_ex)
 
203
#ifdef SIDL_C_HAS_INLINE
 
204
{
 
205
  (*self->d_epv->f_deleteRef)(
 
206
    self,
 
207
    _ex);
 
208
}
 
209
#else
 
210
;
 
211
#endif /* SIDL_C_HAS_INLINE */
 
212
 
 
213
 
 
214
/**
 
215
 * Return true if and only if <code>obj</code> refers to the same
 
216
 * object as this object.
 
217
 */
 
218
SIDL_C_INLINE_DECL
 
219
sidl_bool
 
220
sidlx_rmi_UnexpectedCloseException_isSame(
 
221
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
222
  /* in */ sidl_BaseInterface iobj,
 
223
  /* out */ sidl_BaseInterface *_ex)
 
224
#ifdef SIDL_C_HAS_INLINE
 
225
{
 
226
  sidl_bool _result;
 
227
  _result = (*self->d_epv->f_isSame)(
 
228
    self,
 
229
    iobj,
 
230
    _ex);
 
231
  return _result;
 
232
}
 
233
#else
 
234
;
 
235
#endif /* SIDL_C_HAS_INLINE */
 
236
 
 
237
 
 
238
/**
 
239
 * Return whether this object is an instance of the specified type.
 
240
 * The string name must be the <code>sidl</code> type name.  This
 
241
 * routine will return <code>true</code> if and only if a cast to
 
242
 * the string type name would succeed.
 
243
 */
 
244
SIDL_C_INLINE_DECL
 
245
sidl_bool
 
246
sidlx_rmi_UnexpectedCloseException_isType(
 
247
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
248
  /* in */ const char* name,
 
249
  /* out */ sidl_BaseInterface *_ex)
 
250
#ifdef SIDL_C_HAS_INLINE
 
251
{
 
252
  sidl_bool _result;
 
253
  _result = (*self->d_epv->f_isType)(
 
254
    self,
 
255
    name,
 
256
    _ex);
 
257
  return _result;
 
258
}
 
259
#else
 
260
;
 
261
#endif /* SIDL_C_HAS_INLINE */
 
262
 
 
263
 
 
264
/**
 
265
 * Return the meta-data about the class implementing this interface.
 
266
 */
 
267
SIDL_C_INLINE_DECL
 
268
sidl_ClassInfo
 
269
sidlx_rmi_UnexpectedCloseException_getClassInfo(
 
270
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
271
  /* out */ sidl_BaseInterface *_ex)
 
272
#ifdef SIDL_C_HAS_INLINE
 
273
{
 
274
  sidl_ClassInfo _result;
 
275
  _result = (*self->d_epv->f_getClassInfo)(
 
276
    self,
 
277
    _ex);
 
278
  return _result;
 
279
}
 
280
#else
 
281
;
 
282
#endif /* SIDL_C_HAS_INLINE */
 
283
 
 
284
 
 
285
/**
 
286
 * Return the message associated with the exception.
 
287
 */
 
288
SIDL_C_INLINE_DECL
 
289
char*
 
290
sidlx_rmi_UnexpectedCloseException_getNote(
 
291
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
292
  /* out */ sidl_BaseInterface *_ex)
 
293
#ifdef SIDL_C_HAS_INLINE
 
294
{
 
295
  char* _result;
 
296
  _result = (*self->d_epv->f_getNote)(
 
297
    self,
 
298
    _ex);
 
299
  return _result;
 
300
}
 
301
#else
 
302
;
 
303
#endif /* SIDL_C_HAS_INLINE */
 
304
 
 
305
 
 
306
/**
 
307
 * Set the message associated with the exception.
 
308
 */
 
309
SIDL_C_INLINE_DECL
 
310
void
 
311
sidlx_rmi_UnexpectedCloseException_setNote(
 
312
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
313
  /* in */ const char* message,
 
314
  /* out */ sidl_BaseInterface *_ex)
 
315
#ifdef SIDL_C_HAS_INLINE
 
316
{
 
317
  (*self->d_epv->f_setNote)(
 
318
    self,
 
319
    message,
 
320
    _ex);
 
321
}
 
322
#else
 
323
;
 
324
#endif /* SIDL_C_HAS_INLINE */
 
325
 
 
326
 
 
327
/**
 
328
 * Returns formatted string containing the concatenation of all 
 
329
 * tracelines.
 
330
 */
 
331
SIDL_C_INLINE_DECL
 
332
char*
 
333
sidlx_rmi_UnexpectedCloseException_getTrace(
 
334
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
335
  /* out */ sidl_BaseInterface *_ex)
 
336
#ifdef SIDL_C_HAS_INLINE
 
337
{
 
338
  char* _result;
 
339
  _result = (*self->d_epv->f_getTrace)(
 
340
    self,
 
341
    _ex);
 
342
  return _result;
 
343
}
 
344
#else
 
345
;
 
346
#endif /* SIDL_C_HAS_INLINE */
 
347
 
 
348
 
 
349
/**
 
350
 * Adds a stringified entry/line to the stack trace.
 
351
 */
 
352
SIDL_C_INLINE_DECL
 
353
void
 
354
sidlx_rmi_UnexpectedCloseException_addLine(
 
355
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
356
  /* in */ const char* traceline,
 
357
  /* out */ sidl_BaseInterface *_ex)
 
358
#ifdef SIDL_C_HAS_INLINE
 
359
{
 
360
  (*self->d_epv->f_addLine)(
 
361
    self,
 
362
    traceline,
 
363
    _ex);
 
364
}
 
365
#else
 
366
;
 
367
#endif /* SIDL_C_HAS_INLINE */
 
368
 
 
369
 
 
370
/**
 
371
 * Formats and adds an entry to the stack trace based on the 
 
372
 * file name, line number, and method name.
 
373
 */
 
374
SIDL_C_INLINE_DECL
 
375
void
 
376
sidlx_rmi_UnexpectedCloseException_add(
 
377
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
378
  /* in */ const char* filename,
 
379
  /* in */ int32_t lineno,
 
380
  /* in */ const char* methodname,
 
381
  /* out */ sidl_BaseInterface *_ex)
 
382
#ifdef SIDL_C_HAS_INLINE
 
383
{
 
384
  (*self->d_epv->f_add)(
 
385
    self,
 
386
    filename,
 
387
    lineno,
 
388
    methodname,
 
389
    _ex);
 
390
}
 
391
#else
 
392
;
 
393
#endif /* SIDL_C_HAS_INLINE */
 
394
 
 
395
 
 
396
/**
 
397
 * Method:  packObj[]
 
398
 */
 
399
SIDL_C_INLINE_DECL
 
400
void
 
401
sidlx_rmi_UnexpectedCloseException_packObj(
 
402
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
403
  /* in */ sidl_io_Serializer ser,
 
404
  /* out */ sidl_BaseInterface *_ex)
 
405
#ifdef SIDL_C_HAS_INLINE
 
406
{
 
407
  (*self->d_epv->f_packObj)(
 
408
    self,
 
409
    ser,
 
410
    _ex);
 
411
}
 
412
#else
 
413
;
 
414
#endif /* SIDL_C_HAS_INLINE */
 
415
 
 
416
 
 
417
/**
 
418
 * Method:  unpackObj[]
 
419
 */
 
420
SIDL_C_INLINE_DECL
 
421
void
 
422
sidlx_rmi_UnexpectedCloseException_unpackObj(
 
423
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
424
  /* in */ sidl_io_Deserializer des,
 
425
  /* out */ sidl_BaseInterface *_ex)
 
426
#ifdef SIDL_C_HAS_INLINE
 
427
{
 
428
  (*self->d_epv->f_unpackObj)(
 
429
    self,
 
430
    des,
 
431
    _ex);
 
432
}
 
433
#else
 
434
;
 
435
#endif /* SIDL_C_HAS_INLINE */
 
436
 
 
437
 
 
438
/**
 
439
 * Cast method for interface and class type conversions.
 
440
 */
 
441
struct sidlx_rmi_UnexpectedCloseException__object*
 
442
sidlx_rmi_UnexpectedCloseException__cast(
 
443
  void* obj,
 
444
  sidl_BaseInterface* _ex);
 
445
 
 
446
/**
 
447
 * String cast method for interface and class type conversions.
 
448
 */
 
449
void*
 
450
sidlx_rmi_UnexpectedCloseException__cast2(
 
451
  void* obj,
 
452
  const char* type,
 
453
  sidl_BaseInterface *_ex);
 
454
 
 
455
/**
 
456
 * Select and execute a method by name
 
457
 */
 
458
SIDL_C_INLINE_DECL
 
459
void
 
460
sidlx_rmi_UnexpectedCloseException__exec(
 
461
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
462
  /* in */ const char* methodName,
 
463
  /* in */ sidl_rmi_Call inArgs,
 
464
  /* in */ sidl_rmi_Return outArgs,
 
465
  /* out */ sidl_BaseInterface *_ex)
 
466
#ifdef SIDL_C_HAS_INLINE
 
467
{
 
468
  (*self->d_epv->f__exec)(
 
469
    self,
 
470
    methodName,
 
471
    inArgs,
 
472
    outArgs,
 
473
    _ex);
 
474
}
 
475
#else
 
476
;
 
477
#endif /* SIDL_C_HAS_INLINE */
 
478
 
 
479
/**
 
480
 * Get the URL of the Implementation of this object (for RMI)
 
481
 */
 
482
SIDL_C_INLINE_DECL
 
483
char*
 
484
sidlx_rmi_UnexpectedCloseException__getURL(
 
485
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
486
  /* out */ sidl_BaseInterface *_ex)
 
487
#ifdef SIDL_C_HAS_INLINE
 
488
{
 
489
  char* _result;
 
490
  _result = (*self->d_epv->f__getURL)(
 
491
    self,
 
492
    _ex);
 
493
  return _result;
 
494
}
 
495
#else
 
496
;
 
497
#endif /* SIDL_C_HAS_INLINE */
 
498
 
 
499
/**
 
500
 * On a remote object, addrefs the remote instance.
 
501
 */
 
502
SIDL_C_INLINE_DECL
 
503
void
 
504
sidlx_rmi_UnexpectedCloseException__raddRef(
 
505
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
506
  /* out */ sidl_BaseInterface *_ex)
 
507
#ifdef SIDL_C_HAS_INLINE
 
508
{
 
509
  (*self->d_epv->f__raddRef)(
 
510
    self,
 
511
    _ex);
 
512
}
 
513
#else
 
514
;
 
515
#endif /* SIDL_C_HAS_INLINE */
 
516
 
 
517
/**
 
518
 * TRUE if this object is remote, false if local
 
519
 */
 
520
SIDL_C_INLINE_DECL
 
521
sidl_bool
 
522
sidlx_rmi_UnexpectedCloseException__isRemote(
 
523
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
524
  /* out */ sidl_BaseInterface *_ex)
 
525
#ifdef SIDL_C_HAS_INLINE
 
526
{
 
527
  sidl_bool _result;
 
528
  _result = (*self->d_epv->f__isRemote)(
 
529
    self,
 
530
    _ex);
 
531
  return _result;
 
532
}
 
533
#else
 
534
;
 
535
#endif /* SIDL_C_HAS_INLINE */
 
536
 
 
537
/**
 
538
 * TRUE if this object is remote, false if local
 
539
 */
 
540
sidl_bool
 
541
sidlx_rmi_UnexpectedCloseException__isLocal(
 
542
  /* in */ sidlx_rmi_UnexpectedCloseException self,
 
543
  /* out */ sidl_BaseInterface *_ex);
 
544
/**
 
545
 * Create a contiguous array of the given dimension with specified
 
546
 * index bounds in column-major order. This array
 
547
 * owns and manages its data.
 
548
 * This function initializes the contents of the array to
 
549
 * NULL.
 
550
 */
 
551
struct sidlx_rmi_UnexpectedCloseException__array*
 
552
sidlx_rmi_UnexpectedCloseException__array_createCol(
 
553
  int32_t       dimen,
 
554
  const int32_t lower[],
 
555
  const int32_t upper[]);
 
556
 
 
557
/**
 
558
 * Create a contiguous array of the given dimension with specified
 
559
 * index bounds in row-major order. This array
 
560
 * owns and manages its data.
 
561
 * This function initializes the contents of the array to
 
562
 * NULL.
 
563
 */
 
564
struct sidlx_rmi_UnexpectedCloseException__array*
 
565
sidlx_rmi_UnexpectedCloseException__array_createRow(
 
566
  int32_t       dimen,
 
567
  const int32_t lower[],
 
568
  const int32_t upper[]);
 
569
 
 
570
/**
 
571
 * Create a contiguous one-dimensional array with a lower index
 
572
 * of 0 and an upper index of len-1. This array
 
573
 * owns and manages its data.
 
574
 * This function initializes the contents of the array to
 
575
 * NULL.
 
576
 */
 
577
struct sidlx_rmi_UnexpectedCloseException__array*
 
578
sidlx_rmi_UnexpectedCloseException__array_create1d(int32_t len);
 
579
 
 
580
/**
 
581
 * Create a dense one-dimensional vector with a lower
 
582
 * index of 0 and an upper index of len-1. The initial data for this
 
583
 * new array is copied from data. This will increment the reference
 
584
 * count of each non-NULL object/interface reference in data.
 
585
 * 
 
586
 * This array owns and manages its data.
 
587
 */
 
588
struct sidlx_rmi_UnexpectedCloseException__array*
 
589
sidlx_rmi_UnexpectedCloseException__array_create1dInit(
 
590
  int32_t len, 
 
591
  sidlx_rmi_UnexpectedCloseException* data);
 
592
 
 
593
/**
 
594
 * Create a contiguous two-dimensional array in column-major
 
595
 * order with a lower index of (0,0) and an upper index of
 
596
 * (m-1,n-1). This array owns and manages its data.
 
597
 * This function initializes the contents of the array to
 
598
 * NULL.
 
599
 */
 
600
struct sidlx_rmi_UnexpectedCloseException__array*
 
601
sidlx_rmi_UnexpectedCloseException__array_create2dCol(int32_t m, int32_t n);
 
602
 
 
603
/**
 
604
 * Create a contiguous two-dimensional array in row-major
 
605
 * order with a lower index of (0,0) and an upper index of
 
606
 * (m-1,n-1). This array owns and manages its data.
 
607
 * This function initializes the contents of the array to
 
608
 * NULL.
 
609
 */
 
610
struct sidlx_rmi_UnexpectedCloseException__array*
 
611
sidlx_rmi_UnexpectedCloseException__array_create2dRow(int32_t m, int32_t n);
 
612
 
 
613
/**
 
614
 * Create an array that uses data (memory) from another
 
615
 * source. The initial contents are determined by the
 
616
 * data being borrowed.
 
617
 * Any time an element in the borrowed array is replaced
 
618
 * via a set call, deleteRef will be called on the
 
619
 * value being replaced if it is not NULL.
 
620
 */
 
621
struct sidlx_rmi_UnexpectedCloseException__array*
 
622
sidlx_rmi_UnexpectedCloseException__array_borrow(
 
623
  sidlx_rmi_UnexpectedCloseException* firstElement,
 
624
  int32_t       dimen,
 
625
  const int32_t lower[],
 
626
  const int32_t upper[],
 
627
  const int32_t stride[]);
 
628
 
 
629
/**
 
630
 * If array is borrowed, allocate a new self-sufficient
 
631
 * array and copy the borrowed array into the new array;
 
632
 * otherwise, increment the reference count and return
 
633
 * the array passed in. Use this whenever you want to
 
634
 * make a copy of a method argument because arrays
 
635
 * passed into methods aren't guaranteed to exist after
 
636
 * the method call.
 
637
 */
 
638
struct sidlx_rmi_UnexpectedCloseException__array*
 
639
sidlx_rmi_UnexpectedCloseException__array_smartCopy(
 
640
  struct sidlx_rmi_UnexpectedCloseException__array *array);
 
641
 
 
642
/**
 
643
 * Increment the array's internal reference count by one.
 
644
 */
 
645
void
 
646
sidlx_rmi_UnexpectedCloseException__array_addRef(
 
647
  struct sidlx_rmi_UnexpectedCloseException__array* array);
 
648
 
 
649
/**
 
650
 * Decrement the array's internal reference count by one.
 
651
 * If the reference count goes to zero, destroy the array.
 
652
 * If the array isn't borrowed, this releases all the
 
653
 * object references held by the array.
 
654
 */
 
655
void
 
656
sidlx_rmi_UnexpectedCloseException__array_deleteRef(
 
657
  struct sidlx_rmi_UnexpectedCloseException__array* array);
 
658
 
 
659
/**
 
660
 * Retrieve element i1 of a(n) 1-dimensional array.
 
661
 */
 
662
sidlx_rmi_UnexpectedCloseException
 
663
sidlx_rmi_UnexpectedCloseException__array_get1(
 
664
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
665
  const int32_t i1);
 
666
 
 
667
/**
 
668
 * Retrieve element (i1,i2) of a(n) 2-dimensional array.
 
669
 */
 
670
sidlx_rmi_UnexpectedCloseException
 
671
sidlx_rmi_UnexpectedCloseException__array_get2(
 
672
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
673
  const int32_t i1,
 
674
  const int32_t i2);
 
675
 
 
676
/**
 
677
 * Retrieve element (i1,i2,i3) of a(n) 3-dimensional array.
 
678
 */
 
679
sidlx_rmi_UnexpectedCloseException
 
680
sidlx_rmi_UnexpectedCloseException__array_get3(
 
681
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
682
  const int32_t i1,
 
683
  const int32_t i2,
 
684
  const int32_t i3);
 
685
 
 
686
/**
 
687
 * Retrieve element (i1,i2,i3,i4) of a(n) 4-dimensional array.
 
688
 */
 
689
sidlx_rmi_UnexpectedCloseException
 
690
sidlx_rmi_UnexpectedCloseException__array_get4(
 
691
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
692
  const int32_t i1,
 
693
  const int32_t i2,
 
694
  const int32_t i3,
 
695
  const int32_t i4);
 
696
 
 
697
/**
 
698
 * Retrieve element (i1,i2,i3,i4,i5) of a(n) 5-dimensional array.
 
699
 */
 
700
sidlx_rmi_UnexpectedCloseException
 
701
sidlx_rmi_UnexpectedCloseException__array_get5(
 
702
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
703
  const int32_t i1,
 
704
  const int32_t i2,
 
705
  const int32_t i3,
 
706
  const int32_t i4,
 
707
  const int32_t i5);
 
708
 
 
709
/**
 
710
 * Retrieve element (i1,i2,i3,i4,i5,i6) of a(n) 6-dimensional array.
 
711
 */
 
712
sidlx_rmi_UnexpectedCloseException
 
713
sidlx_rmi_UnexpectedCloseException__array_get6(
 
714
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
715
  const int32_t i1,
 
716
  const int32_t i2,
 
717
  const int32_t i3,
 
718
  const int32_t i4,
 
719
  const int32_t i5,
 
720
  const int32_t i6);
 
721
 
 
722
/**
 
723
 * Retrieve element (i1,i2,i3,i4,i5,i6,i7) of a(n) 7-dimensional array.
 
724
 */
 
725
sidlx_rmi_UnexpectedCloseException
 
726
sidlx_rmi_UnexpectedCloseException__array_get7(
 
727
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
728
  const int32_t i1,
 
729
  const int32_t i2,
 
730
  const int32_t i3,
 
731
  const int32_t i4,
 
732
  const int32_t i5,
 
733
  const int32_t i6,
 
734
  const int32_t i7);
 
735
 
 
736
/**
 
737
 * Retrieve element indices of an n-dimensional array.
 
738
 * indices is assumed to have the right number of elements
 
739
 * for the dimension of array.
 
740
 */
 
741
sidlx_rmi_UnexpectedCloseException
 
742
sidlx_rmi_UnexpectedCloseException__array_get(
 
743
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
744
  const int32_t indices[]);
 
745
 
 
746
/**
 
747
 * Set element i1 of a(n) 1-dimensional array to value.
 
748
 */
 
749
void
 
750
sidlx_rmi_UnexpectedCloseException__array_set1(
 
751
  struct sidlx_rmi_UnexpectedCloseException__array* array,
 
752
  const int32_t i1,
 
753
  sidlx_rmi_UnexpectedCloseException const value);
 
754
 
 
755
/**
 
756
 * Set element (i1,i2) of a(n) 2-dimensional array to value.
 
757
 */
 
758
void
 
759
sidlx_rmi_UnexpectedCloseException__array_set2(
 
760
  struct sidlx_rmi_UnexpectedCloseException__array* array,
 
761
  const int32_t i1,
 
762
  const int32_t i2,
 
763
  sidlx_rmi_UnexpectedCloseException const value);
 
764
 
 
765
/**
 
766
 * Set element (i1,i2,i3) of a(n) 3-dimensional array to value.
 
767
 */
 
768
void
 
769
sidlx_rmi_UnexpectedCloseException__array_set3(
 
770
  struct sidlx_rmi_UnexpectedCloseException__array* array,
 
771
  const int32_t i1,
 
772
  const int32_t i2,
 
773
  const int32_t i3,
 
774
  sidlx_rmi_UnexpectedCloseException const value);
 
775
 
 
776
/**
 
777
 * Set element (i1,i2,i3,i4) of a(n) 4-dimensional array to value.
 
778
 */
 
779
void
 
780
sidlx_rmi_UnexpectedCloseException__array_set4(
 
781
  struct sidlx_rmi_UnexpectedCloseException__array* array,
 
782
  const int32_t i1,
 
783
  const int32_t i2,
 
784
  const int32_t i3,
 
785
  const int32_t i4,
 
786
  sidlx_rmi_UnexpectedCloseException const value);
 
787
 
 
788
/**
 
789
 * Set element (i1,i2,i3,i4,i5) of a(n) 5-dimensional array to value.
 
790
 */
 
791
void
 
792
sidlx_rmi_UnexpectedCloseException__array_set5(
 
793
  struct sidlx_rmi_UnexpectedCloseException__array* array,
 
794
  const int32_t i1,
 
795
  const int32_t i2,
 
796
  const int32_t i3,
 
797
  const int32_t i4,
 
798
  const int32_t i5,
 
799
  sidlx_rmi_UnexpectedCloseException const value);
 
800
 
 
801
/**
 
802
 * Set element (i1,i2,i3,i4,i5,i6) of a(n) 6-dimensional array to value.
 
803
 */
 
804
void
 
805
sidlx_rmi_UnexpectedCloseException__array_set6(
 
806
  struct sidlx_rmi_UnexpectedCloseException__array* array,
 
807
  const int32_t i1,
 
808
  const int32_t i2,
 
809
  const int32_t i3,
 
810
  const int32_t i4,
 
811
  const int32_t i5,
 
812
  const int32_t i6,
 
813
  sidlx_rmi_UnexpectedCloseException const value);
 
814
 
 
815
/**
 
816
 * Set element (i1,i2,i3,i4,i5,i6,i7) of a(n) 7-dimensional array to value.
 
817
 */
 
818
void
 
819
sidlx_rmi_UnexpectedCloseException__array_set7(
 
820
  struct sidlx_rmi_UnexpectedCloseException__array* array,
 
821
  const int32_t i1,
 
822
  const int32_t i2,
 
823
  const int32_t i3,
 
824
  const int32_t i4,
 
825
  const int32_t i5,
 
826
  const int32_t i6,
 
827
  const int32_t i7,
 
828
  sidlx_rmi_UnexpectedCloseException const value);
 
829
 
 
830
/**
 
831
 * Set element indices of an n-dimensional array to value.indices is assumed to have the right number of elements
 
832
 * for the dimension of array.
 
833
 */
 
834
void
 
835
sidlx_rmi_UnexpectedCloseException__array_set(
 
836
  struct sidlx_rmi_UnexpectedCloseException__array* array,
 
837
  const int32_t indices[],
 
838
  sidlx_rmi_UnexpectedCloseException const value);
 
839
 
 
840
/**
 
841
 * Return the dimension of array. If the array pointer is
 
842
 * NULL, zero is returned.
 
843
 */
 
844
int32_t
 
845
sidlx_rmi_UnexpectedCloseException__array_dimen(
 
846
  const struct sidlx_rmi_UnexpectedCloseException__array* array);
 
847
 
 
848
/**
 
849
 * Return the lower bound of dimension ind.
 
850
 * If ind is not a valid dimension, 0 is returned.
 
851
 * The valid range for ind is from 0 to dimen-1.
 
852
 */
 
853
int32_t
 
854
sidlx_rmi_UnexpectedCloseException__array_lower(
 
855
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
856
  const int32_t ind);
 
857
 
 
858
/**
 
859
 * Return the upper bound of dimension ind.
 
860
 * If ind is not a valid dimension, -1 is returned.
 
861
 * The valid range for ind is from 0 to dimen-1.
 
862
 */
 
863
int32_t
 
864
sidlx_rmi_UnexpectedCloseException__array_upper(
 
865
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
866
  const int32_t ind);
 
867
 
 
868
/**
 
869
 * Return the length of dimension ind.
 
870
 * If ind is not a valid dimension, -1 is returned.
 
871
 * The valid range for ind is from 0 to dimen-1.
 
872
 */
 
873
int32_t
 
874
sidlx_rmi_UnexpectedCloseException__array_length(
 
875
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
876
  const int32_t ind);
 
877
 
 
878
/**
 
879
 * Return the stride of dimension ind.
 
880
 * If ind is not a valid dimension, 0 is returned.
 
881
 * The valid range for ind is from 0 to dimen-1.
 
882
 */
 
883
int32_t
 
884
sidlx_rmi_UnexpectedCloseException__array_stride(
 
885
  const struct sidlx_rmi_UnexpectedCloseException__array* array,
 
886
  const int32_t ind);
 
887
 
 
888
/**
 
889
 * Return a true value iff the array is a contiguous
 
890
 * column-major ordered array. A NULL array argument
 
891
 * causes 0 to be returned.
 
892
 */
 
893
int
 
894
sidlx_rmi_UnexpectedCloseException__array_isColumnOrder(
 
895
  const struct sidlx_rmi_UnexpectedCloseException__array* array);
 
896
 
 
897
/**
 
898
 * Return a true value iff the array is a contiguous
 
899
 * row-major ordered array. A NULL array argument
 
900
 * causes 0 to be returned.
 
901
 */
 
902
int
 
903
sidlx_rmi_UnexpectedCloseException__array_isRowOrder(
 
904
  const struct sidlx_rmi_UnexpectedCloseException__array* array);
 
905
 
 
906
/**
 
907
 * Create a sub-array of another array. This resulting
 
908
 * array shares data with the original array. The new
 
909
 * array can be of the same dimension or potentially
 
910
 * less assuming the original array has dimension
 
911
 * greater than 1.  If you are removing dimension,
 
912
 * indicate the dimensions to remove by setting
 
913
 * numElem[i] to zero for any dimension i wthat should
 
914
 * go away in the new array.  The meaning of each
 
915
 * argument is covered below.
 
916
 * 
 
917
 * src       the array to be created will be a subset
 
918
 *           of this array. If this argument is NULL,
 
919
 *           NULL will be returned. The array returned
 
920
 *           borrows data from src, so modifying src or
 
921
 *           the returned array will modify both
 
922
 *           arrays.
 
923
 * 
 
924
 * dimen     this argument must be greater than zero
 
925
 *           and less than or equal to the dimension of
 
926
 *           src. An illegal value will cause a NULL
 
927
 *           return value.
 
928
 * 
 
929
 * numElem   this specifies how many elements from src
 
930
 *           should be taken in each dimension. A zero
 
931
 *           entry indicates that the dimension should
 
932
 *           not appear in the new array.  This
 
933
 *           argument should be an array with an entry
 
934
 *           for each dimension of src.  Passing NULL
 
935
 *           here will cause NULL to be returned.  If
 
936
 *           srcStart[i] + numElem[i]*srcStride[i] is
 
937
 *           greater than upper[i] for src or if
 
938
 *           srcStart[i] + numElem[i]*srcStride[i] is
 
939
 *           less than lower[i] for src, NULL will be
 
940
 *           returned.
 
941
 * 
 
942
 * srcStart  this array holds the coordinates of the
 
943
 *           first element of the new array. If this
 
944
 *           argument is NULL, the first element of src
 
945
 *           will be the first element of the new
 
946
 *           array. If non-NULL, this argument should
 
947
 *           be an array with an entry for each
 
948
 *           dimension of src.  If srcStart[i] is less
 
949
 *           than lower[i] for the array src, NULL will
 
950
 *           be returned.
 
951
 * 
 
952
 * srcStride this array lets you specify the stride
 
953
 *           between elements in each dimension of
 
954
 *           src. This stride is relative to the
 
955
 *           coordinate system of the src array. If
 
956
 *           this argument is NULL, the stride is taken
 
957
 *           to be one in each dimension.  If non-NULL,
 
958
 *           this argument should be an array with an
 
959
 *           entry for each dimension of src.
 
960
 * 
 
961
 * newLower  this argument is like lower in a create
 
962
 *           method. It sets the coordinates for the
 
963
 *           first element in the new array.  If this
 
964
 *           argument is NULL, the values indicated by
 
965
 *           srcStart will be used. If non-NULL, this
 
966
 *           should be an array with dimen elements.
 
967
 */
 
968
struct sidlx_rmi_UnexpectedCloseException__array*
 
969
sidlx_rmi_UnexpectedCloseException__array_slice(
 
970
  struct sidlx_rmi_UnexpectedCloseException__array* src,
 
971
  int32_t        dimen,
 
972
  const int32_t  numElem[],
 
973
  const int32_t  *srcStart,
 
974
  const int32_t  *srcStride,
 
975
  const int32_t  *newStart);
 
976
 
 
977
/**
 
978
 * Copy the contents of one array (src) to a second array
 
979
 * (dest). For the copy to take place, both arrays must
 
980
 * exist and be of the same dimension. This method will
 
981
 * not modify dest's size, index bounds, or stride; only
 
982
 * the array element values of dest may be changed by
 
983
 * this function. No part of src is ever changed by copy.
 
984
 * 
 
985
 * On exit, dest[i][j][k]... = src[i][j][k]... for all
 
986
 * indices i,j,k...  that are in both arrays. If dest and
 
987
 * src have no indices in common, nothing is copied. For
 
988
 * example, if src is a 1-d array with elements 0-5 and
 
989
 * dest is a 1-d array with elements 2-3, this function
 
990
 * will make the following assignments:
 
991
 *   dest[2] = src[2],
 
992
 *   dest[3] = src[3].
 
993
 * The function copied the elements that both arrays have
 
994
 * in common.  If dest had elements 4-10, this function
 
995
 * will make the following assignments:
 
996
 *   dest[4] = src[4],
 
997
 *   dest[5] = src[5].
 
998
 */
 
999
void
 
1000
sidlx_rmi_UnexpectedCloseException__array_copy(
 
1001
  const struct sidlx_rmi_UnexpectedCloseException__array* src,
 
1002
  struct sidlx_rmi_UnexpectedCloseException__array* dest);
 
1003
 
 
1004
/**
 
1005
 * If necessary, convert a general matrix into a matrix
 
1006
 * with the required properties. This checks the
 
1007
 * dimension and ordering of the matrix.  If both these
 
1008
 * match, it simply returns a new reference to the
 
1009
 * existing matrix. If the dimension of the incoming
 
1010
 * array doesn't match, it returns NULL. If the ordering
 
1011
 * of the incoming array doesn't match the specification,
 
1012
 * a new array is created with the desired ordering and
 
1013
 * the content of the incoming array is copied to the new
 
1014
 * array.
 
1015
 * 
 
1016
 * The ordering parameter should be one of the constants
 
1017
 * defined in enum sidl_array_ordering
 
1018
 * (e.g. sidl_general_order, sidl_column_major_order, or
 
1019
 * sidl_row_major_order). If you specify
 
1020
 * sidl_general_order, this routine will only check the
 
1021
 * dimension because any matrix is sidl_general_order.
 
1022
 * 
 
1023
 * The caller assumes ownership of the returned reference
 
1024
 * unless it's NULL.
 
1025
 */
 
1026
struct sidlx_rmi_UnexpectedCloseException__array*
 
1027
sidlx_rmi_UnexpectedCloseException__array_ensure(
 
1028
  struct sidlx_rmi_UnexpectedCloseException__array* src,
 
1029
  int32_t dimen,
 
1030
  int     ordering);
 
1031
 
 
1032
 
 
1033
#pragma weak sidlx_rmi_UnexpectedCloseException__connectI
 
1034
 
 
1035
/**
 
1036
 * RMI connector function for the class. (no addref)
 
1037
 */
 
1038
struct sidlx_rmi_UnexpectedCloseException__object*
 
1039
sidlx_rmi_UnexpectedCloseException__connectI(const char * url, sidl_bool ar, 
 
1040
  struct sidl_BaseInterface__object **_ex);
 
1041
 
 
1042
#ifdef __cplusplus
 
1043
}
 
1044
#endif
 
1045
#endif