1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.40
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGRUBY
12
13
14 #ifdef __cplusplus
15 /* SwigValueWrapper is described in swig.swg */
16 template<typename T> class SwigValueWrapper {
17 struct SwigMovePointer {
18 T *ptr;
SwigMovePointerSwigValueWrapper::SwigMovePointer19 SwigMovePointer(T *p) : ptr(p) { }
~SwigMovePointerSwigValueWrapper::SwigMovePointer20 ~SwigMovePointer() { delete ptr; }
operator =SwigValueWrapper::SwigMovePointer21 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
22 } pointer;
23 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
24 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
25 public:
SwigValueWrapper()26 SwigValueWrapper() : pointer(0) { }
operator =(const T & t)27 SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
operator T&() const28 operator T&() const { return *pointer.ptr; }
operator &()29 T *operator&() { return pointer.ptr; }
30 };
31
SwigValueInit()32 template <typename T> T SwigValueInit() {
33 return T();
34 }
35 #endif
36
37 /* -----------------------------------------------------------------------------
38 * This section contains generic SWIG labels for method/variable
39 * declarations/attributes, and other compiler dependent labels.
40 * ----------------------------------------------------------------------------- */
41
42 /* template workaround for compilers that cannot correctly implement the C++ standard */
43 #ifndef SWIGTEMPLATEDISAMBIGUATOR
44 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
45 # define SWIGTEMPLATEDISAMBIGUATOR template
46 # elif defined(__HP_aCC)
47 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
48 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
49 # define SWIGTEMPLATEDISAMBIGUATOR template
50 # else
51 # define SWIGTEMPLATEDISAMBIGUATOR
52 # endif
53 #endif
54
55 /* inline attribute */
56 #ifndef SWIGINLINE
57 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
58 # define SWIGINLINE inline
59 # else
60 # define SWIGINLINE
61 # endif
62 #endif
63
64 /* attribute recognised by some compilers to avoid 'unused' warnings */
65 #ifndef SWIGUNUSED
66 # if defined(__GNUC__)
67 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
68 # define SWIGUNUSED __attribute__ ((__unused__))
69 # else
70 # define SWIGUNUSED
71 # endif
72 # elif defined(__ICC)
73 # define SWIGUNUSED __attribute__ ((__unused__))
74 # else
75 # define SWIGUNUSED
76 # endif
77 #endif
78
79 #ifndef SWIG_MSC_UNSUPPRESS_4505
80 # if defined(_MSC_VER)
81 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
82 # endif
83 #endif
84
85 #ifndef SWIGUNUSEDPARM
86 # ifdef __cplusplus
87 # define SWIGUNUSEDPARM(p)
88 # else
89 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
90 # endif
91 #endif
92
93 /* internal SWIG method */
94 #ifndef SWIGINTERN
95 # define SWIGINTERN static SWIGUNUSED
96 #endif
97
98 /* internal inline SWIG method */
99 #ifndef SWIGINTERNINLINE
100 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
101 #endif
102
103 /* exporting methods */
104 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
105 # ifndef GCC_HASCLASSVISIBILITY
106 # define GCC_HASCLASSVISIBILITY
107 # endif
108 #endif
109
110 #ifndef SWIGEXPORT
111 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
112 # if defined(STATIC_LINKED)
113 # define SWIGEXPORT
114 # else
115 # define SWIGEXPORT __declspec(dllexport)
116 # endif
117 # else
118 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
119 # define SWIGEXPORT __attribute__ ((visibility("default")))
120 # else
121 # define SWIGEXPORT
122 # endif
123 # endif
124 #endif
125
126 /* calling conventions for Windows */
127 #ifndef SWIGSTDCALL
128 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
129 # define SWIGSTDCALL __stdcall
130 # else
131 # define SWIGSTDCALL
132 # endif
133 #endif
134
135 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
136 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
137 # define _CRT_SECURE_NO_DEPRECATE
138 #endif
139
140 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
141 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
142 # define _SCL_SECURE_NO_DEPRECATE
143 #endif
144
145
146 /* -----------------------------------------------------------------------------
147 * This section contains generic SWIG labels for method/variable
148 * declarations/attributes, and other compiler dependent labels.
149 * ----------------------------------------------------------------------------- */
150
151 /* template workaround for compilers that cannot correctly implement the C++ standard */
152 #ifndef SWIGTEMPLATEDISAMBIGUATOR
153 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
154 # define SWIGTEMPLATEDISAMBIGUATOR template
155 # elif defined(__HP_aCC)
156 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
157 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
158 # define SWIGTEMPLATEDISAMBIGUATOR template
159 # else
160 # define SWIGTEMPLATEDISAMBIGUATOR
161 # endif
162 #endif
163
164 /* inline attribute */
165 #ifndef SWIGINLINE
166 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
167 # define SWIGINLINE inline
168 # else
169 # define SWIGINLINE
170 # endif
171 #endif
172
173 /* attribute recognised by some compilers to avoid 'unused' warnings */
174 #ifndef SWIGUNUSED
175 # if defined(__GNUC__)
176 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
177 # define SWIGUNUSED __attribute__ ((__unused__))
178 # else
179 # define SWIGUNUSED
180 # endif
181 # elif defined(__ICC)
182 # define SWIGUNUSED __attribute__ ((__unused__))
183 # else
184 # define SWIGUNUSED
185 # endif
186 #endif
187
188 #ifndef SWIG_MSC_UNSUPPRESS_4505
189 # if defined(_MSC_VER)
190 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
191 # endif
192 #endif
193
194 #ifndef SWIGUNUSEDPARM
195 # ifdef __cplusplus
196 # define SWIGUNUSEDPARM(p)
197 # else
198 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
199 # endif
200 #endif
201
202 /* internal SWIG method */
203 #ifndef SWIGINTERN
204 # define SWIGINTERN static SWIGUNUSED
205 #endif
206
207 /* internal inline SWIG method */
208 #ifndef SWIGINTERNINLINE
209 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
210 #endif
211
212 /* exporting methods */
213 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
214 # ifndef GCC_HASCLASSVISIBILITY
215 # define GCC_HASCLASSVISIBILITY
216 # endif
217 #endif
218
219 #ifndef SWIGEXPORT
220 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
221 # if defined(STATIC_LINKED)
222 # define SWIGEXPORT
223 # else
224 # define SWIGEXPORT __declspec(dllexport)
225 # endif
226 # else
227 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
228 # define SWIGEXPORT __attribute__ ((visibility("default")))
229 # else
230 # define SWIGEXPORT
231 # endif
232 # endif
233 #endif
234
235 /* calling conventions for Windows */
236 #ifndef SWIGSTDCALL
237 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
238 # define SWIGSTDCALL __stdcall
239 # else
240 # define SWIGSTDCALL
241 # endif
242 #endif
243
244 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
245 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
246 # define _CRT_SECURE_NO_DEPRECATE
247 #endif
248
249 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
250 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
251 # define _SCL_SECURE_NO_DEPRECATE
252 #endif
253
254
255 /* -----------------------------------------------------------------------------
256 * swigrun.swg
257 *
258 * This file contains generic C API SWIG runtime support for pointer
259 * type checking.
260 * ----------------------------------------------------------------------------- */
261
262 /* This should only be incremented when either the layout of swig_type_info changes,
263 or for whatever reason, the runtime changes incompatibly */
264 #define SWIG_RUNTIME_VERSION "4"
265
266 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
267 #ifdef SWIG_TYPE_TABLE
268 # define SWIG_QUOTE_STRING(x) #x
269 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
270 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
271 #else
272 # define SWIG_TYPE_TABLE_NAME
273 #endif
274
275 /*
276 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
277 creating a static or dynamic library from the SWIG runtime code.
278 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
279
280 But only do this if strictly necessary, ie, if you have problems
281 with your compiler or suchlike.
282 */
283
284 #ifndef SWIGRUNTIME
285 # define SWIGRUNTIME SWIGINTERN
286 #endif
287
288 #ifndef SWIGRUNTIMEINLINE
289 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
290 #endif
291
292 /* Generic buffer size */
293 #ifndef SWIG_BUFFER_SIZE
294 # define SWIG_BUFFER_SIZE 1024
295 #endif
296
297 /* Flags for pointer conversions */
298 #define SWIG_POINTER_DISOWN 0x1
299 #define SWIG_CAST_NEW_MEMORY 0x2
300
301 /* Flags for new pointer objects */
302 #define SWIG_POINTER_OWN 0x1
303
304
305 /*
306 Flags/methods for returning states.
307
308 The SWIG conversion methods, as ConvertPtr, return and integer
309 that tells if the conversion was successful or not. And if not,
310 an error code can be returned (see swigerrors.swg for the codes).
311
312 Use the following macros/flags to set or process the returning
313 states.
314
315 In old versions of SWIG, code such as the following was usually written:
316
317 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
318 // success code
319 } else {
320 //fail code
321 }
322
323 Now you can be more explicit:
324
325 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
326 if (SWIG_IsOK(res)) {
327 // success code
328 } else {
329 // fail code
330 }
331
332 which is the same really, but now you can also do
333
334 Type *ptr;
335 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
336 if (SWIG_IsOK(res)) {
337 // success code
338 if (SWIG_IsNewObj(res) {
339 ...
340 delete *ptr;
341 } else {
342 ...
343 }
344 } else {
345 // fail code
346 }
347
348 I.e., now SWIG_ConvertPtr can return new objects and you can
349 identify the case and take care of the deallocation. Of course that
350 also requires SWIG_ConvertPtr to return new result values, such as
351
352 int SWIG_ConvertPtr(obj, ptr,...) {
353 if (<obj is ok>) {
354 if (<need new object>) {
355 *ptr = <ptr to new allocated object>;
356 return SWIG_NEWOBJ;
357 } else {
358 *ptr = <ptr to old object>;
359 return SWIG_OLDOBJ;
360 }
361 } else {
362 return SWIG_BADOBJ;
363 }
364 }
365
366 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
367 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
368 SWIG errors code.
369
370 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
371 allows to return the 'cast rank', for example, if you have this
372
373 int food(double)
374 int fooi(int);
375
376 and you call
377
378 food(1) // cast rank '1' (1 -> 1.0)
379 fooi(1) // cast rank '0'
380
381 just use the SWIG_AddCast()/SWIG_CheckState()
382 */
383
384 #define SWIG_OK (0)
385 #define SWIG_ERROR (-1)
386 #define SWIG_IsOK(r) (r >= 0)
387 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
388
389 /* The CastRankLimit says how many bits are used for the cast rank */
390 #define SWIG_CASTRANKLIMIT (1 << 8)
391 /* The NewMask denotes the object was created (using new/malloc) */
392 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
393 /* The TmpMask is for in/out typemaps that use temporal objects */
394 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
395 /* Simple returning values */
396 #define SWIG_BADOBJ (SWIG_ERROR)
397 #define SWIG_OLDOBJ (SWIG_OK)
398 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
399 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
400 /* Check, add and del mask methods */
401 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
402 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
403 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
404 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
405 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
406 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
407
408 /* Cast-Rank Mode */
409 #if defined(SWIG_CASTRANK_MODE)
410 # ifndef SWIG_TypeRank
411 # define SWIG_TypeRank unsigned long
412 # endif
413 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
414 # define SWIG_MAXCASTRANK (2)
415 # endif
416 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
417 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIG_AddCast(int r)418 SWIGINTERNINLINE int SWIG_AddCast(int r) {
419 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
420 }
SWIG_CheckState(int r)421 SWIGINTERNINLINE int SWIG_CheckState(int r) {
422 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
423 }
424 #else /* no cast-rank mode */
425 # define SWIG_AddCast
426 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
427 #endif
428
429
430 #include <string.h>
431
432 #ifdef __cplusplus
433 extern "C" {
434 #endif
435
436 typedef void *(*swig_converter_func)(void *, int *);
437 typedef struct swig_type_info *(*swig_dycast_func)(void **);
438
439 /* Structure to store information on one type */
440 typedef struct swig_type_info {
441 const char *name; /* mangled name of this type */
442 const char *str; /* human readable name of this type */
443 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
444 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
445 void *clientdata; /* language specific type data */
446 int owndata; /* flag if the structure owns the clientdata */
447 } swig_type_info;
448
449 /* Structure to store a type and conversion function used for casting */
450 typedef struct swig_cast_info {
451 swig_type_info *type; /* pointer to type that is equivalent to this type */
452 swig_converter_func converter; /* function to cast the void pointers */
453 struct swig_cast_info *next; /* pointer to next cast in linked list */
454 struct swig_cast_info *prev; /* pointer to the previous cast */
455 } swig_cast_info;
456
457 /* Structure used to store module information
458 * Each module generates one structure like this, and the runtime collects
459 * all of these structures and stores them in a circularly linked list.*/
460 typedef struct swig_module_info {
461 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
462 size_t size; /* Number of types in this module */
463 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
464 swig_type_info **type_initial; /* Array of initially generated type structures */
465 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
466 void *clientdata; /* Language specific module data */
467 } swig_module_info;
468
469 /*
470 Compare two type names skipping the space characters, therefore
471 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
472
473 Return 0 when the two name types are equivalent, as in
474 strncmp, but skipping ' '.
475 */
476 SWIGRUNTIME int
SWIG_TypeNameComp(const char * f1,const char * l1,const char * f2,const char * l2)477 SWIG_TypeNameComp(const char *f1, const char *l1,
478 const char *f2, const char *l2) {
479 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
480 while ((*f1 == ' ') && (f1 != l1)) ++f1;
481 while ((*f2 == ' ') && (f2 != l2)) ++f2;
482 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
483 }
484 return (int)((l1 - f1) - (l2 - f2));
485 }
486
487 /*
488 Check type equivalence in a name list like <name1>|<name2>|...
489 Return 0 if not equal, 1 if equal
490 */
491 SWIGRUNTIME int
SWIG_TypeEquiv(const char * nb,const char * tb)492 SWIG_TypeEquiv(const char *nb, const char *tb) {
493 int equiv = 0;
494 const char* te = tb + strlen(tb);
495 const char* ne = nb;
496 while (!equiv && *ne) {
497 for (nb = ne; *ne; ++ne) {
498 if (*ne == '|') break;
499 }
500 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
501 if (*ne) ++ne;
502 }
503 return equiv;
504 }
505
506 /*
507 Check type equivalence in a name list like <name1>|<name2>|...
508 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
509 */
510 SWIGRUNTIME int
SWIG_TypeCompare(const char * nb,const char * tb)511 SWIG_TypeCompare(const char *nb, const char *tb) {
512 int equiv = 0;
513 const char* te = tb + strlen(tb);
514 const char* ne = nb;
515 while (!equiv && *ne) {
516 for (nb = ne; *ne; ++ne) {
517 if (*ne == '|') break;
518 }
519 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
520 if (*ne) ++ne;
521 }
522 return equiv;
523 }
524
525
526 /*
527 Check the typename
528 */
529 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char * c,swig_type_info * ty)530 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
531 if (ty) {
532 swig_cast_info *iter = ty->cast;
533 while (iter) {
534 if (strcmp(iter->type->name, c) == 0) {
535 if (iter == ty->cast)
536 return iter;
537 /* Move iter to the top of the linked list */
538 iter->prev->next = iter->next;
539 if (iter->next)
540 iter->next->prev = iter->prev;
541 iter->next = ty->cast;
542 iter->prev = 0;
543 if (ty->cast) ty->cast->prev = iter;
544 ty->cast = iter;
545 return iter;
546 }
547 iter = iter->next;
548 }
549 }
550 return 0;
551 }
552
553 /*
554 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
555 */
556 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info * from,swig_type_info * ty)557 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
558 if (ty) {
559 swig_cast_info *iter = ty->cast;
560 while (iter) {
561 if (iter->type == from) {
562 if (iter == ty->cast)
563 return iter;
564 /* Move iter to the top of the linked list */
565 iter->prev->next = iter->next;
566 if (iter->next)
567 iter->next->prev = iter->prev;
568 iter->next = ty->cast;
569 iter->prev = 0;
570 if (ty->cast) ty->cast->prev = iter;
571 ty->cast = iter;
572 return iter;
573 }
574 iter = iter->next;
575 }
576 }
577 return 0;
578 }
579
580 /*
581 Cast a pointer up an inheritance hierarchy
582 */
583 SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info * ty,void * ptr,int * newmemory)584 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
585 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
586 }
587
588 /*
589 Dynamic pointer casting. Down an inheritance hierarchy
590 */
591 SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info * ty,void ** ptr)592 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
593 swig_type_info *lastty = ty;
594 if (!ty || !ty->dcast) return ty;
595 while (ty && (ty->dcast)) {
596 ty = (*ty->dcast)(ptr);
597 if (ty) lastty = ty;
598 }
599 return lastty;
600 }
601
602 /*
603 Return the name associated with this type
604 */
605 SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info * ty)606 SWIG_TypeName(const swig_type_info *ty) {
607 return ty->name;
608 }
609
610 /*
611 Return the pretty name associated with this type,
612 that is an unmangled type name in a form presentable to the user.
613 */
614 SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info * type)615 SWIG_TypePrettyName(const swig_type_info *type) {
616 /* The "str" field contains the equivalent pretty names of the
617 type, separated by vertical-bar characters. We choose
618 to print the last name, as it is often (?) the most
619 specific. */
620 if (!type) return NULL;
621 if (type->str != NULL) {
622 const char *last_name = type->str;
623 const char *s;
624 for (s = type->str; *s; s++)
625 if (*s == '|') last_name = s+1;
626 return last_name;
627 }
628 else
629 return type->name;
630 }
631
632 /*
633 Set the clientdata field for a type
634 */
635 SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info * ti,void * clientdata)636 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
637 swig_cast_info *cast = ti->cast;
638 /* if (ti->clientdata == clientdata) return; */
639 ti->clientdata = clientdata;
640
641 while (cast) {
642 if (!cast->converter) {
643 swig_type_info *tc = cast->type;
644 if (!tc->clientdata) {
645 SWIG_TypeClientData(tc, clientdata);
646 }
647 }
648 cast = cast->next;
649 }
650 }
651 SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info * ti,void * clientdata)652 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
653 SWIG_TypeClientData(ti, clientdata);
654 ti->owndata = 1;
655 }
656
657 /*
658 Search for a swig_type_info structure only by mangled name
659 Search is a O(log #types)
660
661 We start searching at module start, and finish searching when start == end.
662 Note: if start == end at the beginning of the function, we go all the way around
663 the circular list.
664 */
665 SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)666 SWIG_MangledTypeQueryModule(swig_module_info *start,
667 swig_module_info *end,
668 const char *name) {
669 swig_module_info *iter = start;
670 do {
671 if (iter->size) {
672 register size_t l = 0;
673 register size_t r = iter->size - 1;
674 do {
675 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
676 register size_t i = (l + r) >> 1;
677 const char *iname = iter->types[i]->name;
678 if (iname) {
679 register int compare = strcmp(name, iname);
680 if (compare == 0) {
681 return iter->types[i];
682 } else if (compare < 0) {
683 if (i) {
684 r = i - 1;
685 } else {
686 break;
687 }
688 } else if (compare > 0) {
689 l = i + 1;
690 }
691 } else {
692 break; /* should never happen */
693 }
694 } while (l <= r);
695 }
696 iter = iter->next;
697 } while (iter != end);
698 return 0;
699 }
700
701 /*
702 Search for a swig_type_info structure for either a mangled name or a human readable name.
703 It first searches the mangled names of the types, which is a O(log #types)
704 If a type is not found it then searches the human readable names, which is O(#types).
705
706 We start searching at module start, and finish searching when start == end.
707 Note: if start == end at the beginning of the function, we go all the way around
708 the circular list.
709 */
710 SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)711 SWIG_TypeQueryModule(swig_module_info *start,
712 swig_module_info *end,
713 const char *name) {
714 /* STEP 1: Search the name field using binary search */
715 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
716 if (ret) {
717 return ret;
718 } else {
719 /* STEP 2: If the type hasn't been found, do a complete search
720 of the str field (the human readable name) */
721 swig_module_info *iter = start;
722 do {
723 register size_t i = 0;
724 for (; i < iter->size; ++i) {
725 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
726 return iter->types[i];
727 }
728 iter = iter->next;
729 } while (iter != end);
730 }
731
732 /* neither found a match */
733 return 0;
734 }
735
736 /*
737 Pack binary data into a string
738 */
739 SWIGRUNTIME char *
SWIG_PackData(char * c,void * ptr,size_t sz)740 SWIG_PackData(char *c, void *ptr, size_t sz) {
741 static const char hex[17] = "0123456789abcdef";
742 register const unsigned char *u = (unsigned char *) ptr;
743 register const unsigned char *eu = u + sz;
744 for (; u != eu; ++u) {
745 register unsigned char uu = *u;
746 *(c++) = hex[(uu & 0xf0) >> 4];
747 *(c++) = hex[uu & 0xf];
748 }
749 return c;
750 }
751
752 /*
753 Unpack binary data from a string
754 */
755 SWIGRUNTIME const char *
SWIG_UnpackData(const char * c,void * ptr,size_t sz)756 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
757 register unsigned char *u = (unsigned char *) ptr;
758 register const unsigned char *eu = u + sz;
759 for (; u != eu; ++u) {
760 register char d = *(c++);
761 register unsigned char uu;
762 if ((d >= '0') && (d <= '9'))
763 uu = ((d - '0') << 4);
764 else if ((d >= 'a') && (d <= 'f'))
765 uu = ((d - ('a'-10)) << 4);
766 else
767 return (char *) 0;
768 d = *(c++);
769 if ((d >= '0') && (d <= '9'))
770 uu |= (d - '0');
771 else if ((d >= 'a') && (d <= 'f'))
772 uu |= (d - ('a'-10));
773 else
774 return (char *) 0;
775 *u = uu;
776 }
777 return c;
778 }
779
780 /*
781 Pack 'void *' into a string buffer.
782 */
783 SWIGRUNTIME char *
SWIG_PackVoidPtr(char * buff,void * ptr,const char * name,size_t bsz)784 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
785 char *r = buff;
786 if ((2*sizeof(void *) + 2) > bsz) return 0;
787 *(r++) = '_';
788 r = SWIG_PackData(r,&ptr,sizeof(void *));
789 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
790 strcpy(r,name);
791 return buff;
792 }
793
794 SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char * c,void ** ptr,const char * name)795 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
796 if (*c != '_') {
797 if (strcmp(c,"NULL") == 0) {
798 *ptr = (void *) 0;
799 return name;
800 } else {
801 return 0;
802 }
803 }
804 return SWIG_UnpackData(++c,ptr,sizeof(void *));
805 }
806
807 SWIGRUNTIME char *
SWIG_PackDataName(char * buff,void * ptr,size_t sz,const char * name,size_t bsz)808 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
809 char *r = buff;
810 size_t lname = (name ? strlen(name) : 0);
811 if ((2*sz + 2 + lname) > bsz) return 0;
812 *(r++) = '_';
813 r = SWIG_PackData(r,ptr,sz);
814 if (lname) {
815 strncpy(r,name,lname+1);
816 } else {
817 *r = 0;
818 }
819 return buff;
820 }
821
822 SWIGRUNTIME const char *
SWIG_UnpackDataName(const char * c,void * ptr,size_t sz,const char * name)823 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
824 if (*c != '_') {
825 if (strcmp(c,"NULL") == 0) {
826 memset(ptr,0,sz);
827 return name;
828 } else {
829 return 0;
830 }
831 }
832 return SWIG_UnpackData(++c,ptr,sz);
833 }
834
835 #ifdef __cplusplus
836 }
837 #endif
838
839 /* Errors in SWIG */
840 #define SWIG_UnknownError -1
841 #define SWIG_IOError -2
842 #define SWIG_RuntimeError -3
843 #define SWIG_IndexError -4
844 #define SWIG_TypeError -5
845 #define SWIG_DivisionByZero -6
846 #define SWIG_OverflowError -7
847 #define SWIG_SyntaxError -8
848 #define SWIG_ValueError -9
849 #define SWIG_SystemError -10
850 #define SWIG_AttributeError -11
851 #define SWIG_MemoryError -12
852 #define SWIG_NullReferenceError -13
853
854
855
856 #include <ruby.h>
857
858 /* Remove global macros defined in Ruby's win32.h */
859 #ifdef write
860 # undef write
861 #endif
862 #ifdef read
863 # undef read
864 #endif
865 #ifdef bind
866 # undef bind
867 #endif
868 #ifdef close
869 # undef close
870 #endif
871 #ifdef connect
872 # undef connect
873 #endif
874
875
876 /* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
877 #ifndef NUM2LL
878 #define NUM2LL(x) NUM2LONG((x))
879 #endif
880 #ifndef LL2NUM
881 #define LL2NUM(x) INT2NUM((long) (x))
882 #endif
883 #ifndef ULL2NUM
884 #define ULL2NUM(x) UINT2NUM((unsigned long) (x))
885 #endif
886
887 /* Ruby 1.7 doesn't (yet) define NUM2ULL() */
888 #ifndef NUM2ULL
889 #ifdef HAVE_LONG_LONG
890 #define NUM2ULL(x) rb_num2ull((x))
891 #else
892 #define NUM2ULL(x) NUM2ULONG(x)
893 #endif
894 #endif
895
896 /* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
897 /* Define these for older versions so we can just write code the new way */
898 #ifndef RSTRING_LEN
899 # define RSTRING_LEN(x) RSTRING(x)->len
900 #endif
901 #ifndef RSTRING_PTR
902 # define RSTRING_PTR(x) RSTRING(x)->ptr
903 #endif
904 #ifndef RSTRING_END
905 # define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
906 #endif
907 #ifndef RARRAY_LEN
908 # define RARRAY_LEN(x) RARRAY(x)->len
909 #endif
910 #ifndef RARRAY_PTR
911 # define RARRAY_PTR(x) RARRAY(x)->ptr
912 #endif
913 #ifndef RFLOAT_VALUE
914 # define RFLOAT_VALUE(x) RFLOAT(x)->value
915 #endif
916 #ifndef DOUBLE2NUM
917 # define DOUBLE2NUM(x) rb_float_new(x)
918 #endif
919 #ifndef RHASH_TBL
920 # define RHASH_TBL(x) (RHASH(x)->tbl)
921 #endif
922 #ifndef RHASH_ITER_LEV
923 # define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
924 #endif
925 #ifndef RHASH_IFNONE
926 # define RHASH_IFNONE(x) (RHASH(x)->ifnone)
927 #endif
928 #ifndef RHASH_SIZE
929 # define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
930 #endif
931 #ifndef RHASH_EMPTY_P
932 # define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
933 #endif
934 #ifndef RSTRUCT_LEN
935 # define RSTRUCT_LEN(x) RSTRUCT(x)->len
936 #endif
937 #ifndef RSTRUCT_PTR
938 # define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
939 #endif
940
941
942
943 /*
944 * Need to be very careful about how these macros are defined, especially
945 * when compiling C++ code or C code with an ANSI C compiler.
946 *
947 * VALUEFUNC(f) is a macro used to typecast a C function that implements
948 * a Ruby method so that it can be passed as an argument to API functions
949 * like rb_define_method() and rb_define_singleton_method().
950 *
951 * VOIDFUNC(f) is a macro used to typecast a C function that implements
952 * either the "mark" or "free" stuff for a Ruby Data object, so that it
953 * can be passed as an argument to API functions like Data_Wrap_Struct()
954 * and Data_Make_Struct().
955 */
956
957 #ifdef __cplusplus
958 # ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
959 # define PROTECTFUNC(f) ((VALUE (*)()) f)
960 # define VALUEFUNC(f) ((VALUE (*)()) f)
961 # define VOIDFUNC(f) ((void (*)()) f)
962 # else
963 # ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
964 # define PROTECTFUNC(f) ((VALUE (*)()) f)
965 # define VALUEFUNC(f) ((VALUE (*)()) f)
966 # define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
967 # else /* These definitions should work for Ruby 1.7+ */
968 # define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
969 # define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
970 # define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
971 # endif
972 # endif
973 #else
974 # define VALUEFUNC(f) (f)
975 # define VOIDFUNC(f) (f)
976 #endif
977
978 /* Don't use for expressions have side effect */
979 #ifndef RB_STRING_VALUE
980 #define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
981 #endif
982 #ifndef StringValue
983 #define StringValue(s) RB_STRING_VALUE(s)
984 #endif
985 #ifndef StringValuePtr
986 #define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
987 #endif
988 #ifndef StringValueLen
989 #define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
990 #endif
991 #ifndef SafeStringValue
992 #define SafeStringValue(v) do {\
993 StringValue(v);\
994 rb_check_safe_str(v);\
995 } while (0)
996 #endif
997
998 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
999 #define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
1000 #define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
1001 #endif
1002
1003 static VALUE _mSWIG = Qnil;
1004
1005 /* -----------------------------------------------------------------------------
1006 * error manipulation
1007 * ----------------------------------------------------------------------------- */
1008
1009
1010 /* Define some additional error types */
1011 #define SWIG_ObjectPreviouslyDeletedError -100
1012
1013
1014 /* Define custom exceptions for errors that do not map to existing Ruby
1015 exceptions. Note this only works for C++ since a global cannot be
1016 initialized by a funtion in C. For C, fallback to rb_eRuntimeError.*/
1017
1018 SWIGINTERN VALUE
getNullReferenceError(void)1019 getNullReferenceError(void) {
1020 static int init = 0;
1021 static VALUE rb_eNullReferenceError ;
1022 if (!init) {
1023 init = 1;
1024 rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
1025 }
1026 return rb_eNullReferenceError;
1027 }
1028
1029 SWIGINTERN VALUE
getObjectPreviouslyDeletedError(void)1030 getObjectPreviouslyDeletedError(void) {
1031 static int init = 0;
1032 static VALUE rb_eObjectPreviouslyDeleted ;
1033 if (!init) {
1034 init = 1;
1035 rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
1036 }
1037 return rb_eObjectPreviouslyDeleted;
1038 }
1039
1040
1041 SWIGINTERN VALUE
SWIG_Ruby_ErrorType(int SWIG_code)1042 SWIG_Ruby_ErrorType(int SWIG_code) {
1043 VALUE type;
1044 switch (SWIG_code) {
1045 case SWIG_MemoryError:
1046 type = rb_eNoMemError;
1047 break;
1048 case SWIG_IOError:
1049 type = rb_eIOError;
1050 break;
1051 case SWIG_RuntimeError:
1052 type = rb_eRuntimeError;
1053 break;
1054 case SWIG_IndexError:
1055 type = rb_eIndexError;
1056 break;
1057 case SWIG_TypeError:
1058 type = rb_eTypeError;
1059 break;
1060 case SWIG_DivisionByZero:
1061 type = rb_eZeroDivError;
1062 break;
1063 case SWIG_OverflowError:
1064 type = rb_eRangeError;
1065 break;
1066 case SWIG_SyntaxError:
1067 type = rb_eSyntaxError;
1068 break;
1069 case SWIG_ValueError:
1070 type = rb_eArgError;
1071 break;
1072 case SWIG_SystemError:
1073 type = rb_eFatal;
1074 break;
1075 case SWIG_AttributeError:
1076 type = rb_eRuntimeError;
1077 break;
1078 case SWIG_NullReferenceError:
1079 type = getNullReferenceError();
1080 break;
1081 case SWIG_ObjectPreviouslyDeletedError:
1082 type = getObjectPreviouslyDeletedError();
1083 break;
1084 case SWIG_UnknownError:
1085 type = rb_eRuntimeError;
1086 break;
1087 default:
1088 type = rb_eRuntimeError;
1089 }
1090 return type;
1091 }
1092
1093
1094 /* This function is called when a user inputs a wrong argument to
1095 a method.
1096 */
1097 SWIGINTERN
Ruby_Format_TypeError(const char * msg,const char * type,const char * name,const int argn,VALUE input)1098 const char* Ruby_Format_TypeError( const char* msg,
1099 const char* type,
1100 const char* name,
1101 const int argn,
1102 VALUE input )
1103 {
1104 char buf[128];
1105 VALUE str;
1106 VALUE asStr;
1107 if ( msg && *msg )
1108 {
1109 str = rb_str_new2(msg);
1110 }
1111 else
1112 {
1113 str = rb_str_new(NULL, 0);
1114 }
1115
1116 str = rb_str_cat2( str, "Expected argument " );
1117 sprintf( buf, "%d of type ", argn-1 );
1118 str = rb_str_cat2( str, buf );
1119 str = rb_str_cat2( str, type );
1120 str = rb_str_cat2( str, ", but got " );
1121 str = rb_str_cat2( str, rb_obj_classname(input) );
1122 str = rb_str_cat2( str, " " );
1123 asStr = rb_inspect(input);
1124 if ( RSTRING_LEN(asStr) > 30 )
1125 {
1126 str = rb_str_cat( str, StringValuePtr(asStr), 30 );
1127 str = rb_str_cat2( str, "..." );
1128 }
1129 else
1130 {
1131 str = rb_str_append( str, asStr );
1132 }
1133
1134 if ( name )
1135 {
1136 str = rb_str_cat2( str, "\n\tin SWIG method '" );
1137 str = rb_str_cat2( str, name );
1138 str = rb_str_cat2( str, "'" );
1139 }
1140
1141 return StringValuePtr( str );
1142 }
1143
1144 /* This function is called when an overloaded method fails */
1145 SWIGINTERN
Ruby_Format_OverloadedError(const int argc,const int maxargs,const char * method,const char * prototypes)1146 void Ruby_Format_OverloadedError(
1147 const int argc,
1148 const int maxargs,
1149 const char* method,
1150 const char* prototypes
1151 )
1152 {
1153 const char* msg = "Wrong # of arguments";
1154 if ( argc <= maxargs ) msg = "Wrong arguments";
1155 rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"
1156 "Possible C/C++ prototypes are:\n%s",
1157 msg, method, prototypes);
1158 }
1159
1160 /* -----------------------------------------------------------------------------
1161 * See the LICENSE file for information on copyright, usage and redistribution
1162 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1163 *
1164 * rubytracking.swg
1165 *
1166 * This file contains support for tracking mappings from
1167 * Ruby objects to C++ objects. This functionality is needed
1168 * to implement mark functions for Ruby's mark and sweep
1169 * garbage collector.
1170 * ----------------------------------------------------------------------------- */
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #endif
1175
1176 /* Ruby 1.8 actually assumes the first case. */
1177 #if SIZEOF_VOIDP == SIZEOF_LONG
1178 # define SWIG2NUM(v) LONG2NUM((unsigned long)v)
1179 # define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
1180 #elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
1181 # define SWIG2NUM(v) LL2NUM((unsigned long long)v)
1182 # define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
1183 #else
1184 # error sizeof(void*) is not the same as long or long long
1185 #endif
1186
1187
1188 /* Global Ruby hash table to store Trackings from C/C++
1189 structs to Ruby Objects.
1190 */
1191 static VALUE swig_ruby_trackings = Qnil;
1192
1193 /* Global variable that stores a reference to the ruby
1194 hash table delete function. */
1195 static ID swig_ruby_hash_delete;
1196
1197 /* Setup a Ruby hash table to store Trackings */
SWIG_RubyInitializeTrackings(void)1198 SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
1199 /* Create a ruby hash table to store Trackings from C++
1200 objects to Ruby objects. */
1201
1202 /* Try to see if some other .so has already created a
1203 tracking hash table, which we keep hidden in an instance var
1204 in the SWIG module.
1205 This is done to allow multiple DSOs to share the same
1206 tracking table.
1207 */
1208 ID trackings_id = rb_intern( "@__trackings__" );
1209 VALUE verbose = rb_gv_get("VERBOSE");
1210 rb_gv_set("VERBOSE", Qfalse);
1211 swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
1212 rb_gv_set("VERBOSE", verbose);
1213
1214 /* No, it hasn't. Create one ourselves */
1215 if ( swig_ruby_trackings == Qnil )
1216 {
1217 swig_ruby_trackings = rb_hash_new();
1218 rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
1219 }
1220
1221 /* Now store a reference to the hash table delete function
1222 so that we only have to look it up once.*/
1223 swig_ruby_hash_delete = rb_intern("delete");
1224 }
1225
1226 /* Get a Ruby number to reference a pointer */
SWIG_RubyPtrToReference(void * ptr)1227 SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
1228 /* We cast the pointer to an unsigned long
1229 and then store a reference to it using
1230 a Ruby number object. */
1231
1232 /* Convert the pointer to a Ruby number */
1233 return SWIG2NUM(ptr);
1234 }
1235
1236 /* Get a Ruby number to reference an object */
SWIG_RubyObjectToReference(VALUE object)1237 SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
1238 /* We cast the object to an unsigned long
1239 and then store a reference to it using
1240 a Ruby number object. */
1241
1242 /* Convert the Object to a Ruby number */
1243 return SWIG2NUM(object);
1244 }
1245
1246 /* Get a Ruby object from a previously stored reference */
SWIG_RubyReferenceToObject(VALUE reference)1247 SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
1248 /* The provided Ruby number object is a reference
1249 to the Ruby object we want.*/
1250
1251 /* Convert the Ruby number to a Ruby object */
1252 return NUM2SWIG(reference);
1253 }
1254
1255 /* Add a Tracking from a C/C++ struct to a Ruby object */
SWIG_RubyAddTracking(void * ptr,VALUE object)1256 SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
1257 /* In a Ruby hash table we store the pointer and
1258 the associated Ruby object. The trick here is
1259 that we cannot store the Ruby object directly - if
1260 we do then it cannot be garbage collected. So
1261 instead we typecast it as a unsigned long and
1262 convert it to a Ruby number object.*/
1263
1264 /* Get a reference to the pointer as a Ruby number */
1265 VALUE key = SWIG_RubyPtrToReference(ptr);
1266
1267 /* Get a reference to the Ruby object as a Ruby number */
1268 VALUE value = SWIG_RubyObjectToReference(object);
1269
1270 /* Store the mapping to the global hash table. */
1271 rb_hash_aset(swig_ruby_trackings, key, value);
1272 }
1273
1274 /* Get the Ruby object that owns the specified C/C++ struct */
SWIG_RubyInstanceFor(void * ptr)1275 SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
1276 /* Get a reference to the pointer as a Ruby number */
1277 VALUE key = SWIG_RubyPtrToReference(ptr);
1278
1279 /* Now lookup the value stored in the global hash table */
1280 VALUE value = rb_hash_aref(swig_ruby_trackings, key);
1281
1282 if (value == Qnil) {
1283 /* No object exists - return nil. */
1284 return Qnil;
1285 }
1286 else {
1287 /* Convert this value to Ruby object */
1288 return SWIG_RubyReferenceToObject(value);
1289 }
1290 }
1291
1292 /* Remove a Tracking from a C/C++ struct to a Ruby object. It
1293 is very important to remove objects once they are destroyed
1294 since the same memory address may be reused later to create
1295 a new object. */
SWIG_RubyRemoveTracking(void * ptr)1296 SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
1297 /* Get a reference to the pointer as a Ruby number */
1298 VALUE key = SWIG_RubyPtrToReference(ptr);
1299
1300 /* Delete the object from the hash table by calling Ruby's
1301 do this we need to call the Hash.delete method.*/
1302 rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
1303 }
1304
1305 /* This is a helper method that unlinks a Ruby object from its
1306 underlying C++ object. This is needed if the lifetime of the
1307 Ruby object is longer than the C++ object */
SWIG_RubyUnlinkObjects(void * ptr)1308 SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
1309 VALUE object = SWIG_RubyInstanceFor(ptr);
1310
1311 if (object != Qnil) {
1312 DATA_PTR(object) = 0;
1313 }
1314 }
1315
1316
1317 #ifdef __cplusplus
1318 }
1319 #endif
1320
1321 /* -----------------------------------------------------------------------------
1322 * Ruby API portion that goes into the runtime
1323 * ----------------------------------------------------------------------------- */
1324
1325 #ifdef __cplusplus
1326 extern "C" {
1327 #endif
1328
1329 SWIGINTERN VALUE
SWIG_Ruby_AppendOutput(VALUE target,VALUE o)1330 SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
1331 if (NIL_P(target)) {
1332 target = o;
1333 } else {
1334 if (TYPE(target) != T_ARRAY) {
1335 VALUE o2 = target;
1336 target = rb_ary_new();
1337 rb_ary_push(target, o2);
1338 }
1339 rb_ary_push(target, o);
1340 }
1341 return target;
1342 }
1343
1344 /* For ruby1.8.4 and earlier. */
1345 #ifndef RUBY_INIT_STACK
1346 RUBY_EXTERN void Init_stack(VALUE* addr);
1347 # define RUBY_INIT_STACK \
1348 VALUE variable_in_this_stack_frame; \
1349 Init_stack(&variable_in_this_stack_frame);
1350 #endif
1351
1352
1353 #ifdef __cplusplus
1354 }
1355 #endif
1356
1357
1358 /* -----------------------------------------------------------------------------
1359 * See the LICENSE file for information on copyright, usage and redistribution
1360 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1361 *
1362 * rubyrun.swg
1363 *
1364 * This file contains the runtime support for Ruby modules
1365 * and includes code for managing global variables and pointer
1366 * type checking.
1367 * ----------------------------------------------------------------------------- */
1368
1369 /* For backward compatibility only */
1370 #define SWIG_POINTER_EXCEPTION 0
1371
1372 /* for raw pointers */
1373 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1374 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1375 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
1376 #define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own)
1377 #define swig_owntype ruby_owntype
1378
1379 /* for raw packed data */
1380 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
1381 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1382
1383 /* for class or struct pointers */
1384 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1385 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1386
1387 /* for C or C++ function pointers */
1388 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
1389 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
1390
1391 /* for C++ member pointers, ie, member methods */
1392 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
1393 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1394
1395
1396 /* Runtime API */
1397
1398 #define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule()
1399 #define SWIG_SetModule(clientdata, pointer) SWIG_Ruby_SetModule(pointer)
1400
1401
1402 /* Error manipulation */
1403
1404 #define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code)
1405 #define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), msg)
1406 #define SWIG_fail goto fail
1407
1408
1409 /* Ruby-specific SWIG API */
1410
1411 #define SWIG_InitRuntime() SWIG_Ruby_InitRuntime()
1412 #define SWIG_define_class(ty) SWIG_Ruby_define_class(ty)
1413 #define SWIG_NewClassInstance(value, ty) SWIG_Ruby_NewClassInstance(value, ty)
1414 #define SWIG_MangleStr(value) SWIG_Ruby_MangleStr(value)
1415 #define SWIG_CheckConvert(value, ty) SWIG_Ruby_CheckConvert(value, ty)
1416
1417 #include "assert.h"
1418
1419 /* -----------------------------------------------------------------------------
1420 * pointers/data manipulation
1421 * ----------------------------------------------------------------------------- */
1422
1423 #ifdef __cplusplus
1424 extern "C" {
1425 #endif
1426
1427 typedef struct {
1428 VALUE klass;
1429 VALUE mImpl;
1430 void (*mark)(void *);
1431 void (*destroy)(void *);
1432 int trackObjects;
1433 } swig_class;
1434
1435
1436 /* Global pointer used to keep some internal SWIG stuff */
1437 static VALUE _cSWIG_Pointer = Qnil;
1438 static VALUE swig_runtime_data_type_pointer = Qnil;
1439
1440 /* Global IDs used to keep some internal SWIG stuff */
1441 static ID swig_arity_id = 0;
1442 static ID swig_call_id = 0;
1443
1444 /*
1445 If your swig extension is to be run within an embedded ruby and has
1446 director callbacks, you should set -DRUBY_EMBEDDED during compilation.
1447 This will reset ruby's stack frame on each entry point from the main
1448 program the first time a virtual director function is invoked (in a
1449 non-recursive way).
1450 If this is not done, you run the risk of Ruby trashing the stack.
1451 */
1452
1453 #ifdef RUBY_EMBEDDED
1454
1455 # define SWIG_INIT_STACK \
1456 if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
1457 ++swig_virtual_calls;
1458 # define SWIG_RELEASE_STACK --swig_virtual_calls;
1459 # define Ruby_DirectorTypeMismatchException(x) \
1460 rb_raise( rb_eTypeError, x ); return c_result;
1461
1462 static unsigned int swig_virtual_calls = 0;
1463
1464 #else /* normal non-embedded extension */
1465
1466 # define SWIG_INIT_STACK
1467 # define SWIG_RELEASE_STACK
1468 # define Ruby_DirectorTypeMismatchException(x) \
1469 throw Swig::DirectorTypeMismatchException( x );
1470
1471 #endif /* RUBY_EMBEDDED */
1472
1473
1474 SWIGRUNTIME VALUE
getExceptionClass(void)1475 getExceptionClass(void) {
1476 static int init = 0;
1477 static VALUE rubyExceptionClass ;
1478 if (!init) {
1479 init = 1;
1480 rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
1481 }
1482 return rubyExceptionClass;
1483 }
1484
1485 /* This code checks to see if the Ruby object being raised as part
1486 of an exception inherits from the Ruby class Exception. If so,
1487 the object is simply returned. If not, then a new Ruby exception
1488 object is created and that will be returned to Ruby.*/
1489 SWIGRUNTIME VALUE
SWIG_Ruby_ExceptionType(swig_type_info * desc,VALUE obj)1490 SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
1491 VALUE exceptionClass = getExceptionClass();
1492 if (rb_obj_is_kind_of(obj, exceptionClass)) {
1493 return obj;
1494 } else {
1495 return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
1496 }
1497 }
1498
1499 /* Initialize Ruby runtime support */
1500 SWIGRUNTIME void
SWIG_Ruby_InitRuntime(void)1501 SWIG_Ruby_InitRuntime(void)
1502 {
1503 if (_mSWIG == Qnil) {
1504 _mSWIG = rb_define_module("SWIG");
1505 swig_call_id = rb_intern("call");
1506 swig_arity_id = rb_intern("arity");
1507 }
1508 }
1509
1510 /* Define Ruby class for C type */
1511 SWIGRUNTIME void
SWIG_Ruby_define_class(swig_type_info * type)1512 SWIG_Ruby_define_class(swig_type_info *type)
1513 {
1514 VALUE klass;
1515 char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1516 sprintf(klass_name, "TYPE%s", type->name);
1517 if (NIL_P(_cSWIG_Pointer)) {
1518 _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
1519 rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
1520 }
1521 klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
1522 free((void *) klass_name);
1523 }
1524
1525 /* Create a new pointer object */
1526 SWIGRUNTIME VALUE
SWIG_Ruby_NewPointerObj(void * ptr,swig_type_info * type,int flags)1527 SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
1528 {
1529 int own = flags & SWIG_POINTER_OWN;
1530 int track;
1531 char *klass_name;
1532 swig_class *sklass;
1533 VALUE klass;
1534 VALUE obj;
1535
1536 if (!ptr)
1537 return Qnil;
1538
1539 if (type->clientdata) {
1540 sklass = (swig_class *) type->clientdata;
1541
1542 /* Are we tracking this class and have we already returned this Ruby object? */
1543 track = sklass->trackObjects;
1544 if (track) {
1545 obj = SWIG_RubyInstanceFor(ptr);
1546
1547 /* Check the object's type and make sure it has the correct type.
1548 It might not in cases where methods do things like
1549 downcast methods. */
1550 if (obj != Qnil) {
1551 VALUE value = rb_iv_get(obj, "@__swigtype__");
1552 char* type_name = RSTRING_PTR(value);
1553
1554 if (strcmp(type->name, type_name) == 0) {
1555 return obj;
1556 }
1557 }
1558 }
1559
1560 /* Create a new Ruby object */
1561 obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark),
1562 ( own ? VOIDFUNC(sklass->destroy) :
1563 (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
1564 ), ptr);
1565
1566 /* If tracking is on for this class then track this object. */
1567 if (track) {
1568 SWIG_RubyAddTracking(ptr, obj);
1569 }
1570 } else {
1571 klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1572 sprintf(klass_name, "TYPE%s", type->name);
1573 klass = rb_const_get(_mSWIG, rb_intern(klass_name));
1574 free((void *) klass_name);
1575 obj = Data_Wrap_Struct(klass, 0, 0, ptr);
1576 }
1577 rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
1578
1579 return obj;
1580 }
1581
1582 /* Create a new class instance (always owned) */
1583 SWIGRUNTIME VALUE
SWIG_Ruby_NewClassInstance(VALUE klass,swig_type_info * type)1584 SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
1585 {
1586 VALUE obj;
1587 swig_class *sklass = (swig_class *) type->clientdata;
1588 obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
1589 rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
1590 return obj;
1591 }
1592
1593 /* Get type mangle from class name */
1594 SWIGRUNTIMEINLINE char *
SWIG_Ruby_MangleStr(VALUE obj)1595 SWIG_Ruby_MangleStr(VALUE obj)
1596 {
1597 VALUE stype = rb_iv_get(obj, "@__swigtype__");
1598 return StringValuePtr(stype);
1599 }
1600
1601 /* Acquire a pointer value */
1602 typedef void (*ruby_owntype)(void*);
1603
1604 SWIGRUNTIME ruby_owntype
SWIG_Ruby_AcquirePtr(VALUE obj,ruby_owntype own)1605 SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
1606 if (obj) {
1607 ruby_owntype oldown = RDATA(obj)->dfree;
1608 RDATA(obj)->dfree = own;
1609 return oldown;
1610 } else {
1611 return 0;
1612 }
1613 }
1614
1615 /* Convert a pointer value */
1616 SWIGRUNTIME int
SWIG_Ruby_ConvertPtrAndOwn(VALUE obj,void ** ptr,swig_type_info * ty,int flags,ruby_owntype * own)1617 SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
1618 {
1619 char *c;
1620 swig_cast_info *tc;
1621 void *vptr = 0;
1622
1623 /* Grab the pointer */
1624 if (NIL_P(obj)) {
1625 *ptr = 0;
1626 return SWIG_OK;
1627 } else {
1628 if (TYPE(obj) != T_DATA) {
1629 return SWIG_ERROR;
1630 }
1631 Data_Get_Struct(obj, void, vptr);
1632 }
1633
1634 if (own) *own = RDATA(obj)->dfree;
1635
1636 /* Check to see if the input object is giving up ownership
1637 of the underlying C struct or C++ object. If so then we
1638 need to reset the destructor since the Ruby object no
1639 longer owns the underlying C++ object.*/
1640 if (flags & SWIG_POINTER_DISOWN) {
1641 /* Is tracking on for this class? */
1642 int track = 0;
1643 if (ty && ty->clientdata) {
1644 swig_class *sklass = (swig_class *) ty->clientdata;
1645 track = sklass->trackObjects;
1646 }
1647
1648 if (track) {
1649 /* We are tracking objects for this class. Thus we change the destructor
1650 * to SWIG_RubyRemoveTracking. This allows us to
1651 * remove the mapping from the C++ to Ruby object
1652 * when the Ruby object is garbage collected. If we don't
1653 * do this, then it is possible we will return a reference
1654 * to a Ruby object that no longer exists thereby crashing Ruby. */
1655 RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
1656 } else {
1657 RDATA(obj)->dfree = 0;
1658 }
1659 }
1660
1661 /* Do type-checking if type info was provided */
1662 if (ty) {
1663 if (ty->clientdata) {
1664 if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
1665 if (vptr == 0) {
1666 /* The object has already been deleted */
1667 return SWIG_ObjectPreviouslyDeletedError;
1668 }
1669 *ptr = vptr;
1670 return SWIG_OK;
1671 }
1672 }
1673 if ((c = SWIG_MangleStr(obj)) == NULL) {
1674 return SWIG_ERROR;
1675 }
1676 tc = SWIG_TypeCheck(c, ty);
1677 if (!tc) {
1678 return SWIG_ERROR;
1679 } else {
1680 int newmemory = 0;
1681 *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
1682 assert(!newmemory); /* newmemory handling not yet implemented */
1683 }
1684 } else {
1685 *ptr = vptr;
1686 }
1687
1688 return SWIG_OK;
1689 }
1690
1691 /* Check convert */
1692 SWIGRUNTIMEINLINE int
SWIG_Ruby_CheckConvert(VALUE obj,swig_type_info * ty)1693 SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
1694 {
1695 char *c = SWIG_MangleStr(obj);
1696 if (!c) return 0;
1697 return SWIG_TypeCheck(c,ty) != 0;
1698 }
1699
1700 SWIGRUNTIME VALUE
SWIG_Ruby_NewPackedObj(void * ptr,int sz,swig_type_info * type)1701 SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1702 char result[1024];
1703 char *r = result;
1704 if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1705 *(r++) = '_';
1706 r = SWIG_PackData(r, ptr, sz);
1707 strcpy(r, type->name);
1708 return rb_str_new2(result);
1709 }
1710
1711 /* Convert a packed value value */
1712 SWIGRUNTIME int
SWIG_Ruby_ConvertPacked(VALUE obj,void * ptr,int sz,swig_type_info * ty)1713 SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
1714 swig_cast_info *tc;
1715 const char *c;
1716
1717 if (TYPE(obj) != T_STRING) goto type_error;
1718 c = StringValuePtr(obj);
1719 /* Pointer values must start with leading underscore */
1720 if (*c != '_') goto type_error;
1721 c++;
1722 c = SWIG_UnpackData(c, ptr, sz);
1723 if (ty) {
1724 tc = SWIG_TypeCheck(c, ty);
1725 if (!tc) goto type_error;
1726 }
1727 return SWIG_OK;
1728
1729 type_error:
1730 return SWIG_ERROR;
1731 }
1732
1733 SWIGRUNTIME swig_module_info *
SWIG_Ruby_GetModule(void)1734 SWIG_Ruby_GetModule(void)
1735 {
1736 VALUE pointer;
1737 swig_module_info *ret = 0;
1738 VALUE verbose = rb_gv_get("VERBOSE");
1739
1740 /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
1741 rb_gv_set("VERBOSE", Qfalse);
1742
1743 /* first check if pointer already created */
1744 pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1745 if (pointer != Qnil) {
1746 Data_Get_Struct(pointer, swig_module_info, ret);
1747 }
1748
1749 /* reinstate warnings */
1750 rb_gv_set("VERBOSE", verbose);
1751 return ret;
1752 }
1753
1754 SWIGRUNTIME void
SWIG_Ruby_SetModule(swig_module_info * pointer)1755 SWIG_Ruby_SetModule(swig_module_info *pointer)
1756 {
1757 /* register a new class */
1758 VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
1759 /* create and store the structure pointer to a global variable */
1760 swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
1761 rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
1762 }
1763
1764 /* This function can be used to check whether a proc or method or similarly
1765 callable function has been passed. Usually used in a %typecheck, like:
1766
1767 %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
1768 $result = SWIG_Ruby_isCallable( $input );
1769 }
1770 */
1771 SWIGINTERN
SWIG_Ruby_isCallable(VALUE proc)1772 int SWIG_Ruby_isCallable( VALUE proc )
1773 {
1774 if ( rb_respond_to( proc, swig_call_id ) == Qtrue )
1775 return 1;
1776 return 0;
1777 }
1778
1779 /* This function can be used to check the arity (number of arguments)
1780 a proc or method can take. Usually used in a %typecheck.
1781 Valid arities will be that equal to minimal or those < 0
1782 which indicate a variable number of parameters at the end.
1783 */
1784 SWIGINTERN
SWIG_Ruby_arity(VALUE proc,int minimal)1785 int SWIG_Ruby_arity( VALUE proc, int minimal )
1786 {
1787 if ( rb_respond_to( proc, swig_arity_id ) == Qtrue )
1788 {
1789 VALUE num = rb_funcall( proc, swig_arity_id, 0 );
1790 int arity = NUM2INT(num);
1791 if ( arity < 0 && (arity+1) < -minimal ) return 1;
1792 if ( arity == minimal ) return 1;
1793 return 1;
1794 }
1795 return 0;
1796 }
1797
1798
1799 #ifdef __cplusplus
1800 }
1801 #endif
1802
1803
1804
1805 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1806
1807 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1808
1809
1810
1811 /* -------- TYPES TABLE (BEGIN) -------- */
1812
1813 #define SWIGTYPE_p_OpalCallEndReason swig_types[0]
1814 #define SWIGTYPE_p_OpalContext swig_types[1]
1815 #define SWIGTYPE_p_OpalEchoCancelMode swig_types[2]
1816 #define SWIGTYPE_p_OpalHandleStruct swig_types[3]
1817 #define SWIGTYPE_p_OpalLineAppearanceStates swig_types[4]
1818 #define SWIGTYPE_p_OpalMediaDataType swig_types[5]
1819 #define SWIGTYPE_p_OpalMediaStates swig_types[6]
1820 #define SWIGTYPE_p_OpalMediaTiming swig_types[7]
1821 #define SWIGTYPE_p_OpalMessage swig_types[8]
1822 #define SWIGTYPE_p_OpalMessagePtr swig_types[9]
1823 #define SWIGTYPE_p_OpalMessageType swig_types[10]
1824 #define SWIGTYPE_p_OpalMessage_m_param swig_types[11]
1825 #define SWIGTYPE_p_OpalParamAnswerCall swig_types[12]
1826 #define SWIGTYPE_p_OpalParamCallCleared swig_types[13]
1827 #define SWIGTYPE_p_OpalParamGeneral swig_types[14]
1828 #define SWIGTYPE_p_OpalParamProtocol swig_types[15]
1829 #define SWIGTYPE_p_OpalParamRecording swig_types[16]
1830 #define SWIGTYPE_p_OpalParamRegistration swig_types[17]
1831 #define SWIGTYPE_p_OpalParamSetUpCall swig_types[18]
1832 #define SWIGTYPE_p_OpalParamSetUserData swig_types[19]
1833 #define SWIGTYPE_p_OpalProductDescription swig_types[20]
1834 #define SWIGTYPE_p_OpalRegistrationStates swig_types[21]
1835 #define SWIGTYPE_p_OpalSilenceDetectMode swig_types[22]
1836 #define SWIGTYPE_p_OpalStatusCallCleared swig_types[23]
1837 #define SWIGTYPE_p_OpalStatusIVR swig_types[24]
1838 #define SWIGTYPE_p_OpalStatusIncomingCall swig_types[25]
1839 #define SWIGTYPE_p_OpalStatusLineAppearance swig_types[26]
1840 #define SWIGTYPE_p_OpalStatusMediaStream swig_types[27]
1841 #define SWIGTYPE_p_OpalStatusMessageWaiting swig_types[28]
1842 #define SWIGTYPE_p_OpalStatusRegistration swig_types[29]
1843 #define SWIGTYPE_p_OpalStatusTransferCall swig_types[30]
1844 #define SWIGTYPE_p_OpalStatusUserInput swig_types[31]
1845 #define SWIGTYPE_p_OpalUserInputModes swig_types[32]
1846 #define SWIGTYPE_p_OpalVideoRecordMixMode swig_types[33]
1847 #define SWIGTYPE_p_char swig_types[34]
1848 #define SWIGTYPE_p_f_p_q_const__OpalMessage__int swig_types[35]
1849 #define SWIGTYPE_p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_void_p_void_int__int swig_types[36]
1850 #define SWIGTYPE_p_unsigned_int swig_types[37]
1851 #define SWIGTYPE_p_void swig_types[38]
1852 static swig_type_info *swig_types[40];
1853 static swig_module_info swig_module = {swig_types, 39, 0, 0, 0, 0};
1854 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1855 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1856
1857 /* -------- TYPES TABLE (END) -------- */
1858
1859 #define SWIG_init Init_opal
1860 #define SWIG_name "Opal"
1861
1862 static VALUE mOpal;
1863
1864 #define SWIG_RUBY_THREAD_BEGIN_BLOCK
1865 #define SWIG_RUBY_THREAD_END_BLOCK
1866
1867
1868 #define SWIGVERSION 0x010340
1869 #define SWIG_VERSION SWIGVERSION
1870
1871
1872 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
1873 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
1874
1875
1876 #include <stdexcept>
1877
1878
1879 /* Includes the header in the wrapper code */
1880 #include "opal.h"
1881
1882
1883 #ifdef __cplusplus
1884 extern "C" {
1885 #endif
1886
1887 // Ruby 1.9 changed the file name of this header
1888 #ifdef HAVE_RUBY_IO_H
1889 #include "ruby/io.h"
1890 #else
1891 #include "rubyio.h"
1892 #endif
1893
1894 #ifdef __cplusplus
1895 }
1896 #endif
1897
1898
1899 #ifdef __cplusplus
1900 extern "C" {
1901 #endif
1902 #ifdef HAVE_SYS_TIME_H
1903 # include <sys/time.h>
1904 struct timeval rb_time_timeval(VALUE);
1905 #endif
1906 #ifdef __cplusplus
1907 }
1908 #endif
1909
1910
1911 #include <limits.h>
1912 #if !defined(SWIG_NO_LLONG_MAX)
1913 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1914 # define LLONG_MAX __LONG_LONG_MAX__
1915 # define LLONG_MIN (-LLONG_MAX - 1LL)
1916 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1917 # endif
1918 #endif
1919
1920
1921 #define SWIG_From_long LONG2NUM
1922
1923
1924 SWIGINTERNINLINE VALUE
SWIG_From_int(int value)1925 SWIG_From_int (int value)
1926 {
1927 return SWIG_From_long (value);
1928 }
1929
1930
1931 SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)1932 SWIG_pchar_descriptor(void)
1933 {
1934 static int init = 0;
1935 static swig_type_info* info = 0;
1936 if (!init) {
1937 info = SWIG_TypeQuery("_p_char");
1938 init = 1;
1939 }
1940 return info;
1941 }
1942
1943
1944 SWIGINTERN int
SWIG_AsCharPtrAndSize(VALUE obj,char ** cptr,size_t * psize,int * alloc)1945 SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
1946 {
1947 if (TYPE(obj) == T_STRING) {
1948 #if defined(StringValuePtr)
1949 char *cstr = StringValuePtr(obj);
1950 #else
1951 char *cstr = STR2CSTR(obj);
1952 #endif
1953 size_t size = RSTRING_LEN(obj) + 1;
1954 if (cptr) {
1955 if (alloc) {
1956 if (*alloc == SWIG_NEWOBJ) {
1957 *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size)));
1958 } else {
1959 *cptr = cstr;
1960 *alloc = SWIG_OLDOBJ;
1961 }
1962 }
1963 }
1964 if (psize) *psize = size;
1965 return SWIG_OK;
1966 } else {
1967 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1968 if (pchar_descriptor) {
1969 void* vptr = 0;
1970 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
1971 if (cptr) *cptr = (char *)vptr;
1972 if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
1973 if (alloc) *alloc = SWIG_OLDOBJ;
1974 return SWIG_OK;
1975 }
1976 }
1977 }
1978 return SWIG_TypeError;
1979 }
1980
1981
1982
1983
1984
1985 SWIGINTERNINLINE VALUE
SWIG_FromCharPtrAndSize(const char * carray,size_t size)1986 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1987 {
1988 if (carray) {
1989 if (size > LONG_MAX) {
1990 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1991 return pchar_descriptor ?
1992 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
1993 } else {
1994 return rb_str_new(carray, static_cast< long >(size));
1995 }
1996 } else {
1997 return Qnil;
1998 }
1999 }
2000
2001
2002 SWIGINTERNINLINE VALUE
SWIG_FromCharPtr(const char * cptr)2003 SWIG_FromCharPtr(const char *cptr)
2004 {
2005 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2006 }
2007
2008
2009 SWIGINTERN VALUE
SWIG_ruby_failed(void)2010 SWIG_ruby_failed(void)
2011 {
2012 return Qnil;
2013 }
2014
2015
2016 /*@SWIG:c:\\tools\\Lib\\ruby\\rubyprimtypes.swg,23,%ruby_aux_method@*/
SWIG_AUX_NUM2ULONG(VALUE * args)2017 SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
2018 {
2019 VALUE obj = args[0];
2020 VALUE type = TYPE(obj);
2021 unsigned long *res = (unsigned long *)(args[1]);
2022 *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
2023 return obj;
2024 }
2025 /*@SWIG@*/
2026
2027 SWIGINTERN int
SWIG_AsVal_unsigned_SS_long(VALUE obj,unsigned long * val)2028 SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val)
2029 {
2030 VALUE type = TYPE(obj);
2031 if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
2032 unsigned long v;
2033 VALUE a[2];
2034 a[0] = obj;
2035 a[1] = (VALUE)(&v);
2036 if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
2037 if (val) *val = v;
2038 return SWIG_OK;
2039 }
2040 }
2041 return SWIG_TypeError;
2042 }
2043
2044
2045 SWIGINTERN int
SWIG_AsVal_unsigned_SS_int(VALUE obj,unsigned int * val)2046 SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
2047 {
2048 unsigned long v;
2049 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2050 if (SWIG_IsOK(res)) {
2051 if ((v > UINT_MAX)) {
2052 return SWIG_OverflowError;
2053 } else {
2054 if (val) *val = static_cast< unsigned int >(v);
2055 }
2056 }
2057 return res;
2058 }
2059
2060
2061 SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_long(unsigned long value)2062 SWIG_From_unsigned_SS_long (unsigned long value)
2063 {
2064 return ULONG2NUM(value);
2065 }
2066
2067
2068 SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_int(unsigned int value)2069 SWIG_From_unsigned_SS_int (unsigned int value)
2070 {
2071 return SWIG_From_unsigned_SS_long (value);
2072 }
2073
2074
2075 /*@SWIG:c:\\tools\\Lib\\ruby\\rubyprimtypes.swg,23,%ruby_aux_method@*/
SWIG_AUX_NUM2LONG(VALUE * args)2076 SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
2077 {
2078 VALUE obj = args[0];
2079 VALUE type = TYPE(obj);
2080 long *res = (long *)(args[1]);
2081 *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
2082 return obj;
2083 }
2084 /*@SWIG@*/
2085
2086 SWIGINTERN int
SWIG_AsVal_long(VALUE obj,long * val)2087 SWIG_AsVal_long (VALUE obj, long* val)
2088 {
2089 VALUE type = TYPE(obj);
2090 if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
2091 long v;
2092 VALUE a[2];
2093 a[0] = obj;
2094 a[1] = (VALUE)(&v);
2095 if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
2096 if (val) *val = v;
2097 return SWIG_OK;
2098 }
2099 }
2100 return SWIG_TypeError;
2101 }
2102
2103
2104 SWIGINTERN int
SWIG_AsVal_int(VALUE obj,int * val)2105 SWIG_AsVal_int (VALUE obj, int *val)
2106 {
2107 long v;
2108 int res = SWIG_AsVal_long (obj, &v);
2109 if (SWIG_IsOK(res)) {
2110 if ((v < INT_MIN || v > INT_MAX)) {
2111 return SWIG_OverflowError;
2112 } else {
2113 if (val) *val = static_cast< int >(v);
2114 }
2115 }
2116 return res;
2117 }
2118
2119
2120 typedef union {
2121 const char * m_commandError;
2122 OpalParamGeneral m_general;
2123 OpalParamProtocol m_protocol;
2124 OpalParamRegistration m_registrationInfo;
2125 OpalStatusRegistration m_registrationStatus;
2126 OpalParamSetUpCall m_callSetUp;
2127 const char * m_callToken;
2128 OpalStatusIncomingCall m_incomingCall;
2129 OpalParamAnswerCall m_answerCall;
2130 OpalStatusUserInput m_userInput;
2131 OpalStatusMessageWaiting m_messageWaiting;
2132 OpalStatusLineAppearance m_lineAppearance;
2133 OpalStatusCallCleared m_callCleared;
2134 OpalParamCallCleared m_clearCall;
2135 OpalStatusMediaStream m_mediaStream;
2136 OpalParamSetUserData m_setUserData;
2137 OpalParamRecording m_recording;
2138 OpalStatusTransferCall m_transferStatus;
2139 OpalStatusIVR m_ivrStatus;
2140 } OpalMessage_m_param;
2141
2142
2143
2144 SWIGINTERNINLINE VALUE
SWIG_From_bool(bool value)2145 SWIG_From_bool (bool value)
2146 {
2147 return value ? Qtrue : Qfalse;
2148 }
2149
2150
2151 /*
2152 Document-method: Opal.OpalInitialise
2153
2154 call-seq:
2155 OpalInitialise(unsigned int version, char options) -> OpalHandle
2156
2157 A module function.
2158
2159 */
2160 SWIGINTERN VALUE
_wrap_OpalInitialise(int argc,VALUE * argv,VALUE self)2161 _wrap_OpalInitialise(int argc, VALUE *argv, VALUE self) {
2162 unsigned int *arg1 = (unsigned int *) 0 ;
2163 char *arg2 = (char *) 0 ;
2164 void *argp1 = 0 ;
2165 int res1 = 0 ;
2166 int res2 ;
2167 char *buf2 = 0 ;
2168 int alloc2 = 0 ;
2169 OpalHandle result;
2170 VALUE vresult = Qnil;
2171
2172 if ((argc < 2) || (argc > 2)) {
2173 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2174 }
2175 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_unsigned_int, 0 | 0 );
2176 if (!SWIG_IsOK(res1)) {
2177 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "unsigned int *","OpalInitialise", 1, argv[0] ));
2178 }
2179 arg1 = reinterpret_cast< unsigned int * >(argp1);
2180 res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
2181 if (!SWIG_IsOK(res2)) {
2182 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","OpalInitialise", 2, argv[1] ));
2183 }
2184 arg2 = reinterpret_cast< char * >(buf2);
2185 result = (OpalHandle)OpalInitialise(arg1,(char const *)arg2);
2186 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalHandleStruct, 0 | 0 );
2187 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2188 return vresult;
2189 fail:
2190 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2191 return Qnil;
2192 }
2193
2194
2195
2196 /*
2197 Document-method: Opal.OpalShutDown
2198
2199 call-seq:
2200 OpalShutDown(OpalHandle opal)
2201
2202 A module function.
2203
2204 */
2205 SWIGINTERN VALUE
_wrap_OpalShutDown(int argc,VALUE * argv,VALUE self)2206 _wrap_OpalShutDown(int argc, VALUE *argv, VALUE self) {
2207 OpalHandle arg1 = (OpalHandle) 0 ;
2208 void *argp1 = 0 ;
2209 int res1 = 0 ;
2210
2211 if ((argc < 1) || (argc > 1)) {
2212 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2213 }
2214 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_OpalHandleStruct, 0 | 0 );
2215 if (!SWIG_IsOK(res1)) {
2216 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalHandle","OpalShutDown", 1, argv[0] ));
2217 }
2218 arg1 = reinterpret_cast< OpalHandle >(argp1);
2219 OpalShutDown(arg1);
2220 return Qnil;
2221 fail:
2222 return Qnil;
2223 }
2224
2225
2226
2227 /*
2228 Document-method: Opal.OpalGetMessage
2229
2230 call-seq:
2231 OpalGetMessage(OpalHandle opal, unsigned int timeout) -> OpalMessage
2232
2233 A module function.
2234
2235 */
2236 SWIGINTERN VALUE
_wrap_OpalGetMessage(int argc,VALUE * argv,VALUE self)2237 _wrap_OpalGetMessage(int argc, VALUE *argv, VALUE self) {
2238 OpalHandle arg1 = (OpalHandle) 0 ;
2239 unsigned int arg2 ;
2240 void *argp1 = 0 ;
2241 int res1 = 0 ;
2242 unsigned int val2 ;
2243 int ecode2 = 0 ;
2244 OpalMessage *result = 0 ;
2245 VALUE vresult = Qnil;
2246
2247 if ((argc < 2) || (argc > 2)) {
2248 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2249 }
2250 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_OpalHandleStruct, 0 | 0 );
2251 if (!SWIG_IsOK(res1)) {
2252 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalHandle","OpalGetMessage", 1, argv[0] ));
2253 }
2254 arg1 = reinterpret_cast< OpalHandle >(argp1);
2255 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
2256 if (!SWIG_IsOK(ecode2)) {
2257 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","OpalGetMessage", 2, argv[1] ));
2258 }
2259 arg2 = static_cast< unsigned int >(val2);
2260 result = (OpalMessage *)OpalGetMessage(arg1,arg2);
2261 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalMessage, 0 | 0 );
2262 return vresult;
2263 fail:
2264 return Qnil;
2265 }
2266
2267
2268
2269 /*
2270 Document-method: Opal.OpalSendMessage
2271
2272 call-seq:
2273 OpalSendMessage(OpalHandle opal, OpalMessage message) -> OpalMessage
2274
2275 A module function.
2276
2277 */
2278 SWIGINTERN VALUE
_wrap_OpalSendMessage(int argc,VALUE * argv,VALUE self)2279 _wrap_OpalSendMessage(int argc, VALUE *argv, VALUE self) {
2280 OpalHandle arg1 = (OpalHandle) 0 ;
2281 OpalMessage *arg2 = (OpalMessage *) 0 ;
2282 void *argp1 = 0 ;
2283 int res1 = 0 ;
2284 void *argp2 = 0 ;
2285 int res2 = 0 ;
2286 OpalMessage *result = 0 ;
2287 VALUE vresult = Qnil;
2288
2289 if ((argc < 2) || (argc > 2)) {
2290 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2291 }
2292 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_OpalHandleStruct, 0 | 0 );
2293 if (!SWIG_IsOK(res1)) {
2294 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalHandle","OpalSendMessage", 1, argv[0] ));
2295 }
2296 arg1 = reinterpret_cast< OpalHandle >(argp1);
2297 res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_OpalMessage, 0 | 0 );
2298 if (!SWIG_IsOK(res2)) {
2299 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalMessage const *","OpalSendMessage", 2, argv[1] ));
2300 }
2301 arg2 = reinterpret_cast< OpalMessage * >(argp2);
2302 result = (OpalMessage *)OpalSendMessage(arg1,(OpalMessage const *)arg2);
2303 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalMessage, 0 | 0 );
2304 return vresult;
2305 fail:
2306 return Qnil;
2307 }
2308
2309
2310
2311 /*
2312 Document-method: Opal.OpalFreeMessage
2313
2314 call-seq:
2315 OpalFreeMessage(OpalMessage message)
2316
2317 A module function.
2318
2319 */
2320 SWIGINTERN VALUE
_wrap_OpalFreeMessage(int argc,VALUE * argv,VALUE self)2321 _wrap_OpalFreeMessage(int argc, VALUE *argv, VALUE self) {
2322 OpalMessage *arg1 = (OpalMessage *) 0 ;
2323 void *argp1 = 0 ;
2324 int res1 = 0 ;
2325
2326 if ((argc < 1) || (argc > 1)) {
2327 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2328 }
2329 res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_OpalMessage, 0 | 0 );
2330 if (!SWIG_IsOK(res1)) {
2331 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage *","OpalFreeMessage", 1, argv[0] ));
2332 }
2333 arg1 = reinterpret_cast< OpalMessage * >(argp1);
2334 OpalFreeMessage(arg1);
2335 return Qnil;
2336 fail:
2337 return Qnil;
2338 }
2339
2340
2341
2342 /*
2343 Document-class: Opal::OpalParamGeneral
2344
2345 Proxy of C++ Opal::OpalParamGeneral class
2346
2347
2348 */
2349 swig_class SwigClassOpalParamGeneral;
2350
2351
2352 /*
2353 Document-method: Opal::OpalParamGeneral.m_audioRecordDevice
2354
2355 call-seq:
2356 m_audioRecordDevice -> char
2357
2358 Get value of attribute.
2359
2360 */
2361
2362 /*
2363 Document-method: Opal::OpalParamGeneral.m_audioRecordDevice=
2364
2365 call-seq:
2366 m_audioRecordDevice=(x) -> char
2367
2368 Set new value for attribute.
2369
2370 */
2371 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_audioRecordDevice_set(int argc,VALUE * argv,VALUE self)2372 _wrap_OpalParamGeneral_m_audioRecordDevice_set(int argc, VALUE *argv, VALUE self) {
2373 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2374 char *arg2 = (char *) 0 ;
2375 void *argp1 = 0 ;
2376 int res1 = 0 ;
2377 int res2 ;
2378 char *buf2 = 0 ;
2379 int alloc2 = 0 ;
2380
2381 if ((argc < 1) || (argc > 1)) {
2382 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2383 }
2384 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2385 if (!SWIG_IsOK(res1)) {
2386 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_audioRecordDevice", 1, self ));
2387 }
2388 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2389 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2390 if (!SWIG_IsOK(res2)) {
2391 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_audioRecordDevice", 2, argv[0] ));
2392 }
2393 arg2 = reinterpret_cast< char * >(buf2);
2394 if (arg2) {
2395 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
2396 arg1->m_audioRecordDevice = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
2397 } else {
2398 arg1->m_audioRecordDevice = 0;
2399 }
2400 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2401 return Qnil;
2402 fail:
2403 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2404 return Qnil;
2405 }
2406
2407
2408 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_audioRecordDevice_get(int argc,VALUE * argv,VALUE self)2409 _wrap_OpalParamGeneral_m_audioRecordDevice_get(int argc, VALUE *argv, VALUE self) {
2410 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2411 void *argp1 = 0 ;
2412 int res1 = 0 ;
2413 char *result = 0 ;
2414 VALUE vresult = Qnil;
2415
2416 if ((argc < 0) || (argc > 0)) {
2417 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2418 }
2419 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2420 if (!SWIG_IsOK(res1)) {
2421 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_audioRecordDevice", 1, self ));
2422 }
2423 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2424 result = (char *) ((arg1)->m_audioRecordDevice);
2425 vresult = SWIG_FromCharPtr((const char *)result);
2426 return vresult;
2427 fail:
2428 return Qnil;
2429 }
2430
2431
2432
2433 /*
2434 Document-method: Opal::OpalParamGeneral.m_audioPlayerDevice
2435
2436 call-seq:
2437 m_audioPlayerDevice -> char
2438
2439 Get value of attribute.
2440
2441 */
2442
2443 /*
2444 Document-method: Opal::OpalParamGeneral.m_audioPlayerDevice=
2445
2446 call-seq:
2447 m_audioPlayerDevice=(x) -> char
2448
2449 Set new value for attribute.
2450
2451 */
2452 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_audioPlayerDevice_set(int argc,VALUE * argv,VALUE self)2453 _wrap_OpalParamGeneral_m_audioPlayerDevice_set(int argc, VALUE *argv, VALUE self) {
2454 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2455 char *arg2 = (char *) 0 ;
2456 void *argp1 = 0 ;
2457 int res1 = 0 ;
2458 int res2 ;
2459 char *buf2 = 0 ;
2460 int alloc2 = 0 ;
2461
2462 if ((argc < 1) || (argc > 1)) {
2463 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2464 }
2465 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2466 if (!SWIG_IsOK(res1)) {
2467 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_audioPlayerDevice", 1, self ));
2468 }
2469 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2470 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2471 if (!SWIG_IsOK(res2)) {
2472 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_audioPlayerDevice", 2, argv[0] ));
2473 }
2474 arg2 = reinterpret_cast< char * >(buf2);
2475 if (arg2) {
2476 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
2477 arg1->m_audioPlayerDevice = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
2478 } else {
2479 arg1->m_audioPlayerDevice = 0;
2480 }
2481 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2482 return Qnil;
2483 fail:
2484 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2485 return Qnil;
2486 }
2487
2488
2489 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_audioPlayerDevice_get(int argc,VALUE * argv,VALUE self)2490 _wrap_OpalParamGeneral_m_audioPlayerDevice_get(int argc, VALUE *argv, VALUE self) {
2491 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2492 void *argp1 = 0 ;
2493 int res1 = 0 ;
2494 char *result = 0 ;
2495 VALUE vresult = Qnil;
2496
2497 if ((argc < 0) || (argc > 0)) {
2498 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2499 }
2500 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2501 if (!SWIG_IsOK(res1)) {
2502 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_audioPlayerDevice", 1, self ));
2503 }
2504 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2505 result = (char *) ((arg1)->m_audioPlayerDevice);
2506 vresult = SWIG_FromCharPtr((const char *)result);
2507 return vresult;
2508 fail:
2509 return Qnil;
2510 }
2511
2512
2513
2514 /*
2515 Document-method: Opal::OpalParamGeneral.m_videoInputDevice
2516
2517 call-seq:
2518 m_videoInputDevice -> char
2519
2520 Get value of attribute.
2521
2522 */
2523
2524 /*
2525 Document-method: Opal::OpalParamGeneral.m_videoInputDevice=
2526
2527 call-seq:
2528 m_videoInputDevice=(x) -> char
2529
2530 Set new value for attribute.
2531
2532 */
2533 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_videoInputDevice_set(int argc,VALUE * argv,VALUE self)2534 _wrap_OpalParamGeneral_m_videoInputDevice_set(int argc, VALUE *argv, VALUE self) {
2535 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2536 char *arg2 = (char *) 0 ;
2537 void *argp1 = 0 ;
2538 int res1 = 0 ;
2539 int res2 ;
2540 char *buf2 = 0 ;
2541 int alloc2 = 0 ;
2542
2543 if ((argc < 1) || (argc > 1)) {
2544 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2545 }
2546 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2547 if (!SWIG_IsOK(res1)) {
2548 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_videoInputDevice", 1, self ));
2549 }
2550 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2551 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2552 if (!SWIG_IsOK(res2)) {
2553 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_videoInputDevice", 2, argv[0] ));
2554 }
2555 arg2 = reinterpret_cast< char * >(buf2);
2556 if (arg2) {
2557 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
2558 arg1->m_videoInputDevice = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
2559 } else {
2560 arg1->m_videoInputDevice = 0;
2561 }
2562 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2563 return Qnil;
2564 fail:
2565 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2566 return Qnil;
2567 }
2568
2569
2570 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_videoInputDevice_get(int argc,VALUE * argv,VALUE self)2571 _wrap_OpalParamGeneral_m_videoInputDevice_get(int argc, VALUE *argv, VALUE self) {
2572 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2573 void *argp1 = 0 ;
2574 int res1 = 0 ;
2575 char *result = 0 ;
2576 VALUE vresult = Qnil;
2577
2578 if ((argc < 0) || (argc > 0)) {
2579 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2580 }
2581 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2582 if (!SWIG_IsOK(res1)) {
2583 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_videoInputDevice", 1, self ));
2584 }
2585 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2586 result = (char *) ((arg1)->m_videoInputDevice);
2587 vresult = SWIG_FromCharPtr((const char *)result);
2588 return vresult;
2589 fail:
2590 return Qnil;
2591 }
2592
2593
2594
2595 /*
2596 Document-method: Opal::OpalParamGeneral.m_videoOutputDevice
2597
2598 call-seq:
2599 m_videoOutputDevice -> char
2600
2601 Get value of attribute.
2602
2603 */
2604
2605 /*
2606 Document-method: Opal::OpalParamGeneral.m_videoOutputDevice=
2607
2608 call-seq:
2609 m_videoOutputDevice=(x) -> char
2610
2611 Set new value for attribute.
2612
2613 */
2614 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_videoOutputDevice_set(int argc,VALUE * argv,VALUE self)2615 _wrap_OpalParamGeneral_m_videoOutputDevice_set(int argc, VALUE *argv, VALUE self) {
2616 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2617 char *arg2 = (char *) 0 ;
2618 void *argp1 = 0 ;
2619 int res1 = 0 ;
2620 int res2 ;
2621 char *buf2 = 0 ;
2622 int alloc2 = 0 ;
2623
2624 if ((argc < 1) || (argc > 1)) {
2625 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2626 }
2627 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2628 if (!SWIG_IsOK(res1)) {
2629 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_videoOutputDevice", 1, self ));
2630 }
2631 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2632 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2633 if (!SWIG_IsOK(res2)) {
2634 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_videoOutputDevice", 2, argv[0] ));
2635 }
2636 arg2 = reinterpret_cast< char * >(buf2);
2637 if (arg2) {
2638 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
2639 arg1->m_videoOutputDevice = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
2640 } else {
2641 arg1->m_videoOutputDevice = 0;
2642 }
2643 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2644 return Qnil;
2645 fail:
2646 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2647 return Qnil;
2648 }
2649
2650
2651 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_videoOutputDevice_get(int argc,VALUE * argv,VALUE self)2652 _wrap_OpalParamGeneral_m_videoOutputDevice_get(int argc, VALUE *argv, VALUE self) {
2653 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2654 void *argp1 = 0 ;
2655 int res1 = 0 ;
2656 char *result = 0 ;
2657 VALUE vresult = Qnil;
2658
2659 if ((argc < 0) || (argc > 0)) {
2660 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2661 }
2662 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2663 if (!SWIG_IsOK(res1)) {
2664 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_videoOutputDevice", 1, self ));
2665 }
2666 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2667 result = (char *) ((arg1)->m_videoOutputDevice);
2668 vresult = SWIG_FromCharPtr((const char *)result);
2669 return vresult;
2670 fail:
2671 return Qnil;
2672 }
2673
2674
2675
2676 /*
2677 Document-method: Opal::OpalParamGeneral.m_videoPreviewDevice
2678
2679 call-seq:
2680 m_videoPreviewDevice -> char
2681
2682 Get value of attribute.
2683
2684 */
2685
2686 /*
2687 Document-method: Opal::OpalParamGeneral.m_videoPreviewDevice=
2688
2689 call-seq:
2690 m_videoPreviewDevice=(x) -> char
2691
2692 Set new value for attribute.
2693
2694 */
2695 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_videoPreviewDevice_set(int argc,VALUE * argv,VALUE self)2696 _wrap_OpalParamGeneral_m_videoPreviewDevice_set(int argc, VALUE *argv, VALUE self) {
2697 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2698 char *arg2 = (char *) 0 ;
2699 void *argp1 = 0 ;
2700 int res1 = 0 ;
2701 int res2 ;
2702 char *buf2 = 0 ;
2703 int alloc2 = 0 ;
2704
2705 if ((argc < 1) || (argc > 1)) {
2706 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2707 }
2708 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2709 if (!SWIG_IsOK(res1)) {
2710 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_videoPreviewDevice", 1, self ));
2711 }
2712 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2713 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2714 if (!SWIG_IsOK(res2)) {
2715 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_videoPreviewDevice", 2, argv[0] ));
2716 }
2717 arg2 = reinterpret_cast< char * >(buf2);
2718 if (arg2) {
2719 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
2720 arg1->m_videoPreviewDevice = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
2721 } else {
2722 arg1->m_videoPreviewDevice = 0;
2723 }
2724 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2725 return Qnil;
2726 fail:
2727 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2728 return Qnil;
2729 }
2730
2731
2732 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_videoPreviewDevice_get(int argc,VALUE * argv,VALUE self)2733 _wrap_OpalParamGeneral_m_videoPreviewDevice_get(int argc, VALUE *argv, VALUE self) {
2734 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2735 void *argp1 = 0 ;
2736 int res1 = 0 ;
2737 char *result = 0 ;
2738 VALUE vresult = Qnil;
2739
2740 if ((argc < 0) || (argc > 0)) {
2741 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2742 }
2743 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2744 if (!SWIG_IsOK(res1)) {
2745 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_videoPreviewDevice", 1, self ));
2746 }
2747 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2748 result = (char *) ((arg1)->m_videoPreviewDevice);
2749 vresult = SWIG_FromCharPtr((const char *)result);
2750 return vresult;
2751 fail:
2752 return Qnil;
2753 }
2754
2755
2756
2757 /*
2758 Document-method: Opal::OpalParamGeneral.m_mediaOrder
2759
2760 call-seq:
2761 m_mediaOrder -> char
2762
2763 Get value of attribute.
2764
2765 */
2766
2767 /*
2768 Document-method: Opal::OpalParamGeneral.m_mediaOrder=
2769
2770 call-seq:
2771 m_mediaOrder=(x) -> char
2772
2773 Set new value for attribute.
2774
2775 */
2776 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaOrder_set(int argc,VALUE * argv,VALUE self)2777 _wrap_OpalParamGeneral_m_mediaOrder_set(int argc, VALUE *argv, VALUE self) {
2778 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2779 char *arg2 = (char *) 0 ;
2780 void *argp1 = 0 ;
2781 int res1 = 0 ;
2782 int res2 ;
2783 char *buf2 = 0 ;
2784 int alloc2 = 0 ;
2785
2786 if ((argc < 1) || (argc > 1)) {
2787 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2788 }
2789 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2790 if (!SWIG_IsOK(res1)) {
2791 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaOrder", 1, self ));
2792 }
2793 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2794 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2795 if (!SWIG_IsOK(res2)) {
2796 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_mediaOrder", 2, argv[0] ));
2797 }
2798 arg2 = reinterpret_cast< char * >(buf2);
2799 if (arg2) {
2800 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
2801 arg1->m_mediaOrder = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
2802 } else {
2803 arg1->m_mediaOrder = 0;
2804 }
2805 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2806 return Qnil;
2807 fail:
2808 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2809 return Qnil;
2810 }
2811
2812
2813 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaOrder_get(int argc,VALUE * argv,VALUE self)2814 _wrap_OpalParamGeneral_m_mediaOrder_get(int argc, VALUE *argv, VALUE self) {
2815 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2816 void *argp1 = 0 ;
2817 int res1 = 0 ;
2818 char *result = 0 ;
2819 VALUE vresult = Qnil;
2820
2821 if ((argc < 0) || (argc > 0)) {
2822 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2823 }
2824 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2825 if (!SWIG_IsOK(res1)) {
2826 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaOrder", 1, self ));
2827 }
2828 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2829 result = (char *) ((arg1)->m_mediaOrder);
2830 vresult = SWIG_FromCharPtr((const char *)result);
2831 return vresult;
2832 fail:
2833 return Qnil;
2834 }
2835
2836
2837
2838 /*
2839 Document-method: Opal::OpalParamGeneral.m_mediaMask
2840
2841 call-seq:
2842 m_mediaMask -> char
2843
2844 Get value of attribute.
2845
2846 */
2847
2848 /*
2849 Document-method: Opal::OpalParamGeneral.m_mediaMask=
2850
2851 call-seq:
2852 m_mediaMask=(x) -> char
2853
2854 Set new value for attribute.
2855
2856 */
2857 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaMask_set(int argc,VALUE * argv,VALUE self)2858 _wrap_OpalParamGeneral_m_mediaMask_set(int argc, VALUE *argv, VALUE self) {
2859 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2860 char *arg2 = (char *) 0 ;
2861 void *argp1 = 0 ;
2862 int res1 = 0 ;
2863 int res2 ;
2864 char *buf2 = 0 ;
2865 int alloc2 = 0 ;
2866
2867 if ((argc < 1) || (argc > 1)) {
2868 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2869 }
2870 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2871 if (!SWIG_IsOK(res1)) {
2872 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaMask", 1, self ));
2873 }
2874 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2875 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2876 if (!SWIG_IsOK(res2)) {
2877 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_mediaMask", 2, argv[0] ));
2878 }
2879 arg2 = reinterpret_cast< char * >(buf2);
2880 if (arg2) {
2881 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
2882 arg1->m_mediaMask = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
2883 } else {
2884 arg1->m_mediaMask = 0;
2885 }
2886 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2887 return Qnil;
2888 fail:
2889 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2890 return Qnil;
2891 }
2892
2893
2894 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaMask_get(int argc,VALUE * argv,VALUE self)2895 _wrap_OpalParamGeneral_m_mediaMask_get(int argc, VALUE *argv, VALUE self) {
2896 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2897 void *argp1 = 0 ;
2898 int res1 = 0 ;
2899 char *result = 0 ;
2900 VALUE vresult = Qnil;
2901
2902 if ((argc < 0) || (argc > 0)) {
2903 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2904 }
2905 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2906 if (!SWIG_IsOK(res1)) {
2907 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaMask", 1, self ));
2908 }
2909 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2910 result = (char *) ((arg1)->m_mediaMask);
2911 vresult = SWIG_FromCharPtr((const char *)result);
2912 return vresult;
2913 fail:
2914 return Qnil;
2915 }
2916
2917
2918
2919 /*
2920 Document-method: Opal::OpalParamGeneral.m_autoRxMedia
2921
2922 call-seq:
2923 m_autoRxMedia -> char
2924
2925 Get value of attribute.
2926
2927 */
2928
2929 /*
2930 Document-method: Opal::OpalParamGeneral.m_autoRxMedia=
2931
2932 call-seq:
2933 m_autoRxMedia=(x) -> char
2934
2935 Set new value for attribute.
2936
2937 */
2938 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_autoRxMedia_set(int argc,VALUE * argv,VALUE self)2939 _wrap_OpalParamGeneral_m_autoRxMedia_set(int argc, VALUE *argv, VALUE self) {
2940 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2941 char *arg2 = (char *) 0 ;
2942 void *argp1 = 0 ;
2943 int res1 = 0 ;
2944 int res2 ;
2945 char *buf2 = 0 ;
2946 int alloc2 = 0 ;
2947
2948 if ((argc < 1) || (argc > 1)) {
2949 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2950 }
2951 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2952 if (!SWIG_IsOK(res1)) {
2953 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_autoRxMedia", 1, self ));
2954 }
2955 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2956 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2957 if (!SWIG_IsOK(res2)) {
2958 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_autoRxMedia", 2, argv[0] ));
2959 }
2960 arg2 = reinterpret_cast< char * >(buf2);
2961 if (arg2) {
2962 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
2963 arg1->m_autoRxMedia = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
2964 } else {
2965 arg1->m_autoRxMedia = 0;
2966 }
2967 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2968 return Qnil;
2969 fail:
2970 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2971 return Qnil;
2972 }
2973
2974
2975 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_autoRxMedia_get(int argc,VALUE * argv,VALUE self)2976 _wrap_OpalParamGeneral_m_autoRxMedia_get(int argc, VALUE *argv, VALUE self) {
2977 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
2978 void *argp1 = 0 ;
2979 int res1 = 0 ;
2980 char *result = 0 ;
2981 VALUE vresult = Qnil;
2982
2983 if ((argc < 0) || (argc > 0)) {
2984 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2985 }
2986 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
2987 if (!SWIG_IsOK(res1)) {
2988 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_autoRxMedia", 1, self ));
2989 }
2990 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
2991 result = (char *) ((arg1)->m_autoRxMedia);
2992 vresult = SWIG_FromCharPtr((const char *)result);
2993 return vresult;
2994 fail:
2995 return Qnil;
2996 }
2997
2998
2999
3000 /*
3001 Document-method: Opal::OpalParamGeneral.m_autoTxMedia
3002
3003 call-seq:
3004 m_autoTxMedia -> char
3005
3006 Get value of attribute.
3007
3008 */
3009
3010 /*
3011 Document-method: Opal::OpalParamGeneral.m_autoTxMedia=
3012
3013 call-seq:
3014 m_autoTxMedia=(x) -> char
3015
3016 Set new value for attribute.
3017
3018 */
3019 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_autoTxMedia_set(int argc,VALUE * argv,VALUE self)3020 _wrap_OpalParamGeneral_m_autoTxMedia_set(int argc, VALUE *argv, VALUE self) {
3021 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3022 char *arg2 = (char *) 0 ;
3023 void *argp1 = 0 ;
3024 int res1 = 0 ;
3025 int res2 ;
3026 char *buf2 = 0 ;
3027 int alloc2 = 0 ;
3028
3029 if ((argc < 1) || (argc > 1)) {
3030 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3031 }
3032 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3033 if (!SWIG_IsOK(res1)) {
3034 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_autoTxMedia", 1, self ));
3035 }
3036 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3037 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
3038 if (!SWIG_IsOK(res2)) {
3039 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_autoTxMedia", 2, argv[0] ));
3040 }
3041 arg2 = reinterpret_cast< char * >(buf2);
3042 if (arg2) {
3043 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
3044 arg1->m_autoTxMedia = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
3045 } else {
3046 arg1->m_autoTxMedia = 0;
3047 }
3048 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3049 return Qnil;
3050 fail:
3051 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3052 return Qnil;
3053 }
3054
3055
3056 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_autoTxMedia_get(int argc,VALUE * argv,VALUE self)3057 _wrap_OpalParamGeneral_m_autoTxMedia_get(int argc, VALUE *argv, VALUE self) {
3058 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3059 void *argp1 = 0 ;
3060 int res1 = 0 ;
3061 char *result = 0 ;
3062 VALUE vresult = Qnil;
3063
3064 if ((argc < 0) || (argc > 0)) {
3065 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3066 }
3067 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3068 if (!SWIG_IsOK(res1)) {
3069 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_autoTxMedia", 1, self ));
3070 }
3071 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3072 result = (char *) ((arg1)->m_autoTxMedia);
3073 vresult = SWIG_FromCharPtr((const char *)result);
3074 return vresult;
3075 fail:
3076 return Qnil;
3077 }
3078
3079
3080
3081 /*
3082 Document-method: Opal::OpalParamGeneral.m_natRouter
3083
3084 call-seq:
3085 m_natRouter -> char
3086
3087 Get value of attribute.
3088
3089 */
3090
3091 /*
3092 Document-method: Opal::OpalParamGeneral.m_natRouter=
3093
3094 call-seq:
3095 m_natRouter=(x) -> char
3096
3097 Set new value for attribute.
3098
3099 */
3100 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_natRouter_set(int argc,VALUE * argv,VALUE self)3101 _wrap_OpalParamGeneral_m_natRouter_set(int argc, VALUE *argv, VALUE self) {
3102 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3103 char *arg2 = (char *) 0 ;
3104 void *argp1 = 0 ;
3105 int res1 = 0 ;
3106 int res2 ;
3107 char *buf2 = 0 ;
3108 int alloc2 = 0 ;
3109
3110 if ((argc < 1) || (argc > 1)) {
3111 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3112 }
3113 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3114 if (!SWIG_IsOK(res1)) {
3115 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_natRouter", 1, self ));
3116 }
3117 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3118 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
3119 if (!SWIG_IsOK(res2)) {
3120 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_natRouter", 2, argv[0] ));
3121 }
3122 arg2 = reinterpret_cast< char * >(buf2);
3123 if (arg2) {
3124 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
3125 arg1->m_natRouter = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
3126 } else {
3127 arg1->m_natRouter = 0;
3128 }
3129 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3130 return Qnil;
3131 fail:
3132 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3133 return Qnil;
3134 }
3135
3136
3137 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_natRouter_get(int argc,VALUE * argv,VALUE self)3138 _wrap_OpalParamGeneral_m_natRouter_get(int argc, VALUE *argv, VALUE self) {
3139 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3140 void *argp1 = 0 ;
3141 int res1 = 0 ;
3142 char *result = 0 ;
3143 VALUE vresult = Qnil;
3144
3145 if ((argc < 0) || (argc > 0)) {
3146 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3147 }
3148 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3149 if (!SWIG_IsOK(res1)) {
3150 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_natRouter", 1, self ));
3151 }
3152 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3153 result = (char *) ((arg1)->m_natRouter);
3154 vresult = SWIG_FromCharPtr((const char *)result);
3155 return vresult;
3156 fail:
3157 return Qnil;
3158 }
3159
3160
3161
3162 /*
3163 Document-method: Opal::OpalParamGeneral.m_stunServer
3164
3165 call-seq:
3166 m_stunServer -> char
3167
3168 Get value of attribute.
3169
3170 */
3171
3172 /*
3173 Document-method: Opal::OpalParamGeneral.m_stunServer=
3174
3175 call-seq:
3176 m_stunServer=(x) -> char
3177
3178 Set new value for attribute.
3179
3180 */
3181 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_stunServer_set(int argc,VALUE * argv,VALUE self)3182 _wrap_OpalParamGeneral_m_stunServer_set(int argc, VALUE *argv, VALUE self) {
3183 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3184 char *arg2 = (char *) 0 ;
3185 void *argp1 = 0 ;
3186 int res1 = 0 ;
3187 int res2 ;
3188 char *buf2 = 0 ;
3189 int alloc2 = 0 ;
3190
3191 if ((argc < 1) || (argc > 1)) {
3192 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3193 }
3194 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3195 if (!SWIG_IsOK(res1)) {
3196 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_stunServer", 1, self ));
3197 }
3198 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3199 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
3200 if (!SWIG_IsOK(res2)) {
3201 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_stunServer", 2, argv[0] ));
3202 }
3203 arg2 = reinterpret_cast< char * >(buf2);
3204 if (arg2) {
3205 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
3206 arg1->m_stunServer = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
3207 } else {
3208 arg1->m_stunServer = 0;
3209 }
3210 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3211 return Qnil;
3212 fail:
3213 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3214 return Qnil;
3215 }
3216
3217
3218 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_stunServer_get(int argc,VALUE * argv,VALUE self)3219 _wrap_OpalParamGeneral_m_stunServer_get(int argc, VALUE *argv, VALUE self) {
3220 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3221 void *argp1 = 0 ;
3222 int res1 = 0 ;
3223 char *result = 0 ;
3224 VALUE vresult = Qnil;
3225
3226 if ((argc < 0) || (argc > 0)) {
3227 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3228 }
3229 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3230 if (!SWIG_IsOK(res1)) {
3231 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_stunServer", 1, self ));
3232 }
3233 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3234 result = (char *) ((arg1)->m_stunServer);
3235 vresult = SWIG_FromCharPtr((const char *)result);
3236 return vresult;
3237 fail:
3238 return Qnil;
3239 }
3240
3241
3242
3243 /*
3244 Document-method: Opal::OpalParamGeneral.m_tcpPortBase
3245
3246 call-seq:
3247 m_tcpPortBase -> unsigned int
3248
3249 Get value of attribute.
3250
3251 */
3252
3253 /*
3254 Document-method: Opal::OpalParamGeneral.m_tcpPortBase=
3255
3256 call-seq:
3257 m_tcpPortBase=(x) -> unsigned int
3258
3259 Set new value for attribute.
3260
3261 */
3262 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_tcpPortBase_set(int argc,VALUE * argv,VALUE self)3263 _wrap_OpalParamGeneral_m_tcpPortBase_set(int argc, VALUE *argv, VALUE self) {
3264 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3265 unsigned int arg2 ;
3266 void *argp1 = 0 ;
3267 int res1 = 0 ;
3268 unsigned int val2 ;
3269 int ecode2 = 0 ;
3270
3271 if ((argc < 1) || (argc > 1)) {
3272 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3273 }
3274 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3275 if (!SWIG_IsOK(res1)) {
3276 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_tcpPortBase", 1, self ));
3277 }
3278 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3279 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
3280 if (!SWIG_IsOK(ecode2)) {
3281 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_tcpPortBase", 2, argv[0] ));
3282 }
3283 arg2 = static_cast< unsigned int >(val2);
3284 if (arg1) (arg1)->m_tcpPortBase = arg2;
3285 return Qnil;
3286 fail:
3287 return Qnil;
3288 }
3289
3290
3291 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_tcpPortBase_get(int argc,VALUE * argv,VALUE self)3292 _wrap_OpalParamGeneral_m_tcpPortBase_get(int argc, VALUE *argv, VALUE self) {
3293 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3294 void *argp1 = 0 ;
3295 int res1 = 0 ;
3296 unsigned int result;
3297 VALUE vresult = Qnil;
3298
3299 if ((argc < 0) || (argc > 0)) {
3300 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3301 }
3302 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3303 if (!SWIG_IsOK(res1)) {
3304 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_tcpPortBase", 1, self ));
3305 }
3306 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3307 result = (unsigned int) ((arg1)->m_tcpPortBase);
3308 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
3309 return vresult;
3310 fail:
3311 return Qnil;
3312 }
3313
3314
3315
3316 /*
3317 Document-method: Opal::OpalParamGeneral.m_tcpPortMax
3318
3319 call-seq:
3320 m_tcpPortMax -> unsigned int
3321
3322 Get value of attribute.
3323
3324 */
3325
3326 /*
3327 Document-method: Opal::OpalParamGeneral.m_tcpPortMax=
3328
3329 call-seq:
3330 m_tcpPortMax=(x) -> unsigned int
3331
3332 Set new value for attribute.
3333
3334 */
3335 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_tcpPortMax_set(int argc,VALUE * argv,VALUE self)3336 _wrap_OpalParamGeneral_m_tcpPortMax_set(int argc, VALUE *argv, VALUE self) {
3337 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3338 unsigned int arg2 ;
3339 void *argp1 = 0 ;
3340 int res1 = 0 ;
3341 unsigned int val2 ;
3342 int ecode2 = 0 ;
3343
3344 if ((argc < 1) || (argc > 1)) {
3345 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3346 }
3347 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3348 if (!SWIG_IsOK(res1)) {
3349 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_tcpPortMax", 1, self ));
3350 }
3351 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3352 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
3353 if (!SWIG_IsOK(ecode2)) {
3354 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_tcpPortMax", 2, argv[0] ));
3355 }
3356 arg2 = static_cast< unsigned int >(val2);
3357 if (arg1) (arg1)->m_tcpPortMax = arg2;
3358 return Qnil;
3359 fail:
3360 return Qnil;
3361 }
3362
3363
3364 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_tcpPortMax_get(int argc,VALUE * argv,VALUE self)3365 _wrap_OpalParamGeneral_m_tcpPortMax_get(int argc, VALUE *argv, VALUE self) {
3366 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3367 void *argp1 = 0 ;
3368 int res1 = 0 ;
3369 unsigned int result;
3370 VALUE vresult = Qnil;
3371
3372 if ((argc < 0) || (argc > 0)) {
3373 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3374 }
3375 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3376 if (!SWIG_IsOK(res1)) {
3377 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_tcpPortMax", 1, self ));
3378 }
3379 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3380 result = (unsigned int) ((arg1)->m_tcpPortMax);
3381 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
3382 return vresult;
3383 fail:
3384 return Qnil;
3385 }
3386
3387
3388
3389 /*
3390 Document-method: Opal::OpalParamGeneral.m_udpPortBase
3391
3392 call-seq:
3393 m_udpPortBase -> unsigned int
3394
3395 Get value of attribute.
3396
3397 */
3398
3399 /*
3400 Document-method: Opal::OpalParamGeneral.m_udpPortBase=
3401
3402 call-seq:
3403 m_udpPortBase=(x) -> unsigned int
3404
3405 Set new value for attribute.
3406
3407 */
3408 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_udpPortBase_set(int argc,VALUE * argv,VALUE self)3409 _wrap_OpalParamGeneral_m_udpPortBase_set(int argc, VALUE *argv, VALUE self) {
3410 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3411 unsigned int arg2 ;
3412 void *argp1 = 0 ;
3413 int res1 = 0 ;
3414 unsigned int val2 ;
3415 int ecode2 = 0 ;
3416
3417 if ((argc < 1) || (argc > 1)) {
3418 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3419 }
3420 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3421 if (!SWIG_IsOK(res1)) {
3422 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_udpPortBase", 1, self ));
3423 }
3424 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3425 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
3426 if (!SWIG_IsOK(ecode2)) {
3427 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_udpPortBase", 2, argv[0] ));
3428 }
3429 arg2 = static_cast< unsigned int >(val2);
3430 if (arg1) (arg1)->m_udpPortBase = arg2;
3431 return Qnil;
3432 fail:
3433 return Qnil;
3434 }
3435
3436
3437 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_udpPortBase_get(int argc,VALUE * argv,VALUE self)3438 _wrap_OpalParamGeneral_m_udpPortBase_get(int argc, VALUE *argv, VALUE self) {
3439 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3440 void *argp1 = 0 ;
3441 int res1 = 0 ;
3442 unsigned int result;
3443 VALUE vresult = Qnil;
3444
3445 if ((argc < 0) || (argc > 0)) {
3446 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3447 }
3448 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3449 if (!SWIG_IsOK(res1)) {
3450 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_udpPortBase", 1, self ));
3451 }
3452 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3453 result = (unsigned int) ((arg1)->m_udpPortBase);
3454 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
3455 return vresult;
3456 fail:
3457 return Qnil;
3458 }
3459
3460
3461
3462 /*
3463 Document-method: Opal::OpalParamGeneral.m_udpPortMax
3464
3465 call-seq:
3466 m_udpPortMax -> unsigned int
3467
3468 Get value of attribute.
3469
3470 */
3471
3472 /*
3473 Document-method: Opal::OpalParamGeneral.m_udpPortMax=
3474
3475 call-seq:
3476 m_udpPortMax=(x) -> unsigned int
3477
3478 Set new value for attribute.
3479
3480 */
3481 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_udpPortMax_set(int argc,VALUE * argv,VALUE self)3482 _wrap_OpalParamGeneral_m_udpPortMax_set(int argc, VALUE *argv, VALUE self) {
3483 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3484 unsigned int arg2 ;
3485 void *argp1 = 0 ;
3486 int res1 = 0 ;
3487 unsigned int val2 ;
3488 int ecode2 = 0 ;
3489
3490 if ((argc < 1) || (argc > 1)) {
3491 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3492 }
3493 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3494 if (!SWIG_IsOK(res1)) {
3495 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_udpPortMax", 1, self ));
3496 }
3497 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3498 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
3499 if (!SWIG_IsOK(ecode2)) {
3500 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_udpPortMax", 2, argv[0] ));
3501 }
3502 arg2 = static_cast< unsigned int >(val2);
3503 if (arg1) (arg1)->m_udpPortMax = arg2;
3504 return Qnil;
3505 fail:
3506 return Qnil;
3507 }
3508
3509
3510 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_udpPortMax_get(int argc,VALUE * argv,VALUE self)3511 _wrap_OpalParamGeneral_m_udpPortMax_get(int argc, VALUE *argv, VALUE self) {
3512 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3513 void *argp1 = 0 ;
3514 int res1 = 0 ;
3515 unsigned int result;
3516 VALUE vresult = Qnil;
3517
3518 if ((argc < 0) || (argc > 0)) {
3519 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3520 }
3521 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3522 if (!SWIG_IsOK(res1)) {
3523 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_udpPortMax", 1, self ));
3524 }
3525 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3526 result = (unsigned int) ((arg1)->m_udpPortMax);
3527 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
3528 return vresult;
3529 fail:
3530 return Qnil;
3531 }
3532
3533
3534
3535 /*
3536 Document-method: Opal::OpalParamGeneral.m_rtpPortBase
3537
3538 call-seq:
3539 m_rtpPortBase -> unsigned int
3540
3541 Get value of attribute.
3542
3543 */
3544
3545 /*
3546 Document-method: Opal::OpalParamGeneral.m_rtpPortBase=
3547
3548 call-seq:
3549 m_rtpPortBase=(x) -> unsigned int
3550
3551 Set new value for attribute.
3552
3553 */
3554 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_rtpPortBase_set(int argc,VALUE * argv,VALUE self)3555 _wrap_OpalParamGeneral_m_rtpPortBase_set(int argc, VALUE *argv, VALUE self) {
3556 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3557 unsigned int arg2 ;
3558 void *argp1 = 0 ;
3559 int res1 = 0 ;
3560 unsigned int val2 ;
3561 int ecode2 = 0 ;
3562
3563 if ((argc < 1) || (argc > 1)) {
3564 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3565 }
3566 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3567 if (!SWIG_IsOK(res1)) {
3568 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_rtpPortBase", 1, self ));
3569 }
3570 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3571 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
3572 if (!SWIG_IsOK(ecode2)) {
3573 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_rtpPortBase", 2, argv[0] ));
3574 }
3575 arg2 = static_cast< unsigned int >(val2);
3576 if (arg1) (arg1)->m_rtpPortBase = arg2;
3577 return Qnil;
3578 fail:
3579 return Qnil;
3580 }
3581
3582
3583 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_rtpPortBase_get(int argc,VALUE * argv,VALUE self)3584 _wrap_OpalParamGeneral_m_rtpPortBase_get(int argc, VALUE *argv, VALUE self) {
3585 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3586 void *argp1 = 0 ;
3587 int res1 = 0 ;
3588 unsigned int result;
3589 VALUE vresult = Qnil;
3590
3591 if ((argc < 0) || (argc > 0)) {
3592 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3593 }
3594 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3595 if (!SWIG_IsOK(res1)) {
3596 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_rtpPortBase", 1, self ));
3597 }
3598 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3599 result = (unsigned int) ((arg1)->m_rtpPortBase);
3600 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
3601 return vresult;
3602 fail:
3603 return Qnil;
3604 }
3605
3606
3607
3608 /*
3609 Document-method: Opal::OpalParamGeneral.m_rtpPortMax
3610
3611 call-seq:
3612 m_rtpPortMax -> unsigned int
3613
3614 Get value of attribute.
3615
3616 */
3617
3618 /*
3619 Document-method: Opal::OpalParamGeneral.m_rtpPortMax=
3620
3621 call-seq:
3622 m_rtpPortMax=(x) -> unsigned int
3623
3624 Set new value for attribute.
3625
3626 */
3627 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_rtpPortMax_set(int argc,VALUE * argv,VALUE self)3628 _wrap_OpalParamGeneral_m_rtpPortMax_set(int argc, VALUE *argv, VALUE self) {
3629 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3630 unsigned int arg2 ;
3631 void *argp1 = 0 ;
3632 int res1 = 0 ;
3633 unsigned int val2 ;
3634 int ecode2 = 0 ;
3635
3636 if ((argc < 1) || (argc > 1)) {
3637 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3638 }
3639 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3640 if (!SWIG_IsOK(res1)) {
3641 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_rtpPortMax", 1, self ));
3642 }
3643 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3644 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
3645 if (!SWIG_IsOK(ecode2)) {
3646 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_rtpPortMax", 2, argv[0] ));
3647 }
3648 arg2 = static_cast< unsigned int >(val2);
3649 if (arg1) (arg1)->m_rtpPortMax = arg2;
3650 return Qnil;
3651 fail:
3652 return Qnil;
3653 }
3654
3655
3656 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_rtpPortMax_get(int argc,VALUE * argv,VALUE self)3657 _wrap_OpalParamGeneral_m_rtpPortMax_get(int argc, VALUE *argv, VALUE self) {
3658 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3659 void *argp1 = 0 ;
3660 int res1 = 0 ;
3661 unsigned int result;
3662 VALUE vresult = Qnil;
3663
3664 if ((argc < 0) || (argc > 0)) {
3665 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3666 }
3667 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3668 if (!SWIG_IsOK(res1)) {
3669 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_rtpPortMax", 1, self ));
3670 }
3671 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3672 result = (unsigned int) ((arg1)->m_rtpPortMax);
3673 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
3674 return vresult;
3675 fail:
3676 return Qnil;
3677 }
3678
3679
3680
3681 /*
3682 Document-method: Opal::OpalParamGeneral.m_rtpTypeOfService
3683
3684 call-seq:
3685 m_rtpTypeOfService -> unsigned int
3686
3687 Get value of attribute.
3688
3689 */
3690
3691 /*
3692 Document-method: Opal::OpalParamGeneral.m_rtpTypeOfService=
3693
3694 call-seq:
3695 m_rtpTypeOfService=(x) -> unsigned int
3696
3697 Set new value for attribute.
3698
3699 */
3700 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_rtpTypeOfService_set(int argc,VALUE * argv,VALUE self)3701 _wrap_OpalParamGeneral_m_rtpTypeOfService_set(int argc, VALUE *argv, VALUE self) {
3702 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3703 unsigned int arg2 ;
3704 void *argp1 = 0 ;
3705 int res1 = 0 ;
3706 unsigned int val2 ;
3707 int ecode2 = 0 ;
3708
3709 if ((argc < 1) || (argc > 1)) {
3710 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3711 }
3712 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3713 if (!SWIG_IsOK(res1)) {
3714 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_rtpTypeOfService", 1, self ));
3715 }
3716 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3717 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
3718 if (!SWIG_IsOK(ecode2)) {
3719 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_rtpTypeOfService", 2, argv[0] ));
3720 }
3721 arg2 = static_cast< unsigned int >(val2);
3722 if (arg1) (arg1)->m_rtpTypeOfService = arg2;
3723 return Qnil;
3724 fail:
3725 return Qnil;
3726 }
3727
3728
3729 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_rtpTypeOfService_get(int argc,VALUE * argv,VALUE self)3730 _wrap_OpalParamGeneral_m_rtpTypeOfService_get(int argc, VALUE *argv, VALUE self) {
3731 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3732 void *argp1 = 0 ;
3733 int res1 = 0 ;
3734 unsigned int result;
3735 VALUE vresult = Qnil;
3736
3737 if ((argc < 0) || (argc > 0)) {
3738 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3739 }
3740 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3741 if (!SWIG_IsOK(res1)) {
3742 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_rtpTypeOfService", 1, self ));
3743 }
3744 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3745 result = (unsigned int) ((arg1)->m_rtpTypeOfService);
3746 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
3747 return vresult;
3748 fail:
3749 return Qnil;
3750 }
3751
3752
3753
3754 /*
3755 Document-method: Opal::OpalParamGeneral.m_rtpMaxPayloadSize
3756
3757 call-seq:
3758 m_rtpMaxPayloadSize -> unsigned int
3759
3760 Get value of attribute.
3761
3762 */
3763
3764 /*
3765 Document-method: Opal::OpalParamGeneral.m_rtpMaxPayloadSize=
3766
3767 call-seq:
3768 m_rtpMaxPayloadSize=(x) -> unsigned int
3769
3770 Set new value for attribute.
3771
3772 */
3773 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_rtpMaxPayloadSize_set(int argc,VALUE * argv,VALUE self)3774 _wrap_OpalParamGeneral_m_rtpMaxPayloadSize_set(int argc, VALUE *argv, VALUE self) {
3775 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3776 unsigned int arg2 ;
3777 void *argp1 = 0 ;
3778 int res1 = 0 ;
3779 unsigned int val2 ;
3780 int ecode2 = 0 ;
3781
3782 if ((argc < 1) || (argc > 1)) {
3783 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3784 }
3785 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3786 if (!SWIG_IsOK(res1)) {
3787 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_rtpMaxPayloadSize", 1, self ));
3788 }
3789 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3790 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
3791 if (!SWIG_IsOK(ecode2)) {
3792 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_rtpMaxPayloadSize", 2, argv[0] ));
3793 }
3794 arg2 = static_cast< unsigned int >(val2);
3795 if (arg1) (arg1)->m_rtpMaxPayloadSize = arg2;
3796 return Qnil;
3797 fail:
3798 return Qnil;
3799 }
3800
3801
3802 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_rtpMaxPayloadSize_get(int argc,VALUE * argv,VALUE self)3803 _wrap_OpalParamGeneral_m_rtpMaxPayloadSize_get(int argc, VALUE *argv, VALUE self) {
3804 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3805 void *argp1 = 0 ;
3806 int res1 = 0 ;
3807 unsigned int result;
3808 VALUE vresult = Qnil;
3809
3810 if ((argc < 0) || (argc > 0)) {
3811 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3812 }
3813 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3814 if (!SWIG_IsOK(res1)) {
3815 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_rtpMaxPayloadSize", 1, self ));
3816 }
3817 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3818 result = (unsigned int) ((arg1)->m_rtpMaxPayloadSize);
3819 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
3820 return vresult;
3821 fail:
3822 return Qnil;
3823 }
3824
3825
3826
3827 /*
3828 Document-method: Opal::OpalParamGeneral.m_minAudioJitter
3829
3830 call-seq:
3831 m_minAudioJitter -> unsigned int
3832
3833 Get value of attribute.
3834
3835 */
3836
3837 /*
3838 Document-method: Opal::OpalParamGeneral.m_minAudioJitter=
3839
3840 call-seq:
3841 m_minAudioJitter=(x) -> unsigned int
3842
3843 Set new value for attribute.
3844
3845 */
3846 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_minAudioJitter_set(int argc,VALUE * argv,VALUE self)3847 _wrap_OpalParamGeneral_m_minAudioJitter_set(int argc, VALUE *argv, VALUE self) {
3848 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3849 unsigned int arg2 ;
3850 void *argp1 = 0 ;
3851 int res1 = 0 ;
3852 unsigned int val2 ;
3853 int ecode2 = 0 ;
3854
3855 if ((argc < 1) || (argc > 1)) {
3856 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3857 }
3858 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3859 if (!SWIG_IsOK(res1)) {
3860 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_minAudioJitter", 1, self ));
3861 }
3862 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3863 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
3864 if (!SWIG_IsOK(ecode2)) {
3865 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_minAudioJitter", 2, argv[0] ));
3866 }
3867 arg2 = static_cast< unsigned int >(val2);
3868 if (arg1) (arg1)->m_minAudioJitter = arg2;
3869 return Qnil;
3870 fail:
3871 return Qnil;
3872 }
3873
3874
3875 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_minAudioJitter_get(int argc,VALUE * argv,VALUE self)3876 _wrap_OpalParamGeneral_m_minAudioJitter_get(int argc, VALUE *argv, VALUE self) {
3877 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3878 void *argp1 = 0 ;
3879 int res1 = 0 ;
3880 unsigned int result;
3881 VALUE vresult = Qnil;
3882
3883 if ((argc < 0) || (argc > 0)) {
3884 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3885 }
3886 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3887 if (!SWIG_IsOK(res1)) {
3888 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_minAudioJitter", 1, self ));
3889 }
3890 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3891 result = (unsigned int) ((arg1)->m_minAudioJitter);
3892 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
3893 return vresult;
3894 fail:
3895 return Qnil;
3896 }
3897
3898
3899
3900 /*
3901 Document-method: Opal::OpalParamGeneral.m_maxAudioJitter
3902
3903 call-seq:
3904 m_maxAudioJitter -> unsigned int
3905
3906 Get value of attribute.
3907
3908 */
3909
3910 /*
3911 Document-method: Opal::OpalParamGeneral.m_maxAudioJitter=
3912
3913 call-seq:
3914 m_maxAudioJitter=(x) -> unsigned int
3915
3916 Set new value for attribute.
3917
3918 */
3919 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_maxAudioJitter_set(int argc,VALUE * argv,VALUE self)3920 _wrap_OpalParamGeneral_m_maxAudioJitter_set(int argc, VALUE *argv, VALUE self) {
3921 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3922 unsigned int arg2 ;
3923 void *argp1 = 0 ;
3924 int res1 = 0 ;
3925 unsigned int val2 ;
3926 int ecode2 = 0 ;
3927
3928 if ((argc < 1) || (argc > 1)) {
3929 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3930 }
3931 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3932 if (!SWIG_IsOK(res1)) {
3933 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_maxAudioJitter", 1, self ));
3934 }
3935 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3936 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
3937 if (!SWIG_IsOK(ecode2)) {
3938 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_maxAudioJitter", 2, argv[0] ));
3939 }
3940 arg2 = static_cast< unsigned int >(val2);
3941 if (arg1) (arg1)->m_maxAudioJitter = arg2;
3942 return Qnil;
3943 fail:
3944 return Qnil;
3945 }
3946
3947
3948 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_maxAudioJitter_get(int argc,VALUE * argv,VALUE self)3949 _wrap_OpalParamGeneral_m_maxAudioJitter_get(int argc, VALUE *argv, VALUE self) {
3950 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3951 void *argp1 = 0 ;
3952 int res1 = 0 ;
3953 unsigned int result;
3954 VALUE vresult = Qnil;
3955
3956 if ((argc < 0) || (argc > 0)) {
3957 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3958 }
3959 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
3960 if (!SWIG_IsOK(res1)) {
3961 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_maxAudioJitter", 1, self ));
3962 }
3963 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
3964 result = (unsigned int) ((arg1)->m_maxAudioJitter);
3965 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
3966 return vresult;
3967 fail:
3968 return Qnil;
3969 }
3970
3971
3972
3973 /*
3974 Document-method: Opal::OpalParamGeneral.m_silenceDetectMode
3975
3976 call-seq:
3977 m_silenceDetectMode -> int
3978
3979 Get value of attribute.
3980
3981 */
3982
3983 /*
3984 Document-method: Opal::OpalParamGeneral.m_silenceDetectMode=
3985
3986 call-seq:
3987 m_silenceDetectMode=(x) -> int
3988
3989 Set new value for attribute.
3990
3991 */
3992 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_silenceDetectMode_set(int argc,VALUE * argv,VALUE self)3993 _wrap_OpalParamGeneral_m_silenceDetectMode_set(int argc, VALUE *argv, VALUE self) {
3994 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
3995 OpalSilenceDetectMode arg2 ;
3996 void *argp1 = 0 ;
3997 int res1 = 0 ;
3998 int val2 ;
3999 int ecode2 = 0 ;
4000
4001 if ((argc < 1) || (argc > 1)) {
4002 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4003 }
4004 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4005 if (!SWIG_IsOK(res1)) {
4006 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_silenceDetectMode", 1, self ));
4007 }
4008 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4009 ecode2 = SWIG_AsVal_int(argv[0], &val2);
4010 if (!SWIG_IsOK(ecode2)) {
4011 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalSilenceDetectMode","m_silenceDetectMode", 2, argv[0] ));
4012 }
4013 arg2 = static_cast< OpalSilenceDetectMode >(val2);
4014 if (arg1) (arg1)->m_silenceDetectMode = arg2;
4015 return Qnil;
4016 fail:
4017 return Qnil;
4018 }
4019
4020
4021 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_silenceDetectMode_get(int argc,VALUE * argv,VALUE self)4022 _wrap_OpalParamGeneral_m_silenceDetectMode_get(int argc, VALUE *argv, VALUE self) {
4023 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4024 void *argp1 = 0 ;
4025 int res1 = 0 ;
4026 OpalSilenceDetectMode result;
4027 VALUE vresult = Qnil;
4028
4029 if ((argc < 0) || (argc > 0)) {
4030 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4031 }
4032 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4033 if (!SWIG_IsOK(res1)) {
4034 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_silenceDetectMode", 1, self ));
4035 }
4036 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4037 result = (OpalSilenceDetectMode) ((arg1)->m_silenceDetectMode);
4038 vresult = SWIG_From_int(static_cast< int >(result));
4039 return vresult;
4040 fail:
4041 return Qnil;
4042 }
4043
4044
4045
4046 /*
4047 Document-method: Opal::OpalParamGeneral.m_silenceThreshold
4048
4049 call-seq:
4050 m_silenceThreshold -> unsigned int
4051
4052 Get value of attribute.
4053
4054 */
4055
4056 /*
4057 Document-method: Opal::OpalParamGeneral.m_silenceThreshold=
4058
4059 call-seq:
4060 m_silenceThreshold=(x) -> unsigned int
4061
4062 Set new value for attribute.
4063
4064 */
4065 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_silenceThreshold_set(int argc,VALUE * argv,VALUE self)4066 _wrap_OpalParamGeneral_m_silenceThreshold_set(int argc, VALUE *argv, VALUE self) {
4067 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4068 unsigned int arg2 ;
4069 void *argp1 = 0 ;
4070 int res1 = 0 ;
4071 unsigned int val2 ;
4072 int ecode2 = 0 ;
4073
4074 if ((argc < 1) || (argc > 1)) {
4075 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4076 }
4077 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4078 if (!SWIG_IsOK(res1)) {
4079 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_silenceThreshold", 1, self ));
4080 }
4081 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4082 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
4083 if (!SWIG_IsOK(ecode2)) {
4084 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_silenceThreshold", 2, argv[0] ));
4085 }
4086 arg2 = static_cast< unsigned int >(val2);
4087 if (arg1) (arg1)->m_silenceThreshold = arg2;
4088 return Qnil;
4089 fail:
4090 return Qnil;
4091 }
4092
4093
4094 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_silenceThreshold_get(int argc,VALUE * argv,VALUE self)4095 _wrap_OpalParamGeneral_m_silenceThreshold_get(int argc, VALUE *argv, VALUE self) {
4096 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4097 void *argp1 = 0 ;
4098 int res1 = 0 ;
4099 unsigned int result;
4100 VALUE vresult = Qnil;
4101
4102 if ((argc < 0) || (argc > 0)) {
4103 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4104 }
4105 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4106 if (!SWIG_IsOK(res1)) {
4107 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_silenceThreshold", 1, self ));
4108 }
4109 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4110 result = (unsigned int) ((arg1)->m_silenceThreshold);
4111 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
4112 return vresult;
4113 fail:
4114 return Qnil;
4115 }
4116
4117
4118
4119 /*
4120 Document-method: Opal::OpalParamGeneral.m_signalDeadband
4121
4122 call-seq:
4123 m_signalDeadband -> unsigned int
4124
4125 Get value of attribute.
4126
4127 */
4128
4129 /*
4130 Document-method: Opal::OpalParamGeneral.m_signalDeadband=
4131
4132 call-seq:
4133 m_signalDeadband=(x) -> unsigned int
4134
4135 Set new value for attribute.
4136
4137 */
4138 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_signalDeadband_set(int argc,VALUE * argv,VALUE self)4139 _wrap_OpalParamGeneral_m_signalDeadband_set(int argc, VALUE *argv, VALUE self) {
4140 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4141 unsigned int arg2 ;
4142 void *argp1 = 0 ;
4143 int res1 = 0 ;
4144 unsigned int val2 ;
4145 int ecode2 = 0 ;
4146
4147 if ((argc < 1) || (argc > 1)) {
4148 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4149 }
4150 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4151 if (!SWIG_IsOK(res1)) {
4152 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_signalDeadband", 1, self ));
4153 }
4154 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4155 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
4156 if (!SWIG_IsOK(ecode2)) {
4157 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_signalDeadband", 2, argv[0] ));
4158 }
4159 arg2 = static_cast< unsigned int >(val2);
4160 if (arg1) (arg1)->m_signalDeadband = arg2;
4161 return Qnil;
4162 fail:
4163 return Qnil;
4164 }
4165
4166
4167 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_signalDeadband_get(int argc,VALUE * argv,VALUE self)4168 _wrap_OpalParamGeneral_m_signalDeadband_get(int argc, VALUE *argv, VALUE self) {
4169 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4170 void *argp1 = 0 ;
4171 int res1 = 0 ;
4172 unsigned int result;
4173 VALUE vresult = Qnil;
4174
4175 if ((argc < 0) || (argc > 0)) {
4176 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4177 }
4178 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4179 if (!SWIG_IsOK(res1)) {
4180 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_signalDeadband", 1, self ));
4181 }
4182 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4183 result = (unsigned int) ((arg1)->m_signalDeadband);
4184 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
4185 return vresult;
4186 fail:
4187 return Qnil;
4188 }
4189
4190
4191
4192 /*
4193 Document-method: Opal::OpalParamGeneral.m_silenceDeadband
4194
4195 call-seq:
4196 m_silenceDeadband -> unsigned int
4197
4198 Get value of attribute.
4199
4200 */
4201
4202 /*
4203 Document-method: Opal::OpalParamGeneral.m_silenceDeadband=
4204
4205 call-seq:
4206 m_silenceDeadband=(x) -> unsigned int
4207
4208 Set new value for attribute.
4209
4210 */
4211 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_silenceDeadband_set(int argc,VALUE * argv,VALUE self)4212 _wrap_OpalParamGeneral_m_silenceDeadband_set(int argc, VALUE *argv, VALUE self) {
4213 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4214 unsigned int arg2 ;
4215 void *argp1 = 0 ;
4216 int res1 = 0 ;
4217 unsigned int val2 ;
4218 int ecode2 = 0 ;
4219
4220 if ((argc < 1) || (argc > 1)) {
4221 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4222 }
4223 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4224 if (!SWIG_IsOK(res1)) {
4225 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_silenceDeadband", 1, self ));
4226 }
4227 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4228 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
4229 if (!SWIG_IsOK(ecode2)) {
4230 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_silenceDeadband", 2, argv[0] ));
4231 }
4232 arg2 = static_cast< unsigned int >(val2);
4233 if (arg1) (arg1)->m_silenceDeadband = arg2;
4234 return Qnil;
4235 fail:
4236 return Qnil;
4237 }
4238
4239
4240 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_silenceDeadband_get(int argc,VALUE * argv,VALUE self)4241 _wrap_OpalParamGeneral_m_silenceDeadband_get(int argc, VALUE *argv, VALUE self) {
4242 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4243 void *argp1 = 0 ;
4244 int res1 = 0 ;
4245 unsigned int result;
4246 VALUE vresult = Qnil;
4247
4248 if ((argc < 0) || (argc > 0)) {
4249 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4250 }
4251 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4252 if (!SWIG_IsOK(res1)) {
4253 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_silenceDeadband", 1, self ));
4254 }
4255 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4256 result = (unsigned int) ((arg1)->m_silenceDeadband);
4257 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
4258 return vresult;
4259 fail:
4260 return Qnil;
4261 }
4262
4263
4264
4265 /*
4266 Document-method: Opal::OpalParamGeneral.m_silenceAdaptPeriod
4267
4268 call-seq:
4269 m_silenceAdaptPeriod -> unsigned int
4270
4271 Get value of attribute.
4272
4273 */
4274
4275 /*
4276 Document-method: Opal::OpalParamGeneral.m_silenceAdaptPeriod=
4277
4278 call-seq:
4279 m_silenceAdaptPeriod=(x) -> unsigned int
4280
4281 Set new value for attribute.
4282
4283 */
4284 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_silenceAdaptPeriod_set(int argc,VALUE * argv,VALUE self)4285 _wrap_OpalParamGeneral_m_silenceAdaptPeriod_set(int argc, VALUE *argv, VALUE self) {
4286 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4287 unsigned int arg2 ;
4288 void *argp1 = 0 ;
4289 int res1 = 0 ;
4290 unsigned int val2 ;
4291 int ecode2 = 0 ;
4292
4293 if ((argc < 1) || (argc > 1)) {
4294 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4295 }
4296 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4297 if (!SWIG_IsOK(res1)) {
4298 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_silenceAdaptPeriod", 1, self ));
4299 }
4300 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4301 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
4302 if (!SWIG_IsOK(ecode2)) {
4303 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_silenceAdaptPeriod", 2, argv[0] ));
4304 }
4305 arg2 = static_cast< unsigned int >(val2);
4306 if (arg1) (arg1)->m_silenceAdaptPeriod = arg2;
4307 return Qnil;
4308 fail:
4309 return Qnil;
4310 }
4311
4312
4313 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_silenceAdaptPeriod_get(int argc,VALUE * argv,VALUE self)4314 _wrap_OpalParamGeneral_m_silenceAdaptPeriod_get(int argc, VALUE *argv, VALUE self) {
4315 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4316 void *argp1 = 0 ;
4317 int res1 = 0 ;
4318 unsigned int result;
4319 VALUE vresult = Qnil;
4320
4321 if ((argc < 0) || (argc > 0)) {
4322 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4323 }
4324 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4325 if (!SWIG_IsOK(res1)) {
4326 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_silenceAdaptPeriod", 1, self ));
4327 }
4328 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4329 result = (unsigned int) ((arg1)->m_silenceAdaptPeriod);
4330 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
4331 return vresult;
4332 fail:
4333 return Qnil;
4334 }
4335
4336
4337
4338 /*
4339 Document-method: Opal::OpalParamGeneral.m_echoCancellation
4340
4341 call-seq:
4342 m_echoCancellation -> int
4343
4344 Get value of attribute.
4345
4346 */
4347
4348 /*
4349 Document-method: Opal::OpalParamGeneral.m_echoCancellation=
4350
4351 call-seq:
4352 m_echoCancellation=(x) -> int
4353
4354 Set new value for attribute.
4355
4356 */
4357 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_echoCancellation_set(int argc,VALUE * argv,VALUE self)4358 _wrap_OpalParamGeneral_m_echoCancellation_set(int argc, VALUE *argv, VALUE self) {
4359 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4360 OpalEchoCancelMode arg2 ;
4361 void *argp1 = 0 ;
4362 int res1 = 0 ;
4363 int val2 ;
4364 int ecode2 = 0 ;
4365
4366 if ((argc < 1) || (argc > 1)) {
4367 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4368 }
4369 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4370 if (!SWIG_IsOK(res1)) {
4371 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_echoCancellation", 1, self ));
4372 }
4373 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4374 ecode2 = SWIG_AsVal_int(argv[0], &val2);
4375 if (!SWIG_IsOK(ecode2)) {
4376 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalEchoCancelMode","m_echoCancellation", 2, argv[0] ));
4377 }
4378 arg2 = static_cast< OpalEchoCancelMode >(val2);
4379 if (arg1) (arg1)->m_echoCancellation = arg2;
4380 return Qnil;
4381 fail:
4382 return Qnil;
4383 }
4384
4385
4386 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_echoCancellation_get(int argc,VALUE * argv,VALUE self)4387 _wrap_OpalParamGeneral_m_echoCancellation_get(int argc, VALUE *argv, VALUE self) {
4388 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4389 void *argp1 = 0 ;
4390 int res1 = 0 ;
4391 OpalEchoCancelMode result;
4392 VALUE vresult = Qnil;
4393
4394 if ((argc < 0) || (argc > 0)) {
4395 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4396 }
4397 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4398 if (!SWIG_IsOK(res1)) {
4399 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_echoCancellation", 1, self ));
4400 }
4401 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4402 result = (OpalEchoCancelMode) ((arg1)->m_echoCancellation);
4403 vresult = SWIG_From_int(static_cast< int >(result));
4404 return vresult;
4405 fail:
4406 return Qnil;
4407 }
4408
4409
4410
4411 /*
4412 Document-method: Opal::OpalParamGeneral.m_audioBuffers
4413
4414 call-seq:
4415 m_audioBuffers -> unsigned int
4416
4417 Get value of attribute.
4418
4419 */
4420
4421 /*
4422 Document-method: Opal::OpalParamGeneral.m_audioBuffers=
4423
4424 call-seq:
4425 m_audioBuffers=(x) -> unsigned int
4426
4427 Set new value for attribute.
4428
4429 */
4430 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_audioBuffers_set(int argc,VALUE * argv,VALUE self)4431 _wrap_OpalParamGeneral_m_audioBuffers_set(int argc, VALUE *argv, VALUE self) {
4432 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4433 unsigned int arg2 ;
4434 void *argp1 = 0 ;
4435 int res1 = 0 ;
4436 unsigned int val2 ;
4437 int ecode2 = 0 ;
4438
4439 if ((argc < 1) || (argc > 1)) {
4440 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4441 }
4442 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4443 if (!SWIG_IsOK(res1)) {
4444 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_audioBuffers", 1, self ));
4445 }
4446 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4447 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
4448 if (!SWIG_IsOK(ecode2)) {
4449 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_audioBuffers", 2, argv[0] ));
4450 }
4451 arg2 = static_cast< unsigned int >(val2);
4452 if (arg1) (arg1)->m_audioBuffers = arg2;
4453 return Qnil;
4454 fail:
4455 return Qnil;
4456 }
4457
4458
4459 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_audioBuffers_get(int argc,VALUE * argv,VALUE self)4460 _wrap_OpalParamGeneral_m_audioBuffers_get(int argc, VALUE *argv, VALUE self) {
4461 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4462 void *argp1 = 0 ;
4463 int res1 = 0 ;
4464 unsigned int result;
4465 VALUE vresult = Qnil;
4466
4467 if ((argc < 0) || (argc > 0)) {
4468 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4469 }
4470 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4471 if (!SWIG_IsOK(res1)) {
4472 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_audioBuffers", 1, self ));
4473 }
4474 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4475 result = (unsigned int) ((arg1)->m_audioBuffers);
4476 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
4477 return vresult;
4478 fail:
4479 return Qnil;
4480 }
4481
4482
4483
4484 /*
4485 Document-method: Opal::OpalParamGeneral.m_mediaReadData
4486
4487 call-seq:
4488 m_mediaReadData -> OpalMediaDataFunction
4489
4490 Get value of attribute.
4491
4492 */
4493
4494 /*
4495 Document-method: Opal::OpalParamGeneral.m_mediaReadData=
4496
4497 call-seq:
4498 m_mediaReadData=(x) -> OpalMediaDataFunction
4499
4500 Set new value for attribute.
4501
4502 */
4503 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaReadData_set(int argc,VALUE * argv,VALUE self)4504 _wrap_OpalParamGeneral_m_mediaReadData_set(int argc, VALUE *argv, VALUE self) {
4505 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4506 OpalMediaDataFunction arg2 = (OpalMediaDataFunction) 0 ;
4507 void *argp1 = 0 ;
4508 int res1 = 0 ;
4509
4510 if ((argc < 1) || (argc > 1)) {
4511 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4512 }
4513 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4514 if (!SWIG_IsOK(res1)) {
4515 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaReadData", 1, self ));
4516 }
4517 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4518 {
4519 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_void_p_void_int__int);
4520 if (!SWIG_IsOK(res)) {
4521 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "OpalMediaDataFunction","m_mediaReadData", 2, argv[0] ));
4522 }
4523 }
4524 if (arg1) (arg1)->m_mediaReadData = arg2;
4525 return Qnil;
4526 fail:
4527 return Qnil;
4528 }
4529
4530
4531 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaReadData_get(int argc,VALUE * argv,VALUE self)4532 _wrap_OpalParamGeneral_m_mediaReadData_get(int argc, VALUE *argv, VALUE self) {
4533 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4534 void *argp1 = 0 ;
4535 int res1 = 0 ;
4536 OpalMediaDataFunction result;
4537 VALUE vresult = Qnil;
4538
4539 if ((argc < 0) || (argc > 0)) {
4540 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4541 }
4542 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4543 if (!SWIG_IsOK(res1)) {
4544 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaReadData", 1, self ));
4545 }
4546 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4547 result = (OpalMediaDataFunction) ((arg1)->m_mediaReadData);
4548 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_void_p_void_int__int);
4549 return vresult;
4550 fail:
4551 return Qnil;
4552 }
4553
4554
4555
4556 /*
4557 Document-method: Opal::OpalParamGeneral.m_mediaWriteData
4558
4559 call-seq:
4560 m_mediaWriteData -> OpalMediaDataFunction
4561
4562 Get value of attribute.
4563
4564 */
4565
4566 /*
4567 Document-method: Opal::OpalParamGeneral.m_mediaWriteData=
4568
4569 call-seq:
4570 m_mediaWriteData=(x) -> OpalMediaDataFunction
4571
4572 Set new value for attribute.
4573
4574 */
4575 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaWriteData_set(int argc,VALUE * argv,VALUE self)4576 _wrap_OpalParamGeneral_m_mediaWriteData_set(int argc, VALUE *argv, VALUE self) {
4577 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4578 OpalMediaDataFunction arg2 = (OpalMediaDataFunction) 0 ;
4579 void *argp1 = 0 ;
4580 int res1 = 0 ;
4581
4582 if ((argc < 1) || (argc > 1)) {
4583 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4584 }
4585 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4586 if (!SWIG_IsOK(res1)) {
4587 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaWriteData", 1, self ));
4588 }
4589 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4590 {
4591 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_void_p_void_int__int);
4592 if (!SWIG_IsOK(res)) {
4593 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "OpalMediaDataFunction","m_mediaWriteData", 2, argv[0] ));
4594 }
4595 }
4596 if (arg1) (arg1)->m_mediaWriteData = arg2;
4597 return Qnil;
4598 fail:
4599 return Qnil;
4600 }
4601
4602
4603 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaWriteData_get(int argc,VALUE * argv,VALUE self)4604 _wrap_OpalParamGeneral_m_mediaWriteData_get(int argc, VALUE *argv, VALUE self) {
4605 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4606 void *argp1 = 0 ;
4607 int res1 = 0 ;
4608 OpalMediaDataFunction result;
4609 VALUE vresult = Qnil;
4610
4611 if ((argc < 0) || (argc > 0)) {
4612 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4613 }
4614 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4615 if (!SWIG_IsOK(res1)) {
4616 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaWriteData", 1, self ));
4617 }
4618 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4619 result = (OpalMediaDataFunction) ((arg1)->m_mediaWriteData);
4620 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_void_p_void_int__int);
4621 return vresult;
4622 fail:
4623 return Qnil;
4624 }
4625
4626
4627
4628 /*
4629 Document-method: Opal::OpalParamGeneral.m_mediaDataHeader
4630
4631 call-seq:
4632 m_mediaDataHeader -> int
4633
4634 Get value of attribute.
4635
4636 */
4637
4638 /*
4639 Document-method: Opal::OpalParamGeneral.m_mediaDataHeader=
4640
4641 call-seq:
4642 m_mediaDataHeader=(x) -> int
4643
4644 Set new value for attribute.
4645
4646 */
4647 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaDataHeader_set(int argc,VALUE * argv,VALUE self)4648 _wrap_OpalParamGeneral_m_mediaDataHeader_set(int argc, VALUE *argv, VALUE self) {
4649 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4650 OpalMediaDataType arg2 ;
4651 void *argp1 = 0 ;
4652 int res1 = 0 ;
4653 int val2 ;
4654 int ecode2 = 0 ;
4655
4656 if ((argc < 1) || (argc > 1)) {
4657 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4658 }
4659 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4660 if (!SWIG_IsOK(res1)) {
4661 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaDataHeader", 1, self ));
4662 }
4663 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4664 ecode2 = SWIG_AsVal_int(argv[0], &val2);
4665 if (!SWIG_IsOK(ecode2)) {
4666 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalMediaDataType","m_mediaDataHeader", 2, argv[0] ));
4667 }
4668 arg2 = static_cast< OpalMediaDataType >(val2);
4669 if (arg1) (arg1)->m_mediaDataHeader = arg2;
4670 return Qnil;
4671 fail:
4672 return Qnil;
4673 }
4674
4675
4676 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaDataHeader_get(int argc,VALUE * argv,VALUE self)4677 _wrap_OpalParamGeneral_m_mediaDataHeader_get(int argc, VALUE *argv, VALUE self) {
4678 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4679 void *argp1 = 0 ;
4680 int res1 = 0 ;
4681 OpalMediaDataType result;
4682 VALUE vresult = Qnil;
4683
4684 if ((argc < 0) || (argc > 0)) {
4685 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4686 }
4687 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4688 if (!SWIG_IsOK(res1)) {
4689 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaDataHeader", 1, self ));
4690 }
4691 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4692 result = (OpalMediaDataType) ((arg1)->m_mediaDataHeader);
4693 vresult = SWIG_From_int(static_cast< int >(result));
4694 return vresult;
4695 fail:
4696 return Qnil;
4697 }
4698
4699
4700
4701 /*
4702 Document-method: Opal::OpalParamGeneral.m_messageAvailable
4703
4704 call-seq:
4705 m_messageAvailable -> OpalMessageAvailableFunction
4706
4707 Get value of attribute.
4708
4709 */
4710
4711 /*
4712 Document-method: Opal::OpalParamGeneral.m_messageAvailable=
4713
4714 call-seq:
4715 m_messageAvailable=(x) -> OpalMessageAvailableFunction
4716
4717 Set new value for attribute.
4718
4719 */
4720 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_messageAvailable_set(int argc,VALUE * argv,VALUE self)4721 _wrap_OpalParamGeneral_m_messageAvailable_set(int argc, VALUE *argv, VALUE self) {
4722 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4723 OpalMessageAvailableFunction arg2 = (OpalMessageAvailableFunction) 0 ;
4724 void *argp1 = 0 ;
4725 int res1 = 0 ;
4726
4727 if ((argc < 1) || (argc > 1)) {
4728 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4729 }
4730 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4731 if (!SWIG_IsOK(res1)) {
4732 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_messageAvailable", 1, self ));
4733 }
4734 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4735 {
4736 int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__OpalMessage__int);
4737 if (!SWIG_IsOK(res)) {
4738 SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "OpalMessageAvailableFunction","m_messageAvailable", 2, argv[0] ));
4739 }
4740 }
4741 if (arg1) (arg1)->m_messageAvailable = arg2;
4742 return Qnil;
4743 fail:
4744 return Qnil;
4745 }
4746
4747
4748 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_messageAvailable_get(int argc,VALUE * argv,VALUE self)4749 _wrap_OpalParamGeneral_m_messageAvailable_get(int argc, VALUE *argv, VALUE self) {
4750 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4751 void *argp1 = 0 ;
4752 int res1 = 0 ;
4753 OpalMessageAvailableFunction result;
4754 VALUE vresult = Qnil;
4755
4756 if ((argc < 0) || (argc > 0)) {
4757 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4758 }
4759 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4760 if (!SWIG_IsOK(res1)) {
4761 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_messageAvailable", 1, self ));
4762 }
4763 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4764 result = (OpalMessageAvailableFunction) ((arg1)->m_messageAvailable);
4765 vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__OpalMessage__int);
4766 return vresult;
4767 fail:
4768 return Qnil;
4769 }
4770
4771
4772
4773 /*
4774 Document-method: Opal::OpalParamGeneral.m_mediaOptions
4775
4776 call-seq:
4777 m_mediaOptions -> char
4778
4779 Get value of attribute.
4780
4781 */
4782
4783 /*
4784 Document-method: Opal::OpalParamGeneral.m_mediaOptions=
4785
4786 call-seq:
4787 m_mediaOptions=(x) -> char
4788
4789 Set new value for attribute.
4790
4791 */
4792 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaOptions_set(int argc,VALUE * argv,VALUE self)4793 _wrap_OpalParamGeneral_m_mediaOptions_set(int argc, VALUE *argv, VALUE self) {
4794 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4795 char *arg2 = (char *) 0 ;
4796 void *argp1 = 0 ;
4797 int res1 = 0 ;
4798 int res2 ;
4799 char *buf2 = 0 ;
4800 int alloc2 = 0 ;
4801
4802 if ((argc < 1) || (argc > 1)) {
4803 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4804 }
4805 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4806 if (!SWIG_IsOK(res1)) {
4807 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaOptions", 1, self ));
4808 }
4809 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4810 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
4811 if (!SWIG_IsOK(res2)) {
4812 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_mediaOptions", 2, argv[0] ));
4813 }
4814 arg2 = reinterpret_cast< char * >(buf2);
4815 if (arg2) {
4816 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
4817 arg1->m_mediaOptions = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
4818 } else {
4819 arg1->m_mediaOptions = 0;
4820 }
4821 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4822 return Qnil;
4823 fail:
4824 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4825 return Qnil;
4826 }
4827
4828
4829 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaOptions_get(int argc,VALUE * argv,VALUE self)4830 _wrap_OpalParamGeneral_m_mediaOptions_get(int argc, VALUE *argv, VALUE self) {
4831 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4832 void *argp1 = 0 ;
4833 int res1 = 0 ;
4834 char *result = 0 ;
4835 VALUE vresult = Qnil;
4836
4837 if ((argc < 0) || (argc > 0)) {
4838 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4839 }
4840 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4841 if (!SWIG_IsOK(res1)) {
4842 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaOptions", 1, self ));
4843 }
4844 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4845 result = (char *) ((arg1)->m_mediaOptions);
4846 vresult = SWIG_FromCharPtr((const char *)result);
4847 return vresult;
4848 fail:
4849 return Qnil;
4850 }
4851
4852
4853
4854 /*
4855 Document-method: Opal::OpalParamGeneral.m_audioBufferTime
4856
4857 call-seq:
4858 m_audioBufferTime -> unsigned int
4859
4860 Get value of attribute.
4861
4862 */
4863
4864 /*
4865 Document-method: Opal::OpalParamGeneral.m_audioBufferTime=
4866
4867 call-seq:
4868 m_audioBufferTime=(x) -> unsigned int
4869
4870 Set new value for attribute.
4871
4872 */
4873 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_audioBufferTime_set(int argc,VALUE * argv,VALUE self)4874 _wrap_OpalParamGeneral_m_audioBufferTime_set(int argc, VALUE *argv, VALUE self) {
4875 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4876 unsigned int arg2 ;
4877 void *argp1 = 0 ;
4878 int res1 = 0 ;
4879 unsigned int val2 ;
4880 int ecode2 = 0 ;
4881
4882 if ((argc < 1) || (argc > 1)) {
4883 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4884 }
4885 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4886 if (!SWIG_IsOK(res1)) {
4887 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_audioBufferTime", 1, self ));
4888 }
4889 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4890 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
4891 if (!SWIG_IsOK(ecode2)) {
4892 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_audioBufferTime", 2, argv[0] ));
4893 }
4894 arg2 = static_cast< unsigned int >(val2);
4895 if (arg1) (arg1)->m_audioBufferTime = arg2;
4896 return Qnil;
4897 fail:
4898 return Qnil;
4899 }
4900
4901
4902 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_audioBufferTime_get(int argc,VALUE * argv,VALUE self)4903 _wrap_OpalParamGeneral_m_audioBufferTime_get(int argc, VALUE *argv, VALUE self) {
4904 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4905 void *argp1 = 0 ;
4906 int res1 = 0 ;
4907 unsigned int result;
4908 VALUE vresult = Qnil;
4909
4910 if ((argc < 0) || (argc > 0)) {
4911 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4912 }
4913 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4914 if (!SWIG_IsOK(res1)) {
4915 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_audioBufferTime", 1, self ));
4916 }
4917 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4918 result = (unsigned int) ((arg1)->m_audioBufferTime);
4919 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
4920 return vresult;
4921 fail:
4922 return Qnil;
4923 }
4924
4925
4926
4927 /*
4928 Document-method: Opal::OpalParamGeneral.m_manualAlerting
4929
4930 call-seq:
4931 m_manualAlerting -> unsigned int
4932
4933 Get value of attribute.
4934
4935 */
4936
4937 /*
4938 Document-method: Opal::OpalParamGeneral.m_manualAlerting=
4939
4940 call-seq:
4941 m_manualAlerting=(x) -> unsigned int
4942
4943 Set new value for attribute.
4944
4945 */
4946 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_manualAlerting_set(int argc,VALUE * argv,VALUE self)4947 _wrap_OpalParamGeneral_m_manualAlerting_set(int argc, VALUE *argv, VALUE self) {
4948 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4949 unsigned int arg2 ;
4950 void *argp1 = 0 ;
4951 int res1 = 0 ;
4952 unsigned int val2 ;
4953 int ecode2 = 0 ;
4954
4955 if ((argc < 1) || (argc > 1)) {
4956 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4957 }
4958 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4959 if (!SWIG_IsOK(res1)) {
4960 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_manualAlerting", 1, self ));
4961 }
4962 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4963 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
4964 if (!SWIG_IsOK(ecode2)) {
4965 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_manualAlerting", 2, argv[0] ));
4966 }
4967 arg2 = static_cast< unsigned int >(val2);
4968 if (arg1) (arg1)->m_manualAlerting = arg2;
4969 return Qnil;
4970 fail:
4971 return Qnil;
4972 }
4973
4974
4975 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_manualAlerting_get(int argc,VALUE * argv,VALUE self)4976 _wrap_OpalParamGeneral_m_manualAlerting_get(int argc, VALUE *argv, VALUE self) {
4977 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
4978 void *argp1 = 0 ;
4979 int res1 = 0 ;
4980 unsigned int result;
4981 VALUE vresult = Qnil;
4982
4983 if ((argc < 0) || (argc > 0)) {
4984 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4985 }
4986 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
4987 if (!SWIG_IsOK(res1)) {
4988 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_manualAlerting", 1, self ));
4989 }
4990 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
4991 result = (unsigned int) ((arg1)->m_manualAlerting);
4992 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
4993 return vresult;
4994 fail:
4995 return Qnil;
4996 }
4997
4998
4999
5000 /*
5001 Document-method: Opal::OpalParamGeneral.m_mediaTiming
5002
5003 call-seq:
5004 m_mediaTiming -> int
5005
5006 Get value of attribute.
5007
5008 */
5009
5010 /*
5011 Document-method: Opal::OpalParamGeneral.m_mediaTiming=
5012
5013 call-seq:
5014 m_mediaTiming=(x) -> int
5015
5016 Set new value for attribute.
5017
5018 */
5019 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaTiming_set(int argc,VALUE * argv,VALUE self)5020 _wrap_OpalParamGeneral_m_mediaTiming_set(int argc, VALUE *argv, VALUE self) {
5021 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
5022 OpalMediaTiming arg2 ;
5023 void *argp1 = 0 ;
5024 int res1 = 0 ;
5025 int val2 ;
5026 int ecode2 = 0 ;
5027
5028 if ((argc < 1) || (argc > 1)) {
5029 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5030 }
5031 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
5032 if (!SWIG_IsOK(res1)) {
5033 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaTiming", 1, self ));
5034 }
5035 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
5036 ecode2 = SWIG_AsVal_int(argv[0], &val2);
5037 if (!SWIG_IsOK(ecode2)) {
5038 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalMediaTiming","m_mediaTiming", 2, argv[0] ));
5039 }
5040 arg2 = static_cast< OpalMediaTiming >(val2);
5041 if (arg1) (arg1)->m_mediaTiming = arg2;
5042 return Qnil;
5043 fail:
5044 return Qnil;
5045 }
5046
5047
5048 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_mediaTiming_get(int argc,VALUE * argv,VALUE self)5049 _wrap_OpalParamGeneral_m_mediaTiming_get(int argc, VALUE *argv, VALUE self) {
5050 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
5051 void *argp1 = 0 ;
5052 int res1 = 0 ;
5053 OpalMediaTiming result;
5054 VALUE vresult = Qnil;
5055
5056 if ((argc < 0) || (argc > 0)) {
5057 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5058 }
5059 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
5060 if (!SWIG_IsOK(res1)) {
5061 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_mediaTiming", 1, self ));
5062 }
5063 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
5064 result = (OpalMediaTiming) ((arg1)->m_mediaTiming);
5065 vresult = SWIG_From_int(static_cast< int >(result));
5066 return vresult;
5067 fail:
5068 return Qnil;
5069 }
5070
5071
5072
5073 /*
5074 Document-method: Opal::OpalParamGeneral.m_videoSourceTiming
5075
5076 call-seq:
5077 m_videoSourceTiming -> int
5078
5079 Get value of attribute.
5080
5081 */
5082
5083 /*
5084 Document-method: Opal::OpalParamGeneral.m_videoSourceTiming=
5085
5086 call-seq:
5087 m_videoSourceTiming=(x) -> int
5088
5089 Set new value for attribute.
5090
5091 */
5092 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_videoSourceTiming_set(int argc,VALUE * argv,VALUE self)5093 _wrap_OpalParamGeneral_m_videoSourceTiming_set(int argc, VALUE *argv, VALUE self) {
5094 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
5095 OpalMediaTiming arg2 ;
5096 void *argp1 = 0 ;
5097 int res1 = 0 ;
5098 int val2 ;
5099 int ecode2 = 0 ;
5100
5101 if ((argc < 1) || (argc > 1)) {
5102 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5103 }
5104 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
5105 if (!SWIG_IsOK(res1)) {
5106 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_videoSourceTiming", 1, self ));
5107 }
5108 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
5109 ecode2 = SWIG_AsVal_int(argv[0], &val2);
5110 if (!SWIG_IsOK(ecode2)) {
5111 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalMediaTiming","m_videoSourceTiming", 2, argv[0] ));
5112 }
5113 arg2 = static_cast< OpalMediaTiming >(val2);
5114 if (arg1) (arg1)->m_videoSourceTiming = arg2;
5115 return Qnil;
5116 fail:
5117 return Qnil;
5118 }
5119
5120
5121 SWIGINTERN VALUE
_wrap_OpalParamGeneral_m_videoSourceTiming_get(int argc,VALUE * argv,VALUE self)5122 _wrap_OpalParamGeneral_m_videoSourceTiming_get(int argc, VALUE *argv, VALUE self) {
5123 OpalParamGeneral *arg1 = (OpalParamGeneral *) 0 ;
5124 void *argp1 = 0 ;
5125 int res1 = 0 ;
5126 OpalMediaTiming result;
5127 VALUE vresult = Qnil;
5128
5129 if ((argc < 0) || (argc > 0)) {
5130 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5131 }
5132 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
5133 if (!SWIG_IsOK(res1)) {
5134 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_videoSourceTiming", 1, self ));
5135 }
5136 arg1 = reinterpret_cast< OpalParamGeneral * >(argp1);
5137 result = (OpalMediaTiming) ((arg1)->m_videoSourceTiming);
5138 vresult = SWIG_From_int(static_cast< int >(result));
5139 return vresult;
5140 fail:
5141 return Qnil;
5142 }
5143
5144
5145 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
5146 SWIGINTERN VALUE
_wrap_OpalParamGeneral_allocate(VALUE self)5147 _wrap_OpalParamGeneral_allocate(VALUE self) {
5148 #else
5149 SWIGINTERN VALUE
5150 _wrap_OpalParamGeneral_allocate(int argc, VALUE *argv, VALUE self) {
5151 #endif
5152
5153
5154 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalParamGeneral);
5155 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
5156 rb_obj_call_init(vresult, argc, argv);
5157 #endif
5158 return vresult;
5159 }
5160
5161
5162
5163 /*
5164 Document-method: Opal::OpalParamGeneral.new
5165
5166 call-seq:
5167 OpalParamGeneral.new
5168
5169 Class constructor.
5170
5171 */
5172 SWIGINTERN VALUE
5173 _wrap_new_OpalParamGeneral(int argc, VALUE *argv, VALUE self) {
5174 OpalParamGeneral *result = 0 ;
5175
5176 if ((argc < 0) || (argc > 0)) {
5177 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5178 }
5179 result = (OpalParamGeneral *)new OpalParamGeneral();
5180 DATA_PTR(self) = result;
5181 return self;
5182 fail:
5183 return Qnil;
5184 }
5185
5186
5187 SWIGINTERN void
5188 free_OpalParamGeneral(OpalParamGeneral *arg1) {
5189 delete arg1;
5190 }
5191
5192
5193 /*
5194 Document-class: Opal::OpalProductDescription
5195
5196 Proxy of C++ Opal::OpalProductDescription class
5197
5198
5199 */
5200 swig_class SwigClassOpalProductDescription;
5201
5202
5203 /*
5204 Document-method: Opal::OpalProductDescription.m_vendor
5205
5206 call-seq:
5207 m_vendor -> char
5208
5209 Get value of attribute.
5210
5211 */
5212
5213 /*
5214 Document-method: Opal::OpalProductDescription.m_vendor=
5215
5216 call-seq:
5217 m_vendor=(x) -> char
5218
5219 Set new value for attribute.
5220
5221 */
5222 SWIGINTERN VALUE
5223 _wrap_OpalProductDescription_m_vendor_set(int argc, VALUE *argv, VALUE self) {
5224 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5225 char *arg2 = (char *) 0 ;
5226 void *argp1 = 0 ;
5227 int res1 = 0 ;
5228 int res2 ;
5229 char *buf2 = 0 ;
5230 int alloc2 = 0 ;
5231
5232 if ((argc < 1) || (argc > 1)) {
5233 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5234 }
5235 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5236 if (!SWIG_IsOK(res1)) {
5237 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_vendor", 1, self ));
5238 }
5239 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5240 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5241 if (!SWIG_IsOK(res2)) {
5242 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_vendor", 2, argv[0] ));
5243 }
5244 arg2 = reinterpret_cast< char * >(buf2);
5245 if (arg2) {
5246 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
5247 arg1->m_vendor = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
5248 } else {
5249 arg1->m_vendor = 0;
5250 }
5251 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5252 return Qnil;
5253 fail:
5254 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5255 return Qnil;
5256 }
5257
5258
5259 SWIGINTERN VALUE
5260 _wrap_OpalProductDescription_m_vendor_get(int argc, VALUE *argv, VALUE self) {
5261 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5262 void *argp1 = 0 ;
5263 int res1 = 0 ;
5264 char *result = 0 ;
5265 VALUE vresult = Qnil;
5266
5267 if ((argc < 0) || (argc > 0)) {
5268 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5269 }
5270 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5271 if (!SWIG_IsOK(res1)) {
5272 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_vendor", 1, self ));
5273 }
5274 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5275 result = (char *) ((arg1)->m_vendor);
5276 vresult = SWIG_FromCharPtr((const char *)result);
5277 return vresult;
5278 fail:
5279 return Qnil;
5280 }
5281
5282
5283
5284 /*
5285 Document-method: Opal::OpalProductDescription.m_name
5286
5287 call-seq:
5288 m_name -> char
5289
5290 Get value of attribute.
5291
5292 */
5293
5294 /*
5295 Document-method: Opal::OpalProductDescription.m_name=
5296
5297 call-seq:
5298 m_name=(x) -> char
5299
5300 Set new value for attribute.
5301
5302 */
5303 SWIGINTERN VALUE
5304 _wrap_OpalProductDescription_m_name_set(int argc, VALUE *argv, VALUE self) {
5305 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5306 char *arg2 = (char *) 0 ;
5307 void *argp1 = 0 ;
5308 int res1 = 0 ;
5309 int res2 ;
5310 char *buf2 = 0 ;
5311 int alloc2 = 0 ;
5312
5313 if ((argc < 1) || (argc > 1)) {
5314 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5315 }
5316 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5317 if (!SWIG_IsOK(res1)) {
5318 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_name", 1, self ));
5319 }
5320 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5321 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5322 if (!SWIG_IsOK(res2)) {
5323 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_name", 2, argv[0] ));
5324 }
5325 arg2 = reinterpret_cast< char * >(buf2);
5326 if (arg2) {
5327 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
5328 arg1->m_name = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
5329 } else {
5330 arg1->m_name = 0;
5331 }
5332 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5333 return Qnil;
5334 fail:
5335 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5336 return Qnil;
5337 }
5338
5339
5340 SWIGINTERN VALUE
5341 _wrap_OpalProductDescription_m_name_get(int argc, VALUE *argv, VALUE self) {
5342 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5343 void *argp1 = 0 ;
5344 int res1 = 0 ;
5345 char *result = 0 ;
5346 VALUE vresult = Qnil;
5347
5348 if ((argc < 0) || (argc > 0)) {
5349 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5350 }
5351 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5352 if (!SWIG_IsOK(res1)) {
5353 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_name", 1, self ));
5354 }
5355 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5356 result = (char *) ((arg1)->m_name);
5357 vresult = SWIG_FromCharPtr((const char *)result);
5358 return vresult;
5359 fail:
5360 return Qnil;
5361 }
5362
5363
5364
5365 /*
5366 Document-method: Opal::OpalProductDescription.m_version
5367
5368 call-seq:
5369 m_version -> char
5370
5371 Get value of attribute.
5372
5373 */
5374
5375 /*
5376 Document-method: Opal::OpalProductDescription.m_version=
5377
5378 call-seq:
5379 m_version=(x) -> char
5380
5381 Set new value for attribute.
5382
5383 */
5384 SWIGINTERN VALUE
5385 _wrap_OpalProductDescription_m_version_set(int argc, VALUE *argv, VALUE self) {
5386 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5387 char *arg2 = (char *) 0 ;
5388 void *argp1 = 0 ;
5389 int res1 = 0 ;
5390 int res2 ;
5391 char *buf2 = 0 ;
5392 int alloc2 = 0 ;
5393
5394 if ((argc < 1) || (argc > 1)) {
5395 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5396 }
5397 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5398 if (!SWIG_IsOK(res1)) {
5399 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_version", 1, self ));
5400 }
5401 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5402 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5403 if (!SWIG_IsOK(res2)) {
5404 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_version", 2, argv[0] ));
5405 }
5406 arg2 = reinterpret_cast< char * >(buf2);
5407 if (arg2) {
5408 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
5409 arg1->m_version = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
5410 } else {
5411 arg1->m_version = 0;
5412 }
5413 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5414 return Qnil;
5415 fail:
5416 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5417 return Qnil;
5418 }
5419
5420
5421 SWIGINTERN VALUE
5422 _wrap_OpalProductDescription_m_version_get(int argc, VALUE *argv, VALUE self) {
5423 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5424 void *argp1 = 0 ;
5425 int res1 = 0 ;
5426 char *result = 0 ;
5427 VALUE vresult = Qnil;
5428
5429 if ((argc < 0) || (argc > 0)) {
5430 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5431 }
5432 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5433 if (!SWIG_IsOK(res1)) {
5434 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_version", 1, self ));
5435 }
5436 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5437 result = (char *) ((arg1)->m_version);
5438 vresult = SWIG_FromCharPtr((const char *)result);
5439 return vresult;
5440 fail:
5441 return Qnil;
5442 }
5443
5444
5445
5446 /*
5447 Document-method: Opal::OpalProductDescription.m_t35CountryCode
5448
5449 call-seq:
5450 m_t35CountryCode -> unsigned int
5451
5452 Get value of attribute.
5453
5454 */
5455
5456 /*
5457 Document-method: Opal::OpalProductDescription.m_t35CountryCode=
5458
5459 call-seq:
5460 m_t35CountryCode=(x) -> unsigned int
5461
5462 Set new value for attribute.
5463
5464 */
5465 SWIGINTERN VALUE
5466 _wrap_OpalProductDescription_m_t35CountryCode_set(int argc, VALUE *argv, VALUE self) {
5467 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5468 unsigned int arg2 ;
5469 void *argp1 = 0 ;
5470 int res1 = 0 ;
5471 unsigned int val2 ;
5472 int ecode2 = 0 ;
5473
5474 if ((argc < 1) || (argc > 1)) {
5475 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5476 }
5477 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5478 if (!SWIG_IsOK(res1)) {
5479 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_t35CountryCode", 1, self ));
5480 }
5481 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5482 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
5483 if (!SWIG_IsOK(ecode2)) {
5484 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_t35CountryCode", 2, argv[0] ));
5485 }
5486 arg2 = static_cast< unsigned int >(val2);
5487 if (arg1) (arg1)->m_t35CountryCode = arg2;
5488 return Qnil;
5489 fail:
5490 return Qnil;
5491 }
5492
5493
5494 SWIGINTERN VALUE
5495 _wrap_OpalProductDescription_m_t35CountryCode_get(int argc, VALUE *argv, VALUE self) {
5496 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5497 void *argp1 = 0 ;
5498 int res1 = 0 ;
5499 unsigned int result;
5500 VALUE vresult = Qnil;
5501
5502 if ((argc < 0) || (argc > 0)) {
5503 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5504 }
5505 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5506 if (!SWIG_IsOK(res1)) {
5507 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_t35CountryCode", 1, self ));
5508 }
5509 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5510 result = (unsigned int) ((arg1)->m_t35CountryCode);
5511 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
5512 return vresult;
5513 fail:
5514 return Qnil;
5515 }
5516
5517
5518
5519 /*
5520 Document-method: Opal::OpalProductDescription.m_t35Extension
5521
5522 call-seq:
5523 m_t35Extension -> unsigned int
5524
5525 Get value of attribute.
5526
5527 */
5528
5529 /*
5530 Document-method: Opal::OpalProductDescription.m_t35Extension=
5531
5532 call-seq:
5533 m_t35Extension=(x) -> unsigned int
5534
5535 Set new value for attribute.
5536
5537 */
5538 SWIGINTERN VALUE
5539 _wrap_OpalProductDescription_m_t35Extension_set(int argc, VALUE *argv, VALUE self) {
5540 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5541 unsigned int arg2 ;
5542 void *argp1 = 0 ;
5543 int res1 = 0 ;
5544 unsigned int val2 ;
5545 int ecode2 = 0 ;
5546
5547 if ((argc < 1) || (argc > 1)) {
5548 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5549 }
5550 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5551 if (!SWIG_IsOK(res1)) {
5552 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_t35Extension", 1, self ));
5553 }
5554 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5555 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
5556 if (!SWIG_IsOK(ecode2)) {
5557 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_t35Extension", 2, argv[0] ));
5558 }
5559 arg2 = static_cast< unsigned int >(val2);
5560 if (arg1) (arg1)->m_t35Extension = arg2;
5561 return Qnil;
5562 fail:
5563 return Qnil;
5564 }
5565
5566
5567 SWIGINTERN VALUE
5568 _wrap_OpalProductDescription_m_t35Extension_get(int argc, VALUE *argv, VALUE self) {
5569 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5570 void *argp1 = 0 ;
5571 int res1 = 0 ;
5572 unsigned int result;
5573 VALUE vresult = Qnil;
5574
5575 if ((argc < 0) || (argc > 0)) {
5576 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5577 }
5578 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5579 if (!SWIG_IsOK(res1)) {
5580 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_t35Extension", 1, self ));
5581 }
5582 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5583 result = (unsigned int) ((arg1)->m_t35Extension);
5584 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
5585 return vresult;
5586 fail:
5587 return Qnil;
5588 }
5589
5590
5591
5592 /*
5593 Document-method: Opal::OpalProductDescription.m_manufacturerCode
5594
5595 call-seq:
5596 m_manufacturerCode -> unsigned int
5597
5598 Get value of attribute.
5599
5600 */
5601
5602 /*
5603 Document-method: Opal::OpalProductDescription.m_manufacturerCode=
5604
5605 call-seq:
5606 m_manufacturerCode=(x) -> unsigned int
5607
5608 Set new value for attribute.
5609
5610 */
5611 SWIGINTERN VALUE
5612 _wrap_OpalProductDescription_m_manufacturerCode_set(int argc, VALUE *argv, VALUE self) {
5613 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5614 unsigned int arg2 ;
5615 void *argp1 = 0 ;
5616 int res1 = 0 ;
5617 unsigned int val2 ;
5618 int ecode2 = 0 ;
5619
5620 if ((argc < 1) || (argc > 1)) {
5621 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5622 }
5623 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5624 if (!SWIG_IsOK(res1)) {
5625 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_manufacturerCode", 1, self ));
5626 }
5627 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5628 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
5629 if (!SWIG_IsOK(ecode2)) {
5630 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_manufacturerCode", 2, argv[0] ));
5631 }
5632 arg2 = static_cast< unsigned int >(val2);
5633 if (arg1) (arg1)->m_manufacturerCode = arg2;
5634 return Qnil;
5635 fail:
5636 return Qnil;
5637 }
5638
5639
5640 SWIGINTERN VALUE
5641 _wrap_OpalProductDescription_m_manufacturerCode_get(int argc, VALUE *argv, VALUE self) {
5642 OpalProductDescription *arg1 = (OpalProductDescription *) 0 ;
5643 void *argp1 = 0 ;
5644 int res1 = 0 ;
5645 unsigned int result;
5646 VALUE vresult = Qnil;
5647
5648 if ((argc < 0) || (argc > 0)) {
5649 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5650 }
5651 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
5652 if (!SWIG_IsOK(res1)) {
5653 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalProductDescription *","m_manufacturerCode", 1, self ));
5654 }
5655 arg1 = reinterpret_cast< OpalProductDescription * >(argp1);
5656 result = (unsigned int) ((arg1)->m_manufacturerCode);
5657 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
5658 return vresult;
5659 fail:
5660 return Qnil;
5661 }
5662
5663
5664 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
5665 SWIGINTERN VALUE
5666 _wrap_OpalProductDescription_allocate(VALUE self) {
5667 #else
5668 SWIGINTERN VALUE
5669 _wrap_OpalProductDescription_allocate(int argc, VALUE *argv, VALUE self) {
5670 #endif
5671
5672
5673 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalProductDescription);
5674 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
5675 rb_obj_call_init(vresult, argc, argv);
5676 #endif
5677 return vresult;
5678 }
5679
5680
5681
5682 /*
5683 Document-method: Opal::OpalProductDescription.new
5684
5685 call-seq:
5686 OpalProductDescription.new
5687
5688 Class constructor.
5689
5690 */
5691 SWIGINTERN VALUE
5692 _wrap_new_OpalProductDescription(int argc, VALUE *argv, VALUE self) {
5693 OpalProductDescription *result = 0 ;
5694
5695 if ((argc < 0) || (argc > 0)) {
5696 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5697 }
5698 result = (OpalProductDescription *)new OpalProductDescription();
5699 DATA_PTR(self) = result;
5700 return self;
5701 fail:
5702 return Qnil;
5703 }
5704
5705
5706 SWIGINTERN void
5707 free_OpalProductDescription(OpalProductDescription *arg1) {
5708 delete arg1;
5709 }
5710
5711
5712 /*
5713 Document-class: Opal::OpalParamProtocol
5714
5715 Proxy of C++ Opal::OpalParamProtocol class
5716
5717
5718 */
5719 swig_class SwigClassOpalParamProtocol;
5720
5721
5722 /*
5723 Document-method: Opal::OpalParamProtocol.m_prefix
5724
5725 call-seq:
5726 m_prefix -> char
5727
5728 Get value of attribute.
5729
5730 */
5731
5732 /*
5733 Document-method: Opal::OpalParamProtocol.m_prefix=
5734
5735 call-seq:
5736 m_prefix=(x) -> char
5737
5738 Set new value for attribute.
5739
5740 */
5741 SWIGINTERN VALUE
5742 _wrap_OpalParamProtocol_m_prefix_set(int argc, VALUE *argv, VALUE self) {
5743 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
5744 char *arg2 = (char *) 0 ;
5745 void *argp1 = 0 ;
5746 int res1 = 0 ;
5747 int res2 ;
5748 char *buf2 = 0 ;
5749 int alloc2 = 0 ;
5750
5751 if ((argc < 1) || (argc > 1)) {
5752 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5753 }
5754 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
5755 if (!SWIG_IsOK(res1)) {
5756 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_prefix", 1, self ));
5757 }
5758 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
5759 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5760 if (!SWIG_IsOK(res2)) {
5761 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_prefix", 2, argv[0] ));
5762 }
5763 arg2 = reinterpret_cast< char * >(buf2);
5764 if (arg2) {
5765 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
5766 arg1->m_prefix = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
5767 } else {
5768 arg1->m_prefix = 0;
5769 }
5770 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5771 return Qnil;
5772 fail:
5773 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5774 return Qnil;
5775 }
5776
5777
5778 SWIGINTERN VALUE
5779 _wrap_OpalParamProtocol_m_prefix_get(int argc, VALUE *argv, VALUE self) {
5780 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
5781 void *argp1 = 0 ;
5782 int res1 = 0 ;
5783 char *result = 0 ;
5784 VALUE vresult = Qnil;
5785
5786 if ((argc < 0) || (argc > 0)) {
5787 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5788 }
5789 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
5790 if (!SWIG_IsOK(res1)) {
5791 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_prefix", 1, self ));
5792 }
5793 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
5794 result = (char *) ((arg1)->m_prefix);
5795 vresult = SWIG_FromCharPtr((const char *)result);
5796 return vresult;
5797 fail:
5798 return Qnil;
5799 }
5800
5801
5802
5803 /*
5804 Document-method: Opal::OpalParamProtocol.m_userName
5805
5806 call-seq:
5807 m_userName -> char
5808
5809 Get value of attribute.
5810
5811 */
5812
5813 /*
5814 Document-method: Opal::OpalParamProtocol.m_userName=
5815
5816 call-seq:
5817 m_userName=(x) -> char
5818
5819 Set new value for attribute.
5820
5821 */
5822 SWIGINTERN VALUE
5823 _wrap_OpalParamProtocol_m_userName_set(int argc, VALUE *argv, VALUE self) {
5824 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
5825 char *arg2 = (char *) 0 ;
5826 void *argp1 = 0 ;
5827 int res1 = 0 ;
5828 int res2 ;
5829 char *buf2 = 0 ;
5830 int alloc2 = 0 ;
5831
5832 if ((argc < 1) || (argc > 1)) {
5833 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5834 }
5835 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
5836 if (!SWIG_IsOK(res1)) {
5837 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_userName", 1, self ));
5838 }
5839 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
5840 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5841 if (!SWIG_IsOK(res2)) {
5842 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_userName", 2, argv[0] ));
5843 }
5844 arg2 = reinterpret_cast< char * >(buf2);
5845 if (arg2) {
5846 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
5847 arg1->m_userName = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
5848 } else {
5849 arg1->m_userName = 0;
5850 }
5851 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5852 return Qnil;
5853 fail:
5854 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5855 return Qnil;
5856 }
5857
5858
5859 SWIGINTERN VALUE
5860 _wrap_OpalParamProtocol_m_userName_get(int argc, VALUE *argv, VALUE self) {
5861 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
5862 void *argp1 = 0 ;
5863 int res1 = 0 ;
5864 char *result = 0 ;
5865 VALUE vresult = Qnil;
5866
5867 if ((argc < 0) || (argc > 0)) {
5868 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5869 }
5870 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
5871 if (!SWIG_IsOK(res1)) {
5872 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_userName", 1, self ));
5873 }
5874 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
5875 result = (char *) ((arg1)->m_userName);
5876 vresult = SWIG_FromCharPtr((const char *)result);
5877 return vresult;
5878 fail:
5879 return Qnil;
5880 }
5881
5882
5883
5884 /*
5885 Document-method: Opal::OpalParamProtocol.m_displayName
5886
5887 call-seq:
5888 m_displayName -> char
5889
5890 Get value of attribute.
5891
5892 */
5893
5894 /*
5895 Document-method: Opal::OpalParamProtocol.m_displayName=
5896
5897 call-seq:
5898 m_displayName=(x) -> char
5899
5900 Set new value for attribute.
5901
5902 */
5903 SWIGINTERN VALUE
5904 _wrap_OpalParamProtocol_m_displayName_set(int argc, VALUE *argv, VALUE self) {
5905 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
5906 char *arg2 = (char *) 0 ;
5907 void *argp1 = 0 ;
5908 int res1 = 0 ;
5909 int res2 ;
5910 char *buf2 = 0 ;
5911 int alloc2 = 0 ;
5912
5913 if ((argc < 1) || (argc > 1)) {
5914 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5915 }
5916 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
5917 if (!SWIG_IsOK(res1)) {
5918 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_displayName", 1, self ));
5919 }
5920 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
5921 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5922 if (!SWIG_IsOK(res2)) {
5923 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_displayName", 2, argv[0] ));
5924 }
5925 arg2 = reinterpret_cast< char * >(buf2);
5926 if (arg2) {
5927 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
5928 arg1->m_displayName = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
5929 } else {
5930 arg1->m_displayName = 0;
5931 }
5932 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5933 return Qnil;
5934 fail:
5935 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5936 return Qnil;
5937 }
5938
5939
5940 SWIGINTERN VALUE
5941 _wrap_OpalParamProtocol_m_displayName_get(int argc, VALUE *argv, VALUE self) {
5942 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
5943 void *argp1 = 0 ;
5944 int res1 = 0 ;
5945 char *result = 0 ;
5946 VALUE vresult = Qnil;
5947
5948 if ((argc < 0) || (argc > 0)) {
5949 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5950 }
5951 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
5952 if (!SWIG_IsOK(res1)) {
5953 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_displayName", 1, self ));
5954 }
5955 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
5956 result = (char *) ((arg1)->m_displayName);
5957 vresult = SWIG_FromCharPtr((const char *)result);
5958 return vresult;
5959 fail:
5960 return Qnil;
5961 }
5962
5963
5964
5965 /*
5966 Document-method: Opal::OpalParamProtocol.m_product
5967
5968 call-seq:
5969 m_product -> OpalProductDescription
5970
5971 Get value of attribute.
5972
5973 */
5974
5975 /*
5976 Document-method: Opal::OpalParamProtocol.m_product=
5977
5978 call-seq:
5979 m_product=(x) -> OpalProductDescription
5980
5981 Set new value for attribute.
5982
5983 */
5984 SWIGINTERN VALUE
5985 _wrap_OpalParamProtocol_m_product_set(int argc, VALUE *argv, VALUE self) {
5986 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
5987 OpalProductDescription *arg2 = (OpalProductDescription *) 0 ;
5988 void *argp1 = 0 ;
5989 int res1 = 0 ;
5990 void *argp2 = 0 ;
5991 int res2 = 0 ;
5992
5993 if ((argc < 1) || (argc > 1)) {
5994 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5995 }
5996 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
5997 if (!SWIG_IsOK(res1)) {
5998 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_product", 1, self ));
5999 }
6000 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
6001 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
6002 if (!SWIG_IsOK(res2)) {
6003 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalProductDescription *","m_product", 2, argv[0] ));
6004 }
6005 arg2 = reinterpret_cast< OpalProductDescription * >(argp2);
6006 if (arg1) (arg1)->m_product = *arg2;
6007 return Qnil;
6008 fail:
6009 return Qnil;
6010 }
6011
6012
6013 SWIGINTERN VALUE
6014 _wrap_OpalParamProtocol_m_product_get(int argc, VALUE *argv, VALUE self) {
6015 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
6016 void *argp1 = 0 ;
6017 int res1 = 0 ;
6018 OpalProductDescription *result = 0 ;
6019 VALUE vresult = Qnil;
6020
6021 if ((argc < 0) || (argc > 0)) {
6022 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6023 }
6024 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
6025 if (!SWIG_IsOK(res1)) {
6026 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_product", 1, self ));
6027 }
6028 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
6029 result = (OpalProductDescription *)& ((arg1)->m_product);
6030 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalProductDescription, 0 | 0 );
6031 return vresult;
6032 fail:
6033 return Qnil;
6034 }
6035
6036
6037
6038 /*
6039 Document-method: Opal::OpalParamProtocol.m_interfaceAddresses
6040
6041 call-seq:
6042 m_interfaceAddresses -> char
6043
6044 Get value of attribute.
6045
6046 */
6047
6048 /*
6049 Document-method: Opal::OpalParamProtocol.m_interfaceAddresses=
6050
6051 call-seq:
6052 m_interfaceAddresses=(x) -> char
6053
6054 Set new value for attribute.
6055
6056 */
6057 SWIGINTERN VALUE
6058 _wrap_OpalParamProtocol_m_interfaceAddresses_set(int argc, VALUE *argv, VALUE self) {
6059 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
6060 char *arg2 = (char *) 0 ;
6061 void *argp1 = 0 ;
6062 int res1 = 0 ;
6063 int res2 ;
6064 char *buf2 = 0 ;
6065 int alloc2 = 0 ;
6066
6067 if ((argc < 1) || (argc > 1)) {
6068 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6069 }
6070 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
6071 if (!SWIG_IsOK(res1)) {
6072 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_interfaceAddresses", 1, self ));
6073 }
6074 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
6075 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6076 if (!SWIG_IsOK(res2)) {
6077 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_interfaceAddresses", 2, argv[0] ));
6078 }
6079 arg2 = reinterpret_cast< char * >(buf2);
6080 if (arg2) {
6081 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
6082 arg1->m_interfaceAddresses = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
6083 } else {
6084 arg1->m_interfaceAddresses = 0;
6085 }
6086 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6087 return Qnil;
6088 fail:
6089 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6090 return Qnil;
6091 }
6092
6093
6094 SWIGINTERN VALUE
6095 _wrap_OpalParamProtocol_m_interfaceAddresses_get(int argc, VALUE *argv, VALUE self) {
6096 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
6097 void *argp1 = 0 ;
6098 int res1 = 0 ;
6099 char *result = 0 ;
6100 VALUE vresult = Qnil;
6101
6102 if ((argc < 0) || (argc > 0)) {
6103 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6104 }
6105 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
6106 if (!SWIG_IsOK(res1)) {
6107 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_interfaceAddresses", 1, self ));
6108 }
6109 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
6110 result = (char *) ((arg1)->m_interfaceAddresses);
6111 vresult = SWIG_FromCharPtr((const char *)result);
6112 return vresult;
6113 fail:
6114 return Qnil;
6115 }
6116
6117
6118
6119 /*
6120 Document-method: Opal::OpalParamProtocol.m_userInputMode
6121
6122 call-seq:
6123 m_userInputMode -> int
6124
6125 Get value of attribute.
6126
6127 */
6128
6129 /*
6130 Document-method: Opal::OpalParamProtocol.m_userInputMode=
6131
6132 call-seq:
6133 m_userInputMode=(x) -> int
6134
6135 Set new value for attribute.
6136
6137 */
6138 SWIGINTERN VALUE
6139 _wrap_OpalParamProtocol_m_userInputMode_set(int argc, VALUE *argv, VALUE self) {
6140 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
6141 OpalUserInputModes arg2 ;
6142 void *argp1 = 0 ;
6143 int res1 = 0 ;
6144 int val2 ;
6145 int ecode2 = 0 ;
6146
6147 if ((argc < 1) || (argc > 1)) {
6148 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6149 }
6150 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
6151 if (!SWIG_IsOK(res1)) {
6152 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_userInputMode", 1, self ));
6153 }
6154 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
6155 ecode2 = SWIG_AsVal_int(argv[0], &val2);
6156 if (!SWIG_IsOK(ecode2)) {
6157 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalUserInputModes","m_userInputMode", 2, argv[0] ));
6158 }
6159 arg2 = static_cast< OpalUserInputModes >(val2);
6160 if (arg1) (arg1)->m_userInputMode = arg2;
6161 return Qnil;
6162 fail:
6163 return Qnil;
6164 }
6165
6166
6167 SWIGINTERN VALUE
6168 _wrap_OpalParamProtocol_m_userInputMode_get(int argc, VALUE *argv, VALUE self) {
6169 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
6170 void *argp1 = 0 ;
6171 int res1 = 0 ;
6172 OpalUserInputModes result;
6173 VALUE vresult = Qnil;
6174
6175 if ((argc < 0) || (argc > 0)) {
6176 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6177 }
6178 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
6179 if (!SWIG_IsOK(res1)) {
6180 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_userInputMode", 1, self ));
6181 }
6182 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
6183 result = (OpalUserInputModes) ((arg1)->m_userInputMode);
6184 vresult = SWIG_From_int(static_cast< int >(result));
6185 return vresult;
6186 fail:
6187 return Qnil;
6188 }
6189
6190
6191
6192 /*
6193 Document-method: Opal::OpalParamProtocol.m_defaultOptions
6194
6195 call-seq:
6196 m_defaultOptions -> char
6197
6198 Get value of attribute.
6199
6200 */
6201
6202 /*
6203 Document-method: Opal::OpalParamProtocol.m_defaultOptions=
6204
6205 call-seq:
6206 m_defaultOptions=(x) -> char
6207
6208 Set new value for attribute.
6209
6210 */
6211 SWIGINTERN VALUE
6212 _wrap_OpalParamProtocol_m_defaultOptions_set(int argc, VALUE *argv, VALUE self) {
6213 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
6214 char *arg2 = (char *) 0 ;
6215 void *argp1 = 0 ;
6216 int res1 = 0 ;
6217 int res2 ;
6218 char *buf2 = 0 ;
6219 int alloc2 = 0 ;
6220
6221 if ((argc < 1) || (argc > 1)) {
6222 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6223 }
6224 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
6225 if (!SWIG_IsOK(res1)) {
6226 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_defaultOptions", 1, self ));
6227 }
6228 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
6229 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6230 if (!SWIG_IsOK(res2)) {
6231 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_defaultOptions", 2, argv[0] ));
6232 }
6233 arg2 = reinterpret_cast< char * >(buf2);
6234 if (arg2) {
6235 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
6236 arg1->m_defaultOptions = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
6237 } else {
6238 arg1->m_defaultOptions = 0;
6239 }
6240 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6241 return Qnil;
6242 fail:
6243 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6244 return Qnil;
6245 }
6246
6247
6248 SWIGINTERN VALUE
6249 _wrap_OpalParamProtocol_m_defaultOptions_get(int argc, VALUE *argv, VALUE self) {
6250 OpalParamProtocol *arg1 = (OpalParamProtocol *) 0 ;
6251 void *argp1 = 0 ;
6252 int res1 = 0 ;
6253 char *result = 0 ;
6254 VALUE vresult = Qnil;
6255
6256 if ((argc < 0) || (argc > 0)) {
6257 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6258 }
6259 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
6260 if (!SWIG_IsOK(res1)) {
6261 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_defaultOptions", 1, self ));
6262 }
6263 arg1 = reinterpret_cast< OpalParamProtocol * >(argp1);
6264 result = (char *) ((arg1)->m_defaultOptions);
6265 vresult = SWIG_FromCharPtr((const char *)result);
6266 return vresult;
6267 fail:
6268 return Qnil;
6269 }
6270
6271
6272 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
6273 SWIGINTERN VALUE
6274 _wrap_OpalParamProtocol_allocate(VALUE self) {
6275 #else
6276 SWIGINTERN VALUE
6277 _wrap_OpalParamProtocol_allocate(int argc, VALUE *argv, VALUE self) {
6278 #endif
6279
6280
6281 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalParamProtocol);
6282 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
6283 rb_obj_call_init(vresult, argc, argv);
6284 #endif
6285 return vresult;
6286 }
6287
6288
6289
6290 /*
6291 Document-method: Opal::OpalParamProtocol.new
6292
6293 call-seq:
6294 OpalParamProtocol.new
6295
6296 Class constructor.
6297
6298 */
6299 SWIGINTERN VALUE
6300 _wrap_new_OpalParamProtocol(int argc, VALUE *argv, VALUE self) {
6301 OpalParamProtocol *result = 0 ;
6302
6303 if ((argc < 0) || (argc > 0)) {
6304 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6305 }
6306 result = (OpalParamProtocol *)new OpalParamProtocol();
6307 DATA_PTR(self) = result;
6308 return self;
6309 fail:
6310 return Qnil;
6311 }
6312
6313
6314 SWIGINTERN void
6315 free_OpalParamProtocol(OpalParamProtocol *arg1) {
6316 delete arg1;
6317 }
6318
6319
6320 /*
6321 Document-class: Opal::OpalParamRegistration
6322
6323 Proxy of C++ Opal::OpalParamRegistration class
6324
6325
6326 */
6327 swig_class SwigClassOpalParamRegistration;
6328
6329
6330 /*
6331 Document-method: Opal::OpalParamRegistration.m_protocol
6332
6333 call-seq:
6334 m_protocol -> char
6335
6336 Get value of attribute.
6337
6338 */
6339
6340 /*
6341 Document-method: Opal::OpalParamRegistration.m_protocol=
6342
6343 call-seq:
6344 m_protocol=(x) -> char
6345
6346 Set new value for attribute.
6347
6348 */
6349 SWIGINTERN VALUE
6350 _wrap_OpalParamRegistration_m_protocol_set(int argc, VALUE *argv, VALUE self) {
6351 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6352 char *arg2 = (char *) 0 ;
6353 void *argp1 = 0 ;
6354 int res1 = 0 ;
6355 int res2 ;
6356 char *buf2 = 0 ;
6357 int alloc2 = 0 ;
6358
6359 if ((argc < 1) || (argc > 1)) {
6360 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6361 }
6362 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6363 if (!SWIG_IsOK(res1)) {
6364 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_protocol", 1, self ));
6365 }
6366 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6367 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6368 if (!SWIG_IsOK(res2)) {
6369 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_protocol", 2, argv[0] ));
6370 }
6371 arg2 = reinterpret_cast< char * >(buf2);
6372 if (arg2) {
6373 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
6374 arg1->m_protocol = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
6375 } else {
6376 arg1->m_protocol = 0;
6377 }
6378 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6379 return Qnil;
6380 fail:
6381 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6382 return Qnil;
6383 }
6384
6385
6386 SWIGINTERN VALUE
6387 _wrap_OpalParamRegistration_m_protocol_get(int argc, VALUE *argv, VALUE self) {
6388 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6389 void *argp1 = 0 ;
6390 int res1 = 0 ;
6391 char *result = 0 ;
6392 VALUE vresult = Qnil;
6393
6394 if ((argc < 0) || (argc > 0)) {
6395 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6396 }
6397 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6398 if (!SWIG_IsOK(res1)) {
6399 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_protocol", 1, self ));
6400 }
6401 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6402 result = (char *) ((arg1)->m_protocol);
6403 vresult = SWIG_FromCharPtr((const char *)result);
6404 return vresult;
6405 fail:
6406 return Qnil;
6407 }
6408
6409
6410
6411 /*
6412 Document-method: Opal::OpalParamRegistration.m_identifier
6413
6414 call-seq:
6415 m_identifier -> char
6416
6417 Get value of attribute.
6418
6419 */
6420
6421 /*
6422 Document-method: Opal::OpalParamRegistration.m_identifier=
6423
6424 call-seq:
6425 m_identifier=(x) -> char
6426
6427 Set new value for attribute.
6428
6429 */
6430 SWIGINTERN VALUE
6431 _wrap_OpalParamRegistration_m_identifier_set(int argc, VALUE *argv, VALUE self) {
6432 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6433 char *arg2 = (char *) 0 ;
6434 void *argp1 = 0 ;
6435 int res1 = 0 ;
6436 int res2 ;
6437 char *buf2 = 0 ;
6438 int alloc2 = 0 ;
6439
6440 if ((argc < 1) || (argc > 1)) {
6441 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6442 }
6443 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6444 if (!SWIG_IsOK(res1)) {
6445 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_identifier", 1, self ));
6446 }
6447 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6448 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6449 if (!SWIG_IsOK(res2)) {
6450 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_identifier", 2, argv[0] ));
6451 }
6452 arg2 = reinterpret_cast< char * >(buf2);
6453 if (arg2) {
6454 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
6455 arg1->m_identifier = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
6456 } else {
6457 arg1->m_identifier = 0;
6458 }
6459 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6460 return Qnil;
6461 fail:
6462 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6463 return Qnil;
6464 }
6465
6466
6467 SWIGINTERN VALUE
6468 _wrap_OpalParamRegistration_m_identifier_get(int argc, VALUE *argv, VALUE self) {
6469 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6470 void *argp1 = 0 ;
6471 int res1 = 0 ;
6472 char *result = 0 ;
6473 VALUE vresult = Qnil;
6474
6475 if ((argc < 0) || (argc > 0)) {
6476 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6477 }
6478 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6479 if (!SWIG_IsOK(res1)) {
6480 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_identifier", 1, self ));
6481 }
6482 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6483 result = (char *) ((arg1)->m_identifier);
6484 vresult = SWIG_FromCharPtr((const char *)result);
6485 return vresult;
6486 fail:
6487 return Qnil;
6488 }
6489
6490
6491
6492 /*
6493 Document-method: Opal::OpalParamRegistration.m_hostName
6494
6495 call-seq:
6496 m_hostName -> char
6497
6498 Get value of attribute.
6499
6500 */
6501
6502 /*
6503 Document-method: Opal::OpalParamRegistration.m_hostName=
6504
6505 call-seq:
6506 m_hostName=(x) -> char
6507
6508 Set new value for attribute.
6509
6510 */
6511 SWIGINTERN VALUE
6512 _wrap_OpalParamRegistration_m_hostName_set(int argc, VALUE *argv, VALUE self) {
6513 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6514 char *arg2 = (char *) 0 ;
6515 void *argp1 = 0 ;
6516 int res1 = 0 ;
6517 int res2 ;
6518 char *buf2 = 0 ;
6519 int alloc2 = 0 ;
6520
6521 if ((argc < 1) || (argc > 1)) {
6522 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6523 }
6524 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6525 if (!SWIG_IsOK(res1)) {
6526 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_hostName", 1, self ));
6527 }
6528 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6529 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6530 if (!SWIG_IsOK(res2)) {
6531 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_hostName", 2, argv[0] ));
6532 }
6533 arg2 = reinterpret_cast< char * >(buf2);
6534 if (arg2) {
6535 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
6536 arg1->m_hostName = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
6537 } else {
6538 arg1->m_hostName = 0;
6539 }
6540 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6541 return Qnil;
6542 fail:
6543 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6544 return Qnil;
6545 }
6546
6547
6548 SWIGINTERN VALUE
6549 _wrap_OpalParamRegistration_m_hostName_get(int argc, VALUE *argv, VALUE self) {
6550 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6551 void *argp1 = 0 ;
6552 int res1 = 0 ;
6553 char *result = 0 ;
6554 VALUE vresult = Qnil;
6555
6556 if ((argc < 0) || (argc > 0)) {
6557 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6558 }
6559 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6560 if (!SWIG_IsOK(res1)) {
6561 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_hostName", 1, self ));
6562 }
6563 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6564 result = (char *) ((arg1)->m_hostName);
6565 vresult = SWIG_FromCharPtr((const char *)result);
6566 return vresult;
6567 fail:
6568 return Qnil;
6569 }
6570
6571
6572
6573 /*
6574 Document-method: Opal::OpalParamRegistration.m_authUserName
6575
6576 call-seq:
6577 m_authUserName -> char
6578
6579 Get value of attribute.
6580
6581 */
6582
6583 /*
6584 Document-method: Opal::OpalParamRegistration.m_authUserName=
6585
6586 call-seq:
6587 m_authUserName=(x) -> char
6588
6589 Set new value for attribute.
6590
6591 */
6592 SWIGINTERN VALUE
6593 _wrap_OpalParamRegistration_m_authUserName_set(int argc, VALUE *argv, VALUE self) {
6594 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6595 char *arg2 = (char *) 0 ;
6596 void *argp1 = 0 ;
6597 int res1 = 0 ;
6598 int res2 ;
6599 char *buf2 = 0 ;
6600 int alloc2 = 0 ;
6601
6602 if ((argc < 1) || (argc > 1)) {
6603 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6604 }
6605 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6606 if (!SWIG_IsOK(res1)) {
6607 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_authUserName", 1, self ));
6608 }
6609 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6610 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6611 if (!SWIG_IsOK(res2)) {
6612 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_authUserName", 2, argv[0] ));
6613 }
6614 arg2 = reinterpret_cast< char * >(buf2);
6615 if (arg2) {
6616 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
6617 arg1->m_authUserName = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
6618 } else {
6619 arg1->m_authUserName = 0;
6620 }
6621 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6622 return Qnil;
6623 fail:
6624 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6625 return Qnil;
6626 }
6627
6628
6629 SWIGINTERN VALUE
6630 _wrap_OpalParamRegistration_m_authUserName_get(int argc, VALUE *argv, VALUE self) {
6631 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6632 void *argp1 = 0 ;
6633 int res1 = 0 ;
6634 char *result = 0 ;
6635 VALUE vresult = Qnil;
6636
6637 if ((argc < 0) || (argc > 0)) {
6638 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6639 }
6640 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6641 if (!SWIG_IsOK(res1)) {
6642 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_authUserName", 1, self ));
6643 }
6644 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6645 result = (char *) ((arg1)->m_authUserName);
6646 vresult = SWIG_FromCharPtr((const char *)result);
6647 return vresult;
6648 fail:
6649 return Qnil;
6650 }
6651
6652
6653
6654 /*
6655 Document-method: Opal::OpalParamRegistration.m_password
6656
6657 call-seq:
6658 m_password -> char
6659
6660 Get value of attribute.
6661
6662 */
6663
6664 /*
6665 Document-method: Opal::OpalParamRegistration.m_password=
6666
6667 call-seq:
6668 m_password=(x) -> char
6669
6670 Set new value for attribute.
6671
6672 */
6673 SWIGINTERN VALUE
6674 _wrap_OpalParamRegistration_m_password_set(int argc, VALUE *argv, VALUE self) {
6675 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6676 char *arg2 = (char *) 0 ;
6677 void *argp1 = 0 ;
6678 int res1 = 0 ;
6679 int res2 ;
6680 char *buf2 = 0 ;
6681 int alloc2 = 0 ;
6682
6683 if ((argc < 1) || (argc > 1)) {
6684 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6685 }
6686 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6687 if (!SWIG_IsOK(res1)) {
6688 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_password", 1, self ));
6689 }
6690 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6691 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6692 if (!SWIG_IsOK(res2)) {
6693 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_password", 2, argv[0] ));
6694 }
6695 arg2 = reinterpret_cast< char * >(buf2);
6696 if (arg2) {
6697 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
6698 arg1->m_password = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
6699 } else {
6700 arg1->m_password = 0;
6701 }
6702 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6703 return Qnil;
6704 fail:
6705 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6706 return Qnil;
6707 }
6708
6709
6710 SWIGINTERN VALUE
6711 _wrap_OpalParamRegistration_m_password_get(int argc, VALUE *argv, VALUE self) {
6712 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6713 void *argp1 = 0 ;
6714 int res1 = 0 ;
6715 char *result = 0 ;
6716 VALUE vresult = Qnil;
6717
6718 if ((argc < 0) || (argc > 0)) {
6719 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6720 }
6721 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6722 if (!SWIG_IsOK(res1)) {
6723 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_password", 1, self ));
6724 }
6725 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6726 result = (char *) ((arg1)->m_password);
6727 vresult = SWIG_FromCharPtr((const char *)result);
6728 return vresult;
6729 fail:
6730 return Qnil;
6731 }
6732
6733
6734
6735 /*
6736 Document-method: Opal::OpalParamRegistration.m_adminEntity
6737
6738 call-seq:
6739 m_adminEntity -> char
6740
6741 Get value of attribute.
6742
6743 */
6744
6745 /*
6746 Document-method: Opal::OpalParamRegistration.m_adminEntity=
6747
6748 call-seq:
6749 m_adminEntity=(x) -> char
6750
6751 Set new value for attribute.
6752
6753 */
6754 SWIGINTERN VALUE
6755 _wrap_OpalParamRegistration_m_adminEntity_set(int argc, VALUE *argv, VALUE self) {
6756 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6757 char *arg2 = (char *) 0 ;
6758 void *argp1 = 0 ;
6759 int res1 = 0 ;
6760 int res2 ;
6761 char *buf2 = 0 ;
6762 int alloc2 = 0 ;
6763
6764 if ((argc < 1) || (argc > 1)) {
6765 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6766 }
6767 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6768 if (!SWIG_IsOK(res1)) {
6769 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_adminEntity", 1, self ));
6770 }
6771 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6772 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6773 if (!SWIG_IsOK(res2)) {
6774 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_adminEntity", 2, argv[0] ));
6775 }
6776 arg2 = reinterpret_cast< char * >(buf2);
6777 if (arg2) {
6778 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
6779 arg1->m_adminEntity = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
6780 } else {
6781 arg1->m_adminEntity = 0;
6782 }
6783 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6784 return Qnil;
6785 fail:
6786 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6787 return Qnil;
6788 }
6789
6790
6791 SWIGINTERN VALUE
6792 _wrap_OpalParamRegistration_m_adminEntity_get(int argc, VALUE *argv, VALUE self) {
6793 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6794 void *argp1 = 0 ;
6795 int res1 = 0 ;
6796 char *result = 0 ;
6797 VALUE vresult = Qnil;
6798
6799 if ((argc < 0) || (argc > 0)) {
6800 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6801 }
6802 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6803 if (!SWIG_IsOK(res1)) {
6804 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_adminEntity", 1, self ));
6805 }
6806 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6807 result = (char *) ((arg1)->m_adminEntity);
6808 vresult = SWIG_FromCharPtr((const char *)result);
6809 return vresult;
6810 fail:
6811 return Qnil;
6812 }
6813
6814
6815
6816 /*
6817 Document-method: Opal::OpalParamRegistration.m_timeToLive
6818
6819 call-seq:
6820 m_timeToLive -> unsigned int
6821
6822 Get value of attribute.
6823
6824 */
6825
6826 /*
6827 Document-method: Opal::OpalParamRegistration.m_timeToLive=
6828
6829 call-seq:
6830 m_timeToLive=(x) -> unsigned int
6831
6832 Set new value for attribute.
6833
6834 */
6835 SWIGINTERN VALUE
6836 _wrap_OpalParamRegistration_m_timeToLive_set(int argc, VALUE *argv, VALUE self) {
6837 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6838 unsigned int arg2 ;
6839 void *argp1 = 0 ;
6840 int res1 = 0 ;
6841 unsigned int val2 ;
6842 int ecode2 = 0 ;
6843
6844 if ((argc < 1) || (argc > 1)) {
6845 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6846 }
6847 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6848 if (!SWIG_IsOK(res1)) {
6849 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_timeToLive", 1, self ));
6850 }
6851 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6852 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
6853 if (!SWIG_IsOK(ecode2)) {
6854 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_timeToLive", 2, argv[0] ));
6855 }
6856 arg2 = static_cast< unsigned int >(val2);
6857 if (arg1) (arg1)->m_timeToLive = arg2;
6858 return Qnil;
6859 fail:
6860 return Qnil;
6861 }
6862
6863
6864 SWIGINTERN VALUE
6865 _wrap_OpalParamRegistration_m_timeToLive_get(int argc, VALUE *argv, VALUE self) {
6866 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6867 void *argp1 = 0 ;
6868 int res1 = 0 ;
6869 unsigned int result;
6870 VALUE vresult = Qnil;
6871
6872 if ((argc < 0) || (argc > 0)) {
6873 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6874 }
6875 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6876 if (!SWIG_IsOK(res1)) {
6877 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_timeToLive", 1, self ));
6878 }
6879 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6880 result = (unsigned int) ((arg1)->m_timeToLive);
6881 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
6882 return vresult;
6883 fail:
6884 return Qnil;
6885 }
6886
6887
6888
6889 /*
6890 Document-method: Opal::OpalParamRegistration.m_restoreTime
6891
6892 call-seq:
6893 m_restoreTime -> unsigned int
6894
6895 Get value of attribute.
6896
6897 */
6898
6899 /*
6900 Document-method: Opal::OpalParamRegistration.m_restoreTime=
6901
6902 call-seq:
6903 m_restoreTime=(x) -> unsigned int
6904
6905 Set new value for attribute.
6906
6907 */
6908 SWIGINTERN VALUE
6909 _wrap_OpalParamRegistration_m_restoreTime_set(int argc, VALUE *argv, VALUE self) {
6910 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6911 unsigned int arg2 ;
6912 void *argp1 = 0 ;
6913 int res1 = 0 ;
6914 unsigned int val2 ;
6915 int ecode2 = 0 ;
6916
6917 if ((argc < 1) || (argc > 1)) {
6918 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6919 }
6920 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6921 if (!SWIG_IsOK(res1)) {
6922 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_restoreTime", 1, self ));
6923 }
6924 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6925 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
6926 if (!SWIG_IsOK(ecode2)) {
6927 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_restoreTime", 2, argv[0] ));
6928 }
6929 arg2 = static_cast< unsigned int >(val2);
6930 if (arg1) (arg1)->m_restoreTime = arg2;
6931 return Qnil;
6932 fail:
6933 return Qnil;
6934 }
6935
6936
6937 SWIGINTERN VALUE
6938 _wrap_OpalParamRegistration_m_restoreTime_get(int argc, VALUE *argv, VALUE self) {
6939 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6940 void *argp1 = 0 ;
6941 int res1 = 0 ;
6942 unsigned int result;
6943 VALUE vresult = Qnil;
6944
6945 if ((argc < 0) || (argc > 0)) {
6946 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6947 }
6948 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6949 if (!SWIG_IsOK(res1)) {
6950 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_restoreTime", 1, self ));
6951 }
6952 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6953 result = (unsigned int) ((arg1)->m_restoreTime);
6954 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
6955 return vresult;
6956 fail:
6957 return Qnil;
6958 }
6959
6960
6961
6962 /*
6963 Document-method: Opal::OpalParamRegistration.m_eventPackage
6964
6965 call-seq:
6966 m_eventPackage -> char
6967
6968 Get value of attribute.
6969
6970 */
6971
6972 /*
6973 Document-method: Opal::OpalParamRegistration.m_eventPackage=
6974
6975 call-seq:
6976 m_eventPackage=(x) -> char
6977
6978 Set new value for attribute.
6979
6980 */
6981 SWIGINTERN VALUE
6982 _wrap_OpalParamRegistration_m_eventPackage_set(int argc, VALUE *argv, VALUE self) {
6983 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
6984 char *arg2 = (char *) 0 ;
6985 void *argp1 = 0 ;
6986 int res1 = 0 ;
6987 int res2 ;
6988 char *buf2 = 0 ;
6989 int alloc2 = 0 ;
6990
6991 if ((argc < 1) || (argc > 1)) {
6992 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6993 }
6994 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
6995 if (!SWIG_IsOK(res1)) {
6996 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_eventPackage", 1, self ));
6997 }
6998 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
6999 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7000 if (!SWIG_IsOK(res2)) {
7001 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_eventPackage", 2, argv[0] ));
7002 }
7003 arg2 = reinterpret_cast< char * >(buf2);
7004 if (arg2) {
7005 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
7006 arg1->m_eventPackage = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
7007 } else {
7008 arg1->m_eventPackage = 0;
7009 }
7010 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7011 return Qnil;
7012 fail:
7013 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7014 return Qnil;
7015 }
7016
7017
7018 SWIGINTERN VALUE
7019 _wrap_OpalParamRegistration_m_eventPackage_get(int argc, VALUE *argv, VALUE self) {
7020 OpalParamRegistration *arg1 = (OpalParamRegistration *) 0 ;
7021 void *argp1 = 0 ;
7022 int res1 = 0 ;
7023 char *result = 0 ;
7024 VALUE vresult = Qnil;
7025
7026 if ((argc < 0) || (argc > 0)) {
7027 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7028 }
7029 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
7030 if (!SWIG_IsOK(res1)) {
7031 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_eventPackage", 1, self ));
7032 }
7033 arg1 = reinterpret_cast< OpalParamRegistration * >(argp1);
7034 result = (char *) ((arg1)->m_eventPackage);
7035 vresult = SWIG_FromCharPtr((const char *)result);
7036 return vresult;
7037 fail:
7038 return Qnil;
7039 }
7040
7041
7042 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
7043 SWIGINTERN VALUE
7044 _wrap_OpalParamRegistration_allocate(VALUE self) {
7045 #else
7046 SWIGINTERN VALUE
7047 _wrap_OpalParamRegistration_allocate(int argc, VALUE *argv, VALUE self) {
7048 #endif
7049
7050
7051 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalParamRegistration);
7052 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
7053 rb_obj_call_init(vresult, argc, argv);
7054 #endif
7055 return vresult;
7056 }
7057
7058
7059
7060 /*
7061 Document-method: Opal::OpalParamRegistration.new
7062
7063 call-seq:
7064 OpalParamRegistration.new
7065
7066 Class constructor.
7067
7068 */
7069 SWIGINTERN VALUE
7070 _wrap_new_OpalParamRegistration(int argc, VALUE *argv, VALUE self) {
7071 OpalParamRegistration *result = 0 ;
7072
7073 if ((argc < 0) || (argc > 0)) {
7074 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7075 }
7076 result = (OpalParamRegistration *)new OpalParamRegistration();
7077 DATA_PTR(self) = result;
7078 return self;
7079 fail:
7080 return Qnil;
7081 }
7082
7083
7084 SWIGINTERN void
7085 free_OpalParamRegistration(OpalParamRegistration *arg1) {
7086 delete arg1;
7087 }
7088
7089
7090 /*
7091 Document-class: Opal::OpalStatusRegistration
7092
7093 Proxy of C++ Opal::OpalStatusRegistration class
7094
7095
7096 */
7097 swig_class SwigClassOpalStatusRegistration;
7098
7099
7100 /*
7101 Document-method: Opal::OpalStatusRegistration.m_protocol
7102
7103 call-seq:
7104 m_protocol -> char
7105
7106 Get value of attribute.
7107
7108 */
7109
7110 /*
7111 Document-method: Opal::OpalStatusRegistration.m_protocol=
7112
7113 call-seq:
7114 m_protocol=(x) -> char
7115
7116 Set new value for attribute.
7117
7118 */
7119 SWIGINTERN VALUE
7120 _wrap_OpalStatusRegistration_m_protocol_set(int argc, VALUE *argv, VALUE self) {
7121 OpalStatusRegistration *arg1 = (OpalStatusRegistration *) 0 ;
7122 char *arg2 = (char *) 0 ;
7123 void *argp1 = 0 ;
7124 int res1 = 0 ;
7125 int res2 ;
7126 char *buf2 = 0 ;
7127 int alloc2 = 0 ;
7128
7129 if ((argc < 1) || (argc > 1)) {
7130 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7131 }
7132 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
7133 if (!SWIG_IsOK(res1)) {
7134 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusRegistration *","m_protocol", 1, self ));
7135 }
7136 arg1 = reinterpret_cast< OpalStatusRegistration * >(argp1);
7137 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7138 if (!SWIG_IsOK(res2)) {
7139 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_protocol", 2, argv[0] ));
7140 }
7141 arg2 = reinterpret_cast< char * >(buf2);
7142 if (arg2) {
7143 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
7144 arg1->m_protocol = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
7145 } else {
7146 arg1->m_protocol = 0;
7147 }
7148 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7149 return Qnil;
7150 fail:
7151 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7152 return Qnil;
7153 }
7154
7155
7156 SWIGINTERN VALUE
7157 _wrap_OpalStatusRegistration_m_protocol_get(int argc, VALUE *argv, VALUE self) {
7158 OpalStatusRegistration *arg1 = (OpalStatusRegistration *) 0 ;
7159 void *argp1 = 0 ;
7160 int res1 = 0 ;
7161 char *result = 0 ;
7162 VALUE vresult = Qnil;
7163
7164 if ((argc < 0) || (argc > 0)) {
7165 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7166 }
7167 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
7168 if (!SWIG_IsOK(res1)) {
7169 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusRegistration *","m_protocol", 1, self ));
7170 }
7171 arg1 = reinterpret_cast< OpalStatusRegistration * >(argp1);
7172 result = (char *) ((arg1)->m_protocol);
7173 vresult = SWIG_FromCharPtr((const char *)result);
7174 return vresult;
7175 fail:
7176 return Qnil;
7177 }
7178
7179
7180
7181 /*
7182 Document-method: Opal::OpalStatusRegistration.m_serverName
7183
7184 call-seq:
7185 m_serverName -> char
7186
7187 Get value of attribute.
7188
7189 */
7190
7191 /*
7192 Document-method: Opal::OpalStatusRegistration.m_serverName=
7193
7194 call-seq:
7195 m_serverName=(x) -> char
7196
7197 Set new value for attribute.
7198
7199 */
7200 SWIGINTERN VALUE
7201 _wrap_OpalStatusRegistration_m_serverName_set(int argc, VALUE *argv, VALUE self) {
7202 OpalStatusRegistration *arg1 = (OpalStatusRegistration *) 0 ;
7203 char *arg2 = (char *) 0 ;
7204 void *argp1 = 0 ;
7205 int res1 = 0 ;
7206 int res2 ;
7207 char *buf2 = 0 ;
7208 int alloc2 = 0 ;
7209
7210 if ((argc < 1) || (argc > 1)) {
7211 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7212 }
7213 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
7214 if (!SWIG_IsOK(res1)) {
7215 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusRegistration *","m_serverName", 1, self ));
7216 }
7217 arg1 = reinterpret_cast< OpalStatusRegistration * >(argp1);
7218 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7219 if (!SWIG_IsOK(res2)) {
7220 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_serverName", 2, argv[0] ));
7221 }
7222 arg2 = reinterpret_cast< char * >(buf2);
7223 if (arg2) {
7224 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
7225 arg1->m_serverName = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
7226 } else {
7227 arg1->m_serverName = 0;
7228 }
7229 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7230 return Qnil;
7231 fail:
7232 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7233 return Qnil;
7234 }
7235
7236
7237 SWIGINTERN VALUE
7238 _wrap_OpalStatusRegistration_m_serverName_get(int argc, VALUE *argv, VALUE self) {
7239 OpalStatusRegistration *arg1 = (OpalStatusRegistration *) 0 ;
7240 void *argp1 = 0 ;
7241 int res1 = 0 ;
7242 char *result = 0 ;
7243 VALUE vresult = Qnil;
7244
7245 if ((argc < 0) || (argc > 0)) {
7246 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7247 }
7248 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
7249 if (!SWIG_IsOK(res1)) {
7250 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusRegistration *","m_serverName", 1, self ));
7251 }
7252 arg1 = reinterpret_cast< OpalStatusRegistration * >(argp1);
7253 result = (char *) ((arg1)->m_serverName);
7254 vresult = SWIG_FromCharPtr((const char *)result);
7255 return vresult;
7256 fail:
7257 return Qnil;
7258 }
7259
7260
7261
7262 /*
7263 Document-method: Opal::OpalStatusRegistration.m_error
7264
7265 call-seq:
7266 m_error -> char
7267
7268 Get value of attribute.
7269
7270 */
7271
7272 /*
7273 Document-method: Opal::OpalStatusRegistration.m_error=
7274
7275 call-seq:
7276 m_error=(x) -> char
7277
7278 Set new value for attribute.
7279
7280 */
7281 SWIGINTERN VALUE
7282 _wrap_OpalStatusRegistration_m_error_set(int argc, VALUE *argv, VALUE self) {
7283 OpalStatusRegistration *arg1 = (OpalStatusRegistration *) 0 ;
7284 char *arg2 = (char *) 0 ;
7285 void *argp1 = 0 ;
7286 int res1 = 0 ;
7287 int res2 ;
7288 char *buf2 = 0 ;
7289 int alloc2 = 0 ;
7290
7291 if ((argc < 1) || (argc > 1)) {
7292 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7293 }
7294 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
7295 if (!SWIG_IsOK(res1)) {
7296 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusRegistration *","m_error", 1, self ));
7297 }
7298 arg1 = reinterpret_cast< OpalStatusRegistration * >(argp1);
7299 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7300 if (!SWIG_IsOK(res2)) {
7301 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_error", 2, argv[0] ));
7302 }
7303 arg2 = reinterpret_cast< char * >(buf2);
7304 if (arg2) {
7305 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
7306 arg1->m_error = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
7307 } else {
7308 arg1->m_error = 0;
7309 }
7310 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7311 return Qnil;
7312 fail:
7313 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7314 return Qnil;
7315 }
7316
7317
7318 SWIGINTERN VALUE
7319 _wrap_OpalStatusRegistration_m_error_get(int argc, VALUE *argv, VALUE self) {
7320 OpalStatusRegistration *arg1 = (OpalStatusRegistration *) 0 ;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 char *result = 0 ;
7324 VALUE vresult = Qnil;
7325
7326 if ((argc < 0) || (argc > 0)) {
7327 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7328 }
7329 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
7330 if (!SWIG_IsOK(res1)) {
7331 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusRegistration *","m_error", 1, self ));
7332 }
7333 arg1 = reinterpret_cast< OpalStatusRegistration * >(argp1);
7334 result = (char *) ((arg1)->m_error);
7335 vresult = SWIG_FromCharPtr((const char *)result);
7336 return vresult;
7337 fail:
7338 return Qnil;
7339 }
7340
7341
7342
7343 /*
7344 Document-method: Opal::OpalStatusRegistration.m_status
7345
7346 call-seq:
7347 m_status -> int
7348
7349 Get value of attribute.
7350
7351 */
7352
7353 /*
7354 Document-method: Opal::OpalStatusRegistration.m_status=
7355
7356 call-seq:
7357 m_status=(x) -> int
7358
7359 Set new value for attribute.
7360
7361 */
7362 SWIGINTERN VALUE
7363 _wrap_OpalStatusRegistration_m_status_set(int argc, VALUE *argv, VALUE self) {
7364 OpalStatusRegistration *arg1 = (OpalStatusRegistration *) 0 ;
7365 OpalRegistrationStates arg2 ;
7366 void *argp1 = 0 ;
7367 int res1 = 0 ;
7368 int val2 ;
7369 int ecode2 = 0 ;
7370
7371 if ((argc < 1) || (argc > 1)) {
7372 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7373 }
7374 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
7375 if (!SWIG_IsOK(res1)) {
7376 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusRegistration *","m_status", 1, self ));
7377 }
7378 arg1 = reinterpret_cast< OpalStatusRegistration * >(argp1);
7379 ecode2 = SWIG_AsVal_int(argv[0], &val2);
7380 if (!SWIG_IsOK(ecode2)) {
7381 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalRegistrationStates","m_status", 2, argv[0] ));
7382 }
7383 arg2 = static_cast< OpalRegistrationStates >(val2);
7384 if (arg1) (arg1)->m_status = arg2;
7385 return Qnil;
7386 fail:
7387 return Qnil;
7388 }
7389
7390
7391 SWIGINTERN VALUE
7392 _wrap_OpalStatusRegistration_m_status_get(int argc, VALUE *argv, VALUE self) {
7393 OpalStatusRegistration *arg1 = (OpalStatusRegistration *) 0 ;
7394 void *argp1 = 0 ;
7395 int res1 = 0 ;
7396 OpalRegistrationStates result;
7397 VALUE vresult = Qnil;
7398
7399 if ((argc < 0) || (argc > 0)) {
7400 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7401 }
7402 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
7403 if (!SWIG_IsOK(res1)) {
7404 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusRegistration *","m_status", 1, self ));
7405 }
7406 arg1 = reinterpret_cast< OpalStatusRegistration * >(argp1);
7407 result = (OpalRegistrationStates) ((arg1)->m_status);
7408 vresult = SWIG_From_int(static_cast< int >(result));
7409 return vresult;
7410 fail:
7411 return Qnil;
7412 }
7413
7414
7415
7416 /*
7417 Document-method: Opal::OpalStatusRegistration.m_product
7418
7419 call-seq:
7420 m_product -> OpalProductDescription
7421
7422 Get value of attribute.
7423
7424 */
7425
7426 /*
7427 Document-method: Opal::OpalStatusRegistration.m_product=
7428
7429 call-seq:
7430 m_product=(x) -> OpalProductDescription
7431
7432 Set new value for attribute.
7433
7434 */
7435 SWIGINTERN VALUE
7436 _wrap_OpalStatusRegistration_m_product_set(int argc, VALUE *argv, VALUE self) {
7437 OpalStatusRegistration *arg1 = (OpalStatusRegistration *) 0 ;
7438 OpalProductDescription *arg2 = (OpalProductDescription *) 0 ;
7439 void *argp1 = 0 ;
7440 int res1 = 0 ;
7441 void *argp2 = 0 ;
7442 int res2 = 0 ;
7443
7444 if ((argc < 1) || (argc > 1)) {
7445 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7446 }
7447 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
7448 if (!SWIG_IsOK(res1)) {
7449 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusRegistration *","m_product", 1, self ));
7450 }
7451 arg1 = reinterpret_cast< OpalStatusRegistration * >(argp1);
7452 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
7453 if (!SWIG_IsOK(res2)) {
7454 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalProductDescription *","m_product", 2, argv[0] ));
7455 }
7456 arg2 = reinterpret_cast< OpalProductDescription * >(argp2);
7457 if (arg1) (arg1)->m_product = *arg2;
7458 return Qnil;
7459 fail:
7460 return Qnil;
7461 }
7462
7463
7464 SWIGINTERN VALUE
7465 _wrap_OpalStatusRegistration_m_product_get(int argc, VALUE *argv, VALUE self) {
7466 OpalStatusRegistration *arg1 = (OpalStatusRegistration *) 0 ;
7467 void *argp1 = 0 ;
7468 int res1 = 0 ;
7469 OpalProductDescription *result = 0 ;
7470 VALUE vresult = Qnil;
7471
7472 if ((argc < 0) || (argc > 0)) {
7473 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7474 }
7475 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
7476 if (!SWIG_IsOK(res1)) {
7477 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusRegistration *","m_product", 1, self ));
7478 }
7479 arg1 = reinterpret_cast< OpalStatusRegistration * >(argp1);
7480 result = (OpalProductDescription *)& ((arg1)->m_product);
7481 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalProductDescription, 0 | 0 );
7482 return vresult;
7483 fail:
7484 return Qnil;
7485 }
7486
7487
7488 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
7489 SWIGINTERN VALUE
7490 _wrap_OpalStatusRegistration_allocate(VALUE self) {
7491 #else
7492 SWIGINTERN VALUE
7493 _wrap_OpalStatusRegistration_allocate(int argc, VALUE *argv, VALUE self) {
7494 #endif
7495
7496
7497 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalStatusRegistration);
7498 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
7499 rb_obj_call_init(vresult, argc, argv);
7500 #endif
7501 return vresult;
7502 }
7503
7504
7505
7506 /*
7507 Document-method: Opal::OpalStatusRegistration.new
7508
7509 call-seq:
7510 OpalStatusRegistration.new
7511
7512 Class constructor.
7513
7514 */
7515 SWIGINTERN VALUE
7516 _wrap_new_OpalStatusRegistration(int argc, VALUE *argv, VALUE self) {
7517 OpalStatusRegistration *result = 0 ;
7518
7519 if ((argc < 0) || (argc > 0)) {
7520 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7521 }
7522 result = (OpalStatusRegistration *)new OpalStatusRegistration();
7523 DATA_PTR(self) = result;
7524 return self;
7525 fail:
7526 return Qnil;
7527 }
7528
7529
7530 SWIGINTERN void
7531 free_OpalStatusRegistration(OpalStatusRegistration *arg1) {
7532 delete arg1;
7533 }
7534
7535
7536 /*
7537 Document-class: Opal::OpalParamSetUpCall
7538
7539 Proxy of C++ Opal::OpalParamSetUpCall class
7540
7541
7542 */
7543 swig_class SwigClassOpalParamSetUpCall;
7544
7545
7546 /*
7547 Document-method: Opal::OpalParamSetUpCall.m_partyA
7548
7549 call-seq:
7550 m_partyA -> char
7551
7552 Get value of attribute.
7553
7554 */
7555
7556 /*
7557 Document-method: Opal::OpalParamSetUpCall.m_partyA=
7558
7559 call-seq:
7560 m_partyA=(x) -> char
7561
7562 Set new value for attribute.
7563
7564 */
7565 SWIGINTERN VALUE
7566 _wrap_OpalParamSetUpCall_m_partyA_set(int argc, VALUE *argv, VALUE self) {
7567 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
7568 char *arg2 = (char *) 0 ;
7569 void *argp1 = 0 ;
7570 int res1 = 0 ;
7571 int res2 ;
7572 char *buf2 = 0 ;
7573 int alloc2 = 0 ;
7574
7575 if ((argc < 1) || (argc > 1)) {
7576 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7577 }
7578 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
7579 if (!SWIG_IsOK(res1)) {
7580 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_partyA", 1, self ));
7581 }
7582 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
7583 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7584 if (!SWIG_IsOK(res2)) {
7585 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_partyA", 2, argv[0] ));
7586 }
7587 arg2 = reinterpret_cast< char * >(buf2);
7588 if (arg2) {
7589 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
7590 arg1->m_partyA = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
7591 } else {
7592 arg1->m_partyA = 0;
7593 }
7594 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7595 return Qnil;
7596 fail:
7597 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7598 return Qnil;
7599 }
7600
7601
7602 SWIGINTERN VALUE
7603 _wrap_OpalParamSetUpCall_m_partyA_get(int argc, VALUE *argv, VALUE self) {
7604 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
7605 void *argp1 = 0 ;
7606 int res1 = 0 ;
7607 char *result = 0 ;
7608 VALUE vresult = Qnil;
7609
7610 if ((argc < 0) || (argc > 0)) {
7611 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7612 }
7613 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
7614 if (!SWIG_IsOK(res1)) {
7615 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_partyA", 1, self ));
7616 }
7617 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
7618 result = (char *) ((arg1)->m_partyA);
7619 vresult = SWIG_FromCharPtr((const char *)result);
7620 return vresult;
7621 fail:
7622 return Qnil;
7623 }
7624
7625
7626
7627 /*
7628 Document-method: Opal::OpalParamSetUpCall.m_partyB
7629
7630 call-seq:
7631 m_partyB -> char
7632
7633 Get value of attribute.
7634
7635 */
7636
7637 /*
7638 Document-method: Opal::OpalParamSetUpCall.m_partyB=
7639
7640 call-seq:
7641 m_partyB=(x) -> char
7642
7643 Set new value for attribute.
7644
7645 */
7646 SWIGINTERN VALUE
7647 _wrap_OpalParamSetUpCall_m_partyB_set(int argc, VALUE *argv, VALUE self) {
7648 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
7649 char *arg2 = (char *) 0 ;
7650 void *argp1 = 0 ;
7651 int res1 = 0 ;
7652 int res2 ;
7653 char *buf2 = 0 ;
7654 int alloc2 = 0 ;
7655
7656 if ((argc < 1) || (argc > 1)) {
7657 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7658 }
7659 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
7660 if (!SWIG_IsOK(res1)) {
7661 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_partyB", 1, self ));
7662 }
7663 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
7664 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7665 if (!SWIG_IsOK(res2)) {
7666 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_partyB", 2, argv[0] ));
7667 }
7668 arg2 = reinterpret_cast< char * >(buf2);
7669 if (arg2) {
7670 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
7671 arg1->m_partyB = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
7672 } else {
7673 arg1->m_partyB = 0;
7674 }
7675 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7676 return Qnil;
7677 fail:
7678 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7679 return Qnil;
7680 }
7681
7682
7683 SWIGINTERN VALUE
7684 _wrap_OpalParamSetUpCall_m_partyB_get(int argc, VALUE *argv, VALUE self) {
7685 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
7686 void *argp1 = 0 ;
7687 int res1 = 0 ;
7688 char *result = 0 ;
7689 VALUE vresult = Qnil;
7690
7691 if ((argc < 0) || (argc > 0)) {
7692 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7693 }
7694 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
7695 if (!SWIG_IsOK(res1)) {
7696 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_partyB", 1, self ));
7697 }
7698 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
7699 result = (char *) ((arg1)->m_partyB);
7700 vresult = SWIG_FromCharPtr((const char *)result);
7701 return vresult;
7702 fail:
7703 return Qnil;
7704 }
7705
7706
7707
7708 /*
7709 Document-method: Opal::OpalParamSetUpCall.m_callToken
7710
7711 call-seq:
7712 m_callToken -> char
7713
7714 Get value of attribute.
7715
7716 */
7717
7718 /*
7719 Document-method: Opal::OpalParamSetUpCall.m_callToken=
7720
7721 call-seq:
7722 m_callToken=(x) -> char
7723
7724 Set new value for attribute.
7725
7726 */
7727 SWIGINTERN VALUE
7728 _wrap_OpalParamSetUpCall_m_callToken_set(int argc, VALUE *argv, VALUE self) {
7729 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
7730 char *arg2 = (char *) 0 ;
7731 void *argp1 = 0 ;
7732 int res1 = 0 ;
7733 int res2 ;
7734 char *buf2 = 0 ;
7735 int alloc2 = 0 ;
7736
7737 if ((argc < 1) || (argc > 1)) {
7738 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7739 }
7740 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
7741 if (!SWIG_IsOK(res1)) {
7742 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_callToken", 1, self ));
7743 }
7744 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
7745 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7746 if (!SWIG_IsOK(res2)) {
7747 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
7748 }
7749 arg2 = reinterpret_cast< char * >(buf2);
7750 if (arg2) {
7751 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
7752 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
7753 } else {
7754 arg1->m_callToken = 0;
7755 }
7756 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7757 return Qnil;
7758 fail:
7759 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7760 return Qnil;
7761 }
7762
7763
7764 SWIGINTERN VALUE
7765 _wrap_OpalParamSetUpCall_m_callToken_get(int argc, VALUE *argv, VALUE self) {
7766 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
7767 void *argp1 = 0 ;
7768 int res1 = 0 ;
7769 char *result = 0 ;
7770 VALUE vresult = Qnil;
7771
7772 if ((argc < 0) || (argc > 0)) {
7773 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7774 }
7775 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
7776 if (!SWIG_IsOK(res1)) {
7777 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_callToken", 1, self ));
7778 }
7779 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
7780 result = (char *) ((arg1)->m_callToken);
7781 vresult = SWIG_FromCharPtr((const char *)result);
7782 return vresult;
7783 fail:
7784 return Qnil;
7785 }
7786
7787
7788
7789 /*
7790 Document-method: Opal::OpalParamSetUpCall.m_alertingType
7791
7792 call-seq:
7793 m_alertingType -> char
7794
7795 Get value of attribute.
7796
7797 */
7798
7799 /*
7800 Document-method: Opal::OpalParamSetUpCall.m_alertingType=
7801
7802 call-seq:
7803 m_alertingType=(x) -> char
7804
7805 Set new value for attribute.
7806
7807 */
7808 SWIGINTERN VALUE
7809 _wrap_OpalParamSetUpCall_m_alertingType_set(int argc, VALUE *argv, VALUE self) {
7810 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
7811 char *arg2 = (char *) 0 ;
7812 void *argp1 = 0 ;
7813 int res1 = 0 ;
7814 int res2 ;
7815 char *buf2 = 0 ;
7816 int alloc2 = 0 ;
7817
7818 if ((argc < 1) || (argc > 1)) {
7819 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7820 }
7821 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
7822 if (!SWIG_IsOK(res1)) {
7823 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_alertingType", 1, self ));
7824 }
7825 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
7826 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7827 if (!SWIG_IsOK(res2)) {
7828 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_alertingType", 2, argv[0] ));
7829 }
7830 arg2 = reinterpret_cast< char * >(buf2);
7831 if (arg2) {
7832 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
7833 arg1->m_alertingType = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
7834 } else {
7835 arg1->m_alertingType = 0;
7836 }
7837 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7838 return Qnil;
7839 fail:
7840 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7841 return Qnil;
7842 }
7843
7844
7845 SWIGINTERN VALUE
7846 _wrap_OpalParamSetUpCall_m_alertingType_get(int argc, VALUE *argv, VALUE self) {
7847 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
7848 void *argp1 = 0 ;
7849 int res1 = 0 ;
7850 char *result = 0 ;
7851 VALUE vresult = Qnil;
7852
7853 if ((argc < 0) || (argc > 0)) {
7854 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7855 }
7856 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
7857 if (!SWIG_IsOK(res1)) {
7858 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_alertingType", 1, self ));
7859 }
7860 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
7861 result = (char *) ((arg1)->m_alertingType);
7862 vresult = SWIG_FromCharPtr((const char *)result);
7863 return vresult;
7864 fail:
7865 return Qnil;
7866 }
7867
7868
7869
7870 /*
7871 Document-method: Opal::OpalParamSetUpCall.m_protocolCallId
7872
7873 call-seq:
7874 m_protocolCallId -> char
7875
7876 Get value of attribute.
7877
7878 */
7879
7880 /*
7881 Document-method: Opal::OpalParamSetUpCall.m_protocolCallId=
7882
7883 call-seq:
7884 m_protocolCallId=(x) -> char
7885
7886 Set new value for attribute.
7887
7888 */
7889 SWIGINTERN VALUE
7890 _wrap_OpalParamSetUpCall_m_protocolCallId_set(int argc, VALUE *argv, VALUE self) {
7891 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
7892 char *arg2 = (char *) 0 ;
7893 void *argp1 = 0 ;
7894 int res1 = 0 ;
7895 int res2 ;
7896 char *buf2 = 0 ;
7897 int alloc2 = 0 ;
7898
7899 if ((argc < 1) || (argc > 1)) {
7900 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7901 }
7902 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
7903 if (!SWIG_IsOK(res1)) {
7904 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_protocolCallId", 1, self ));
7905 }
7906 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
7907 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
7908 if (!SWIG_IsOK(res2)) {
7909 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_protocolCallId", 2, argv[0] ));
7910 }
7911 arg2 = reinterpret_cast< char * >(buf2);
7912 if (arg2) {
7913 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
7914 arg1->m_protocolCallId = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
7915 } else {
7916 arg1->m_protocolCallId = 0;
7917 }
7918 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7919 return Qnil;
7920 fail:
7921 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7922 return Qnil;
7923 }
7924
7925
7926 SWIGINTERN VALUE
7927 _wrap_OpalParamSetUpCall_m_protocolCallId_get(int argc, VALUE *argv, VALUE self) {
7928 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
7929 void *argp1 = 0 ;
7930 int res1 = 0 ;
7931 char *result = 0 ;
7932 VALUE vresult = Qnil;
7933
7934 if ((argc < 0) || (argc > 0)) {
7935 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7936 }
7937 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
7938 if (!SWIG_IsOK(res1)) {
7939 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_protocolCallId", 1, self ));
7940 }
7941 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
7942 result = (char *) ((arg1)->m_protocolCallId);
7943 vresult = SWIG_FromCharPtr((const char *)result);
7944 return vresult;
7945 fail:
7946 return Qnil;
7947 }
7948
7949
7950
7951 /*
7952 Document-method: Opal::OpalParamSetUpCall.m_overrides
7953
7954 call-seq:
7955 m_overrides -> OpalParamProtocol
7956
7957 Get value of attribute.
7958
7959 */
7960
7961 /*
7962 Document-method: Opal::OpalParamSetUpCall.m_overrides=
7963
7964 call-seq:
7965 m_overrides=(x) -> OpalParamProtocol
7966
7967 Set new value for attribute.
7968
7969 */
7970 SWIGINTERN VALUE
7971 _wrap_OpalParamSetUpCall_m_overrides_set(int argc, VALUE *argv, VALUE self) {
7972 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
7973 OpalParamProtocol *arg2 = (OpalParamProtocol *) 0 ;
7974 void *argp1 = 0 ;
7975 int res1 = 0 ;
7976 void *argp2 = 0 ;
7977 int res2 = 0 ;
7978
7979 if ((argc < 1) || (argc > 1)) {
7980 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7981 }
7982 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
7983 if (!SWIG_IsOK(res1)) {
7984 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_overrides", 1, self ));
7985 }
7986 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
7987 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
7988 if (!SWIG_IsOK(res2)) {
7989 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_overrides", 2, argv[0] ));
7990 }
7991 arg2 = reinterpret_cast< OpalParamProtocol * >(argp2);
7992 if (arg1) (arg1)->m_overrides = *arg2;
7993 return Qnil;
7994 fail:
7995 return Qnil;
7996 }
7997
7998
7999 SWIGINTERN VALUE
8000 _wrap_OpalParamSetUpCall_m_overrides_get(int argc, VALUE *argv, VALUE self) {
8001 OpalParamSetUpCall *arg1 = (OpalParamSetUpCall *) 0 ;
8002 void *argp1 = 0 ;
8003 int res1 = 0 ;
8004 OpalParamProtocol *result = 0 ;
8005 VALUE vresult = Qnil;
8006
8007 if ((argc < 0) || (argc > 0)) {
8008 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8009 }
8010 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
8011 if (!SWIG_IsOK(res1)) {
8012 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_overrides", 1, self ));
8013 }
8014 arg1 = reinterpret_cast< OpalParamSetUpCall * >(argp1);
8015 result = (OpalParamProtocol *)& ((arg1)->m_overrides);
8016 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
8017 return vresult;
8018 fail:
8019 return Qnil;
8020 }
8021
8022
8023 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
8024 SWIGINTERN VALUE
8025 _wrap_OpalParamSetUpCall_allocate(VALUE self) {
8026 #else
8027 SWIGINTERN VALUE
8028 _wrap_OpalParamSetUpCall_allocate(int argc, VALUE *argv, VALUE self) {
8029 #endif
8030
8031
8032 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalParamSetUpCall);
8033 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
8034 rb_obj_call_init(vresult, argc, argv);
8035 #endif
8036 return vresult;
8037 }
8038
8039
8040
8041 /*
8042 Document-method: Opal::OpalParamSetUpCall.new
8043
8044 call-seq:
8045 OpalParamSetUpCall.new
8046
8047 Class constructor.
8048
8049 */
8050 SWIGINTERN VALUE
8051 _wrap_new_OpalParamSetUpCall(int argc, VALUE *argv, VALUE self) {
8052 OpalParamSetUpCall *result = 0 ;
8053
8054 if ((argc < 0) || (argc > 0)) {
8055 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8056 }
8057 result = (OpalParamSetUpCall *)new OpalParamSetUpCall();
8058 DATA_PTR(self) = result;
8059 return self;
8060 fail:
8061 return Qnil;
8062 }
8063
8064
8065 SWIGINTERN void
8066 free_OpalParamSetUpCall(OpalParamSetUpCall *arg1) {
8067 delete arg1;
8068 }
8069
8070
8071 /*
8072 Document-class: Opal::OpalStatusIncomingCall
8073
8074 Proxy of C++ Opal::OpalStatusIncomingCall class
8075
8076
8077 */
8078 swig_class SwigClassOpalStatusIncomingCall;
8079
8080
8081 /*
8082 Document-method: Opal::OpalStatusIncomingCall.m_callToken
8083
8084 call-seq:
8085 m_callToken -> char
8086
8087 Get value of attribute.
8088
8089 */
8090
8091 /*
8092 Document-method: Opal::OpalStatusIncomingCall.m_callToken=
8093
8094 call-seq:
8095 m_callToken=(x) -> char
8096
8097 Set new value for attribute.
8098
8099 */
8100 SWIGINTERN VALUE
8101 _wrap_OpalStatusIncomingCall_m_callToken_set(int argc, VALUE *argv, VALUE self) {
8102 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8103 char *arg2 = (char *) 0 ;
8104 void *argp1 = 0 ;
8105 int res1 = 0 ;
8106 int res2 ;
8107 char *buf2 = 0 ;
8108 int alloc2 = 0 ;
8109
8110 if ((argc < 1) || (argc > 1)) {
8111 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8112 }
8113 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8114 if (!SWIG_IsOK(res1)) {
8115 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_callToken", 1, self ));
8116 }
8117 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8118 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
8119 if (!SWIG_IsOK(res2)) {
8120 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
8121 }
8122 arg2 = reinterpret_cast< char * >(buf2);
8123 if (arg2) {
8124 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
8125 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
8126 } else {
8127 arg1->m_callToken = 0;
8128 }
8129 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8130 return Qnil;
8131 fail:
8132 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8133 return Qnil;
8134 }
8135
8136
8137 SWIGINTERN VALUE
8138 _wrap_OpalStatusIncomingCall_m_callToken_get(int argc, VALUE *argv, VALUE self) {
8139 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8140 void *argp1 = 0 ;
8141 int res1 = 0 ;
8142 char *result = 0 ;
8143 VALUE vresult = Qnil;
8144
8145 if ((argc < 0) || (argc > 0)) {
8146 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8147 }
8148 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8149 if (!SWIG_IsOK(res1)) {
8150 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_callToken", 1, self ));
8151 }
8152 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8153 result = (char *) ((arg1)->m_callToken);
8154 vresult = SWIG_FromCharPtr((const char *)result);
8155 return vresult;
8156 fail:
8157 return Qnil;
8158 }
8159
8160
8161
8162 /*
8163 Document-method: Opal::OpalStatusIncomingCall.m_localAddress
8164
8165 call-seq:
8166 m_localAddress -> char
8167
8168 Get value of attribute.
8169
8170 */
8171
8172 /*
8173 Document-method: Opal::OpalStatusIncomingCall.m_localAddress=
8174
8175 call-seq:
8176 m_localAddress=(x) -> char
8177
8178 Set new value for attribute.
8179
8180 */
8181 SWIGINTERN VALUE
8182 _wrap_OpalStatusIncomingCall_m_localAddress_set(int argc, VALUE *argv, VALUE self) {
8183 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8184 char *arg2 = (char *) 0 ;
8185 void *argp1 = 0 ;
8186 int res1 = 0 ;
8187 int res2 ;
8188 char *buf2 = 0 ;
8189 int alloc2 = 0 ;
8190
8191 if ((argc < 1) || (argc > 1)) {
8192 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8193 }
8194 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8195 if (!SWIG_IsOK(res1)) {
8196 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_localAddress", 1, self ));
8197 }
8198 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8199 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
8200 if (!SWIG_IsOK(res2)) {
8201 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_localAddress", 2, argv[0] ));
8202 }
8203 arg2 = reinterpret_cast< char * >(buf2);
8204 if (arg2) {
8205 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
8206 arg1->m_localAddress = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
8207 } else {
8208 arg1->m_localAddress = 0;
8209 }
8210 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8211 return Qnil;
8212 fail:
8213 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8214 return Qnil;
8215 }
8216
8217
8218 SWIGINTERN VALUE
8219 _wrap_OpalStatusIncomingCall_m_localAddress_get(int argc, VALUE *argv, VALUE self) {
8220 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8221 void *argp1 = 0 ;
8222 int res1 = 0 ;
8223 char *result = 0 ;
8224 VALUE vresult = Qnil;
8225
8226 if ((argc < 0) || (argc > 0)) {
8227 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8228 }
8229 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8230 if (!SWIG_IsOK(res1)) {
8231 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_localAddress", 1, self ));
8232 }
8233 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8234 result = (char *) ((arg1)->m_localAddress);
8235 vresult = SWIG_FromCharPtr((const char *)result);
8236 return vresult;
8237 fail:
8238 return Qnil;
8239 }
8240
8241
8242
8243 /*
8244 Document-method: Opal::OpalStatusIncomingCall.m_remoteAddress
8245
8246 call-seq:
8247 m_remoteAddress -> char
8248
8249 Get value of attribute.
8250
8251 */
8252
8253 /*
8254 Document-method: Opal::OpalStatusIncomingCall.m_remoteAddress=
8255
8256 call-seq:
8257 m_remoteAddress=(x) -> char
8258
8259 Set new value for attribute.
8260
8261 */
8262 SWIGINTERN VALUE
8263 _wrap_OpalStatusIncomingCall_m_remoteAddress_set(int argc, VALUE *argv, VALUE self) {
8264 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8265 char *arg2 = (char *) 0 ;
8266 void *argp1 = 0 ;
8267 int res1 = 0 ;
8268 int res2 ;
8269 char *buf2 = 0 ;
8270 int alloc2 = 0 ;
8271
8272 if ((argc < 1) || (argc > 1)) {
8273 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8274 }
8275 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8276 if (!SWIG_IsOK(res1)) {
8277 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_remoteAddress", 1, self ));
8278 }
8279 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8280 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
8281 if (!SWIG_IsOK(res2)) {
8282 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_remoteAddress", 2, argv[0] ));
8283 }
8284 arg2 = reinterpret_cast< char * >(buf2);
8285 if (arg2) {
8286 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
8287 arg1->m_remoteAddress = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
8288 } else {
8289 arg1->m_remoteAddress = 0;
8290 }
8291 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8292 return Qnil;
8293 fail:
8294 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8295 return Qnil;
8296 }
8297
8298
8299 SWIGINTERN VALUE
8300 _wrap_OpalStatusIncomingCall_m_remoteAddress_get(int argc, VALUE *argv, VALUE self) {
8301 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8302 void *argp1 = 0 ;
8303 int res1 = 0 ;
8304 char *result = 0 ;
8305 VALUE vresult = Qnil;
8306
8307 if ((argc < 0) || (argc > 0)) {
8308 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8309 }
8310 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8311 if (!SWIG_IsOK(res1)) {
8312 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_remoteAddress", 1, self ));
8313 }
8314 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8315 result = (char *) ((arg1)->m_remoteAddress);
8316 vresult = SWIG_FromCharPtr((const char *)result);
8317 return vresult;
8318 fail:
8319 return Qnil;
8320 }
8321
8322
8323
8324 /*
8325 Document-method: Opal::OpalStatusIncomingCall.m_remotePartyNumber
8326
8327 call-seq:
8328 m_remotePartyNumber -> char
8329
8330 Get value of attribute.
8331
8332 */
8333
8334 /*
8335 Document-method: Opal::OpalStatusIncomingCall.m_remotePartyNumber=
8336
8337 call-seq:
8338 m_remotePartyNumber=(x) -> char
8339
8340 Set new value for attribute.
8341
8342 */
8343 SWIGINTERN VALUE
8344 _wrap_OpalStatusIncomingCall_m_remotePartyNumber_set(int argc, VALUE *argv, VALUE self) {
8345 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8346 char *arg2 = (char *) 0 ;
8347 void *argp1 = 0 ;
8348 int res1 = 0 ;
8349 int res2 ;
8350 char *buf2 = 0 ;
8351 int alloc2 = 0 ;
8352
8353 if ((argc < 1) || (argc > 1)) {
8354 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8355 }
8356 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8357 if (!SWIG_IsOK(res1)) {
8358 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_remotePartyNumber", 1, self ));
8359 }
8360 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8361 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
8362 if (!SWIG_IsOK(res2)) {
8363 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_remotePartyNumber", 2, argv[0] ));
8364 }
8365 arg2 = reinterpret_cast< char * >(buf2);
8366 if (arg2) {
8367 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
8368 arg1->m_remotePartyNumber = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
8369 } else {
8370 arg1->m_remotePartyNumber = 0;
8371 }
8372 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8373 return Qnil;
8374 fail:
8375 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8376 return Qnil;
8377 }
8378
8379
8380 SWIGINTERN VALUE
8381 _wrap_OpalStatusIncomingCall_m_remotePartyNumber_get(int argc, VALUE *argv, VALUE self) {
8382 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8383 void *argp1 = 0 ;
8384 int res1 = 0 ;
8385 char *result = 0 ;
8386 VALUE vresult = Qnil;
8387
8388 if ((argc < 0) || (argc > 0)) {
8389 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8390 }
8391 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8392 if (!SWIG_IsOK(res1)) {
8393 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_remotePartyNumber", 1, self ));
8394 }
8395 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8396 result = (char *) ((arg1)->m_remotePartyNumber);
8397 vresult = SWIG_FromCharPtr((const char *)result);
8398 return vresult;
8399 fail:
8400 return Qnil;
8401 }
8402
8403
8404
8405 /*
8406 Document-method: Opal::OpalStatusIncomingCall.m_remoteDisplayName
8407
8408 call-seq:
8409 m_remoteDisplayName -> char
8410
8411 Get value of attribute.
8412
8413 */
8414
8415 /*
8416 Document-method: Opal::OpalStatusIncomingCall.m_remoteDisplayName=
8417
8418 call-seq:
8419 m_remoteDisplayName=(x) -> char
8420
8421 Set new value for attribute.
8422
8423 */
8424 SWIGINTERN VALUE
8425 _wrap_OpalStatusIncomingCall_m_remoteDisplayName_set(int argc, VALUE *argv, VALUE self) {
8426 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8427 char *arg2 = (char *) 0 ;
8428 void *argp1 = 0 ;
8429 int res1 = 0 ;
8430 int res2 ;
8431 char *buf2 = 0 ;
8432 int alloc2 = 0 ;
8433
8434 if ((argc < 1) || (argc > 1)) {
8435 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8436 }
8437 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8438 if (!SWIG_IsOK(res1)) {
8439 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_remoteDisplayName", 1, self ));
8440 }
8441 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8442 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
8443 if (!SWIG_IsOK(res2)) {
8444 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_remoteDisplayName", 2, argv[0] ));
8445 }
8446 arg2 = reinterpret_cast< char * >(buf2);
8447 if (arg2) {
8448 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
8449 arg1->m_remoteDisplayName = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
8450 } else {
8451 arg1->m_remoteDisplayName = 0;
8452 }
8453 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8454 return Qnil;
8455 fail:
8456 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8457 return Qnil;
8458 }
8459
8460
8461 SWIGINTERN VALUE
8462 _wrap_OpalStatusIncomingCall_m_remoteDisplayName_get(int argc, VALUE *argv, VALUE self) {
8463 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8464 void *argp1 = 0 ;
8465 int res1 = 0 ;
8466 char *result = 0 ;
8467 VALUE vresult = Qnil;
8468
8469 if ((argc < 0) || (argc > 0)) {
8470 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8471 }
8472 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8473 if (!SWIG_IsOK(res1)) {
8474 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_remoteDisplayName", 1, self ));
8475 }
8476 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8477 result = (char *) ((arg1)->m_remoteDisplayName);
8478 vresult = SWIG_FromCharPtr((const char *)result);
8479 return vresult;
8480 fail:
8481 return Qnil;
8482 }
8483
8484
8485
8486 /*
8487 Document-method: Opal::OpalStatusIncomingCall.m_calledAddress
8488
8489 call-seq:
8490 m_calledAddress -> char
8491
8492 Get value of attribute.
8493
8494 */
8495
8496 /*
8497 Document-method: Opal::OpalStatusIncomingCall.m_calledAddress=
8498
8499 call-seq:
8500 m_calledAddress=(x) -> char
8501
8502 Set new value for attribute.
8503
8504 */
8505 SWIGINTERN VALUE
8506 _wrap_OpalStatusIncomingCall_m_calledAddress_set(int argc, VALUE *argv, VALUE self) {
8507 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8508 char *arg2 = (char *) 0 ;
8509 void *argp1 = 0 ;
8510 int res1 = 0 ;
8511 int res2 ;
8512 char *buf2 = 0 ;
8513 int alloc2 = 0 ;
8514
8515 if ((argc < 1) || (argc > 1)) {
8516 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8517 }
8518 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8519 if (!SWIG_IsOK(res1)) {
8520 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_calledAddress", 1, self ));
8521 }
8522 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8523 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
8524 if (!SWIG_IsOK(res2)) {
8525 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_calledAddress", 2, argv[0] ));
8526 }
8527 arg2 = reinterpret_cast< char * >(buf2);
8528 if (arg2) {
8529 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
8530 arg1->m_calledAddress = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
8531 } else {
8532 arg1->m_calledAddress = 0;
8533 }
8534 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8535 return Qnil;
8536 fail:
8537 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8538 return Qnil;
8539 }
8540
8541
8542 SWIGINTERN VALUE
8543 _wrap_OpalStatusIncomingCall_m_calledAddress_get(int argc, VALUE *argv, VALUE self) {
8544 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8545 void *argp1 = 0 ;
8546 int res1 = 0 ;
8547 char *result = 0 ;
8548 VALUE vresult = Qnil;
8549
8550 if ((argc < 0) || (argc > 0)) {
8551 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8552 }
8553 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8554 if (!SWIG_IsOK(res1)) {
8555 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_calledAddress", 1, self ));
8556 }
8557 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8558 result = (char *) ((arg1)->m_calledAddress);
8559 vresult = SWIG_FromCharPtr((const char *)result);
8560 return vresult;
8561 fail:
8562 return Qnil;
8563 }
8564
8565
8566
8567 /*
8568 Document-method: Opal::OpalStatusIncomingCall.m_calledPartyNumber
8569
8570 call-seq:
8571 m_calledPartyNumber -> char
8572
8573 Get value of attribute.
8574
8575 */
8576
8577 /*
8578 Document-method: Opal::OpalStatusIncomingCall.m_calledPartyNumber=
8579
8580 call-seq:
8581 m_calledPartyNumber=(x) -> char
8582
8583 Set new value for attribute.
8584
8585 */
8586 SWIGINTERN VALUE
8587 _wrap_OpalStatusIncomingCall_m_calledPartyNumber_set(int argc, VALUE *argv, VALUE self) {
8588 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8589 char *arg2 = (char *) 0 ;
8590 void *argp1 = 0 ;
8591 int res1 = 0 ;
8592 int res2 ;
8593 char *buf2 = 0 ;
8594 int alloc2 = 0 ;
8595
8596 if ((argc < 1) || (argc > 1)) {
8597 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8598 }
8599 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8600 if (!SWIG_IsOK(res1)) {
8601 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_calledPartyNumber", 1, self ));
8602 }
8603 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8604 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
8605 if (!SWIG_IsOK(res2)) {
8606 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_calledPartyNumber", 2, argv[0] ));
8607 }
8608 arg2 = reinterpret_cast< char * >(buf2);
8609 if (arg2) {
8610 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
8611 arg1->m_calledPartyNumber = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
8612 } else {
8613 arg1->m_calledPartyNumber = 0;
8614 }
8615 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8616 return Qnil;
8617 fail:
8618 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8619 return Qnil;
8620 }
8621
8622
8623 SWIGINTERN VALUE
8624 _wrap_OpalStatusIncomingCall_m_calledPartyNumber_get(int argc, VALUE *argv, VALUE self) {
8625 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8626 void *argp1 = 0 ;
8627 int res1 = 0 ;
8628 char *result = 0 ;
8629 VALUE vresult = Qnil;
8630
8631 if ((argc < 0) || (argc > 0)) {
8632 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8633 }
8634 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8635 if (!SWIG_IsOK(res1)) {
8636 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_calledPartyNumber", 1, self ));
8637 }
8638 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8639 result = (char *) ((arg1)->m_calledPartyNumber);
8640 vresult = SWIG_FromCharPtr((const char *)result);
8641 return vresult;
8642 fail:
8643 return Qnil;
8644 }
8645
8646
8647
8648 /*
8649 Document-method: Opal::OpalStatusIncomingCall.m_product
8650
8651 call-seq:
8652 m_product -> OpalProductDescription
8653
8654 Get value of attribute.
8655
8656 */
8657
8658 /*
8659 Document-method: Opal::OpalStatusIncomingCall.m_product=
8660
8661 call-seq:
8662 m_product=(x) -> OpalProductDescription
8663
8664 Set new value for attribute.
8665
8666 */
8667 SWIGINTERN VALUE
8668 _wrap_OpalStatusIncomingCall_m_product_set(int argc, VALUE *argv, VALUE self) {
8669 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8670 OpalProductDescription *arg2 = (OpalProductDescription *) 0 ;
8671 void *argp1 = 0 ;
8672 int res1 = 0 ;
8673 void *argp2 = 0 ;
8674 int res2 = 0 ;
8675
8676 if ((argc < 1) || (argc > 1)) {
8677 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8678 }
8679 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8680 if (!SWIG_IsOK(res1)) {
8681 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_product", 1, self ));
8682 }
8683 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8684 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalProductDescription, 0 | 0 );
8685 if (!SWIG_IsOK(res2)) {
8686 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalProductDescription *","m_product", 2, argv[0] ));
8687 }
8688 arg2 = reinterpret_cast< OpalProductDescription * >(argp2);
8689 if (arg1) (arg1)->m_product = *arg2;
8690 return Qnil;
8691 fail:
8692 return Qnil;
8693 }
8694
8695
8696 SWIGINTERN VALUE
8697 _wrap_OpalStatusIncomingCall_m_product_get(int argc, VALUE *argv, VALUE self) {
8698 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 OpalProductDescription *result = 0 ;
8702 VALUE vresult = Qnil;
8703
8704 if ((argc < 0) || (argc > 0)) {
8705 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8706 }
8707 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8708 if (!SWIG_IsOK(res1)) {
8709 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_product", 1, self ));
8710 }
8711 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8712 result = (OpalProductDescription *)& ((arg1)->m_product);
8713 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalProductDescription, 0 | 0 );
8714 return vresult;
8715 fail:
8716 return Qnil;
8717 }
8718
8719
8720
8721 /*
8722 Document-method: Opal::OpalStatusIncomingCall.m_alertingType
8723
8724 call-seq:
8725 m_alertingType -> char
8726
8727 Get value of attribute.
8728
8729 */
8730
8731 /*
8732 Document-method: Opal::OpalStatusIncomingCall.m_alertingType=
8733
8734 call-seq:
8735 m_alertingType=(x) -> char
8736
8737 Set new value for attribute.
8738
8739 */
8740 SWIGINTERN VALUE
8741 _wrap_OpalStatusIncomingCall_m_alertingType_set(int argc, VALUE *argv, VALUE self) {
8742 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8743 char *arg2 = (char *) 0 ;
8744 void *argp1 = 0 ;
8745 int res1 = 0 ;
8746 int res2 ;
8747 char *buf2 = 0 ;
8748 int alloc2 = 0 ;
8749
8750 if ((argc < 1) || (argc > 1)) {
8751 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8752 }
8753 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8754 if (!SWIG_IsOK(res1)) {
8755 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_alertingType", 1, self ));
8756 }
8757 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8758 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
8759 if (!SWIG_IsOK(res2)) {
8760 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_alertingType", 2, argv[0] ));
8761 }
8762 arg2 = reinterpret_cast< char * >(buf2);
8763 if (arg2) {
8764 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
8765 arg1->m_alertingType = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
8766 } else {
8767 arg1->m_alertingType = 0;
8768 }
8769 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8770 return Qnil;
8771 fail:
8772 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8773 return Qnil;
8774 }
8775
8776
8777 SWIGINTERN VALUE
8778 _wrap_OpalStatusIncomingCall_m_alertingType_get(int argc, VALUE *argv, VALUE self) {
8779 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8780 void *argp1 = 0 ;
8781 int res1 = 0 ;
8782 char *result = 0 ;
8783 VALUE vresult = Qnil;
8784
8785 if ((argc < 0) || (argc > 0)) {
8786 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8787 }
8788 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8789 if (!SWIG_IsOK(res1)) {
8790 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_alertingType", 1, self ));
8791 }
8792 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8793 result = (char *) ((arg1)->m_alertingType);
8794 vresult = SWIG_FromCharPtr((const char *)result);
8795 return vresult;
8796 fail:
8797 return Qnil;
8798 }
8799
8800
8801
8802 /*
8803 Document-method: Opal::OpalStatusIncomingCall.m_protocolCallId
8804
8805 call-seq:
8806 m_protocolCallId -> char
8807
8808 Get value of attribute.
8809
8810 */
8811
8812 /*
8813 Document-method: Opal::OpalStatusIncomingCall.m_protocolCallId=
8814
8815 call-seq:
8816 m_protocolCallId=(x) -> char
8817
8818 Set new value for attribute.
8819
8820 */
8821 SWIGINTERN VALUE
8822 _wrap_OpalStatusIncomingCall_m_protocolCallId_set(int argc, VALUE *argv, VALUE self) {
8823 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8824 char *arg2 = (char *) 0 ;
8825 void *argp1 = 0 ;
8826 int res1 = 0 ;
8827 int res2 ;
8828 char *buf2 = 0 ;
8829 int alloc2 = 0 ;
8830
8831 if ((argc < 1) || (argc > 1)) {
8832 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8833 }
8834 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8835 if (!SWIG_IsOK(res1)) {
8836 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_protocolCallId", 1, self ));
8837 }
8838 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8839 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
8840 if (!SWIG_IsOK(res2)) {
8841 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_protocolCallId", 2, argv[0] ));
8842 }
8843 arg2 = reinterpret_cast< char * >(buf2);
8844 if (arg2) {
8845 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
8846 arg1->m_protocolCallId = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
8847 } else {
8848 arg1->m_protocolCallId = 0;
8849 }
8850 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8851 return Qnil;
8852 fail:
8853 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8854 return Qnil;
8855 }
8856
8857
8858 SWIGINTERN VALUE
8859 _wrap_OpalStatusIncomingCall_m_protocolCallId_get(int argc, VALUE *argv, VALUE self) {
8860 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8861 void *argp1 = 0 ;
8862 int res1 = 0 ;
8863 char *result = 0 ;
8864 VALUE vresult = Qnil;
8865
8866 if ((argc < 0) || (argc > 0)) {
8867 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8868 }
8869 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8870 if (!SWIG_IsOK(res1)) {
8871 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_protocolCallId", 1, self ));
8872 }
8873 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8874 result = (char *) ((arg1)->m_protocolCallId);
8875 vresult = SWIG_FromCharPtr((const char *)result);
8876 return vresult;
8877 fail:
8878 return Qnil;
8879 }
8880
8881
8882
8883 /*
8884 Document-method: Opal::OpalStatusIncomingCall.m_referredByAddress
8885
8886 call-seq:
8887 m_referredByAddress -> char
8888
8889 Get value of attribute.
8890
8891 */
8892
8893 /*
8894 Document-method: Opal::OpalStatusIncomingCall.m_referredByAddress=
8895
8896 call-seq:
8897 m_referredByAddress=(x) -> char
8898
8899 Set new value for attribute.
8900
8901 */
8902 SWIGINTERN VALUE
8903 _wrap_OpalStatusIncomingCall_m_referredByAddress_set(int argc, VALUE *argv, VALUE self) {
8904 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8905 char *arg2 = (char *) 0 ;
8906 void *argp1 = 0 ;
8907 int res1 = 0 ;
8908 int res2 ;
8909 char *buf2 = 0 ;
8910 int alloc2 = 0 ;
8911
8912 if ((argc < 1) || (argc > 1)) {
8913 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8914 }
8915 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8916 if (!SWIG_IsOK(res1)) {
8917 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_referredByAddress", 1, self ));
8918 }
8919 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8920 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
8921 if (!SWIG_IsOK(res2)) {
8922 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_referredByAddress", 2, argv[0] ));
8923 }
8924 arg2 = reinterpret_cast< char * >(buf2);
8925 if (arg2) {
8926 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
8927 arg1->m_referredByAddress = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
8928 } else {
8929 arg1->m_referredByAddress = 0;
8930 }
8931 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8932 return Qnil;
8933 fail:
8934 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8935 return Qnil;
8936 }
8937
8938
8939 SWIGINTERN VALUE
8940 _wrap_OpalStatusIncomingCall_m_referredByAddress_get(int argc, VALUE *argv, VALUE self) {
8941 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8942 void *argp1 = 0 ;
8943 int res1 = 0 ;
8944 char *result = 0 ;
8945 VALUE vresult = Qnil;
8946
8947 if ((argc < 0) || (argc > 0)) {
8948 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8949 }
8950 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8951 if (!SWIG_IsOK(res1)) {
8952 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_referredByAddress", 1, self ));
8953 }
8954 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
8955 result = (char *) ((arg1)->m_referredByAddress);
8956 vresult = SWIG_FromCharPtr((const char *)result);
8957 return vresult;
8958 fail:
8959 return Qnil;
8960 }
8961
8962
8963
8964 /*
8965 Document-method: Opal::OpalStatusIncomingCall.m_redirectingNumber
8966
8967 call-seq:
8968 m_redirectingNumber -> char
8969
8970 Get value of attribute.
8971
8972 */
8973
8974 /*
8975 Document-method: Opal::OpalStatusIncomingCall.m_redirectingNumber=
8976
8977 call-seq:
8978 m_redirectingNumber=(x) -> char
8979
8980 Set new value for attribute.
8981
8982 */
8983 SWIGINTERN VALUE
8984 _wrap_OpalStatusIncomingCall_m_redirectingNumber_set(int argc, VALUE *argv, VALUE self) {
8985 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
8986 char *arg2 = (char *) 0 ;
8987 void *argp1 = 0 ;
8988 int res1 = 0 ;
8989 int res2 ;
8990 char *buf2 = 0 ;
8991 int alloc2 = 0 ;
8992
8993 if ((argc < 1) || (argc > 1)) {
8994 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8995 }
8996 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
8997 if (!SWIG_IsOK(res1)) {
8998 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_redirectingNumber", 1, self ));
8999 }
9000 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
9001 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
9002 if (!SWIG_IsOK(res2)) {
9003 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_redirectingNumber", 2, argv[0] ));
9004 }
9005 arg2 = reinterpret_cast< char * >(buf2);
9006 if (arg2) {
9007 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
9008 arg1->m_redirectingNumber = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
9009 } else {
9010 arg1->m_redirectingNumber = 0;
9011 }
9012 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9013 return Qnil;
9014 fail:
9015 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9016 return Qnil;
9017 }
9018
9019
9020 SWIGINTERN VALUE
9021 _wrap_OpalStatusIncomingCall_m_redirectingNumber_get(int argc, VALUE *argv, VALUE self) {
9022 OpalStatusIncomingCall *arg1 = (OpalStatusIncomingCall *) 0 ;
9023 void *argp1 = 0 ;
9024 int res1 = 0 ;
9025 char *result = 0 ;
9026 VALUE vresult = Qnil;
9027
9028 if ((argc < 0) || (argc > 0)) {
9029 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9030 }
9031 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
9032 if (!SWIG_IsOK(res1)) {
9033 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_redirectingNumber", 1, self ));
9034 }
9035 arg1 = reinterpret_cast< OpalStatusIncomingCall * >(argp1);
9036 result = (char *) ((arg1)->m_redirectingNumber);
9037 vresult = SWIG_FromCharPtr((const char *)result);
9038 return vresult;
9039 fail:
9040 return Qnil;
9041 }
9042
9043
9044 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
9045 SWIGINTERN VALUE
9046 _wrap_OpalStatusIncomingCall_allocate(VALUE self) {
9047 #else
9048 SWIGINTERN VALUE
9049 _wrap_OpalStatusIncomingCall_allocate(int argc, VALUE *argv, VALUE self) {
9050 #endif
9051
9052
9053 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalStatusIncomingCall);
9054 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
9055 rb_obj_call_init(vresult, argc, argv);
9056 #endif
9057 return vresult;
9058 }
9059
9060
9061
9062 /*
9063 Document-method: Opal::OpalStatusIncomingCall.new
9064
9065 call-seq:
9066 OpalStatusIncomingCall.new
9067
9068 Class constructor.
9069
9070 */
9071 SWIGINTERN VALUE
9072 _wrap_new_OpalStatusIncomingCall(int argc, VALUE *argv, VALUE self) {
9073 OpalStatusIncomingCall *result = 0 ;
9074
9075 if ((argc < 0) || (argc > 0)) {
9076 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9077 }
9078 result = (OpalStatusIncomingCall *)new OpalStatusIncomingCall();
9079 DATA_PTR(self) = result;
9080 return self;
9081 fail:
9082 return Qnil;
9083 }
9084
9085
9086 SWIGINTERN void
9087 free_OpalStatusIncomingCall(OpalStatusIncomingCall *arg1) {
9088 delete arg1;
9089 }
9090
9091
9092 /*
9093 Document-class: Opal::OpalParamAnswerCall
9094
9095 Proxy of C++ Opal::OpalParamAnswerCall class
9096
9097
9098 */
9099 swig_class SwigClassOpalParamAnswerCall;
9100
9101
9102 /*
9103 Document-method: Opal::OpalParamAnswerCall.m_callToken
9104
9105 call-seq:
9106 m_callToken -> char
9107
9108 Get value of attribute.
9109
9110 */
9111
9112 /*
9113 Document-method: Opal::OpalParamAnswerCall.m_callToken=
9114
9115 call-seq:
9116 m_callToken=(x) -> char
9117
9118 Set new value for attribute.
9119
9120 */
9121 SWIGINTERN VALUE
9122 _wrap_OpalParamAnswerCall_m_callToken_set(int argc, VALUE *argv, VALUE self) {
9123 OpalParamAnswerCall *arg1 = (OpalParamAnswerCall *) 0 ;
9124 char *arg2 = (char *) 0 ;
9125 void *argp1 = 0 ;
9126 int res1 = 0 ;
9127 int res2 ;
9128 char *buf2 = 0 ;
9129 int alloc2 = 0 ;
9130
9131 if ((argc < 1) || (argc > 1)) {
9132 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9133 }
9134 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamAnswerCall, 0 | 0 );
9135 if (!SWIG_IsOK(res1)) {
9136 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamAnswerCall *","m_callToken", 1, self ));
9137 }
9138 arg1 = reinterpret_cast< OpalParamAnswerCall * >(argp1);
9139 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
9140 if (!SWIG_IsOK(res2)) {
9141 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
9142 }
9143 arg2 = reinterpret_cast< char * >(buf2);
9144 if (arg2) {
9145 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
9146 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
9147 } else {
9148 arg1->m_callToken = 0;
9149 }
9150 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9151 return Qnil;
9152 fail:
9153 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9154 return Qnil;
9155 }
9156
9157
9158 SWIGINTERN VALUE
9159 _wrap_OpalParamAnswerCall_m_callToken_get(int argc, VALUE *argv, VALUE self) {
9160 OpalParamAnswerCall *arg1 = (OpalParamAnswerCall *) 0 ;
9161 void *argp1 = 0 ;
9162 int res1 = 0 ;
9163 char *result = 0 ;
9164 VALUE vresult = Qnil;
9165
9166 if ((argc < 0) || (argc > 0)) {
9167 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9168 }
9169 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamAnswerCall, 0 | 0 );
9170 if (!SWIG_IsOK(res1)) {
9171 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamAnswerCall *","m_callToken", 1, self ));
9172 }
9173 arg1 = reinterpret_cast< OpalParamAnswerCall * >(argp1);
9174 result = (char *) ((arg1)->m_callToken);
9175 vresult = SWIG_FromCharPtr((const char *)result);
9176 return vresult;
9177 fail:
9178 return Qnil;
9179 }
9180
9181
9182
9183 /*
9184 Document-method: Opal::OpalParamAnswerCall.m_overrides
9185
9186 call-seq:
9187 m_overrides -> OpalParamProtocol
9188
9189 Get value of attribute.
9190
9191 */
9192
9193 /*
9194 Document-method: Opal::OpalParamAnswerCall.m_overrides=
9195
9196 call-seq:
9197 m_overrides=(x) -> OpalParamProtocol
9198
9199 Set new value for attribute.
9200
9201 */
9202 SWIGINTERN VALUE
9203 _wrap_OpalParamAnswerCall_m_overrides_set(int argc, VALUE *argv, VALUE self) {
9204 OpalParamAnswerCall *arg1 = (OpalParamAnswerCall *) 0 ;
9205 OpalParamProtocol *arg2 = (OpalParamProtocol *) 0 ;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 void *argp2 = 0 ;
9209 int res2 = 0 ;
9210
9211 if ((argc < 1) || (argc > 1)) {
9212 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9213 }
9214 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamAnswerCall, 0 | 0 );
9215 if (!SWIG_IsOK(res1)) {
9216 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamAnswerCall *","m_overrides", 1, self ));
9217 }
9218 arg1 = reinterpret_cast< OpalParamAnswerCall * >(argp1);
9219 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
9220 if (!SWIG_IsOK(res2)) {
9221 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_overrides", 2, argv[0] ));
9222 }
9223 arg2 = reinterpret_cast< OpalParamProtocol * >(argp2);
9224 if (arg1) (arg1)->m_overrides = *arg2;
9225 return Qnil;
9226 fail:
9227 return Qnil;
9228 }
9229
9230
9231 SWIGINTERN VALUE
9232 _wrap_OpalParamAnswerCall_m_overrides_get(int argc, VALUE *argv, VALUE self) {
9233 OpalParamAnswerCall *arg1 = (OpalParamAnswerCall *) 0 ;
9234 void *argp1 = 0 ;
9235 int res1 = 0 ;
9236 OpalParamProtocol *result = 0 ;
9237 VALUE vresult = Qnil;
9238
9239 if ((argc < 0) || (argc > 0)) {
9240 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9241 }
9242 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamAnswerCall, 0 | 0 );
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamAnswerCall *","m_overrides", 1, self ));
9245 }
9246 arg1 = reinterpret_cast< OpalParamAnswerCall * >(argp1);
9247 result = (OpalParamProtocol *)& ((arg1)->m_overrides);
9248 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
9249 return vresult;
9250 fail:
9251 return Qnil;
9252 }
9253
9254
9255 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
9256 SWIGINTERN VALUE
9257 _wrap_OpalParamAnswerCall_allocate(VALUE self) {
9258 #else
9259 SWIGINTERN VALUE
9260 _wrap_OpalParamAnswerCall_allocate(int argc, VALUE *argv, VALUE self) {
9261 #endif
9262
9263
9264 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalParamAnswerCall);
9265 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
9266 rb_obj_call_init(vresult, argc, argv);
9267 #endif
9268 return vresult;
9269 }
9270
9271
9272
9273 /*
9274 Document-method: Opal::OpalParamAnswerCall.new
9275
9276 call-seq:
9277 OpalParamAnswerCall.new
9278
9279 Class constructor.
9280
9281 */
9282 SWIGINTERN VALUE
9283 _wrap_new_OpalParamAnswerCall(int argc, VALUE *argv, VALUE self) {
9284 OpalParamAnswerCall *result = 0 ;
9285
9286 if ((argc < 0) || (argc > 0)) {
9287 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9288 }
9289 result = (OpalParamAnswerCall *)new OpalParamAnswerCall();
9290 DATA_PTR(self) = result;
9291 return self;
9292 fail:
9293 return Qnil;
9294 }
9295
9296
9297 SWIGINTERN void
9298 free_OpalParamAnswerCall(OpalParamAnswerCall *arg1) {
9299 delete arg1;
9300 }
9301
9302
9303 /*
9304 Document-class: Opal::OpalStatusMediaStream
9305
9306 Proxy of C++ Opal::OpalStatusMediaStream class
9307
9308
9309 */
9310 swig_class SwigClassOpalStatusMediaStream;
9311
9312
9313 /*
9314 Document-method: Opal::OpalStatusMediaStream.m_callToken
9315
9316 call-seq:
9317 m_callToken -> char
9318
9319 Get value of attribute.
9320
9321 */
9322
9323 /*
9324 Document-method: Opal::OpalStatusMediaStream.m_callToken=
9325
9326 call-seq:
9327 m_callToken=(x) -> char
9328
9329 Set new value for attribute.
9330
9331 */
9332 SWIGINTERN VALUE
9333 _wrap_OpalStatusMediaStream_m_callToken_set(int argc, VALUE *argv, VALUE self) {
9334 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9335 char *arg2 = (char *) 0 ;
9336 void *argp1 = 0 ;
9337 int res1 = 0 ;
9338 int res2 ;
9339 char *buf2 = 0 ;
9340 int alloc2 = 0 ;
9341
9342 if ((argc < 1) || (argc > 1)) {
9343 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9344 }
9345 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9346 if (!SWIG_IsOK(res1)) {
9347 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_callToken", 1, self ));
9348 }
9349 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9350 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
9351 if (!SWIG_IsOK(res2)) {
9352 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
9353 }
9354 arg2 = reinterpret_cast< char * >(buf2);
9355 if (arg2) {
9356 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
9357 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
9358 } else {
9359 arg1->m_callToken = 0;
9360 }
9361 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9362 return Qnil;
9363 fail:
9364 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9365 return Qnil;
9366 }
9367
9368
9369 SWIGINTERN VALUE
9370 _wrap_OpalStatusMediaStream_m_callToken_get(int argc, VALUE *argv, VALUE self) {
9371 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9372 void *argp1 = 0 ;
9373 int res1 = 0 ;
9374 char *result = 0 ;
9375 VALUE vresult = Qnil;
9376
9377 if ((argc < 0) || (argc > 0)) {
9378 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9379 }
9380 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9381 if (!SWIG_IsOK(res1)) {
9382 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_callToken", 1, self ));
9383 }
9384 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9385 result = (char *) ((arg1)->m_callToken);
9386 vresult = SWIG_FromCharPtr((const char *)result);
9387 return vresult;
9388 fail:
9389 return Qnil;
9390 }
9391
9392
9393
9394 /*
9395 Document-method: Opal::OpalStatusMediaStream.m_identifier
9396
9397 call-seq:
9398 m_identifier -> char
9399
9400 Get value of attribute.
9401
9402 */
9403
9404 /*
9405 Document-method: Opal::OpalStatusMediaStream.m_identifier=
9406
9407 call-seq:
9408 m_identifier=(x) -> char
9409
9410 Set new value for attribute.
9411
9412 */
9413 SWIGINTERN VALUE
9414 _wrap_OpalStatusMediaStream_m_identifier_set(int argc, VALUE *argv, VALUE self) {
9415 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9416 char *arg2 = (char *) 0 ;
9417 void *argp1 = 0 ;
9418 int res1 = 0 ;
9419 int res2 ;
9420 char *buf2 = 0 ;
9421 int alloc2 = 0 ;
9422
9423 if ((argc < 1) || (argc > 1)) {
9424 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9425 }
9426 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9427 if (!SWIG_IsOK(res1)) {
9428 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_identifier", 1, self ));
9429 }
9430 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9431 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
9432 if (!SWIG_IsOK(res2)) {
9433 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_identifier", 2, argv[0] ));
9434 }
9435 arg2 = reinterpret_cast< char * >(buf2);
9436 if (arg2) {
9437 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
9438 arg1->m_identifier = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
9439 } else {
9440 arg1->m_identifier = 0;
9441 }
9442 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9443 return Qnil;
9444 fail:
9445 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9446 return Qnil;
9447 }
9448
9449
9450 SWIGINTERN VALUE
9451 _wrap_OpalStatusMediaStream_m_identifier_get(int argc, VALUE *argv, VALUE self) {
9452 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9453 void *argp1 = 0 ;
9454 int res1 = 0 ;
9455 char *result = 0 ;
9456 VALUE vresult = Qnil;
9457
9458 if ((argc < 0) || (argc > 0)) {
9459 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9460 }
9461 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_identifier", 1, self ));
9464 }
9465 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9466 result = (char *) ((arg1)->m_identifier);
9467 vresult = SWIG_FromCharPtr((const char *)result);
9468 return vresult;
9469 fail:
9470 return Qnil;
9471 }
9472
9473
9474
9475 /*
9476 Document-method: Opal::OpalStatusMediaStream.m_type
9477
9478 call-seq:
9479 m_type -> char
9480
9481 Get value of attribute.
9482
9483 */
9484
9485 /*
9486 Document-method: Opal::OpalStatusMediaStream.m_type=
9487
9488 call-seq:
9489 m_type=(x) -> char
9490
9491 Set new value for attribute.
9492
9493 */
9494 SWIGINTERN VALUE
9495 _wrap_OpalStatusMediaStream_m_type_set(int argc, VALUE *argv, VALUE self) {
9496 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9497 char *arg2 = (char *) 0 ;
9498 void *argp1 = 0 ;
9499 int res1 = 0 ;
9500 int res2 ;
9501 char *buf2 = 0 ;
9502 int alloc2 = 0 ;
9503
9504 if ((argc < 1) || (argc > 1)) {
9505 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9506 }
9507 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9508 if (!SWIG_IsOK(res1)) {
9509 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_type", 1, self ));
9510 }
9511 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9512 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
9513 if (!SWIG_IsOK(res2)) {
9514 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_type", 2, argv[0] ));
9515 }
9516 arg2 = reinterpret_cast< char * >(buf2);
9517 if (arg2) {
9518 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
9519 arg1->m_type = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
9520 } else {
9521 arg1->m_type = 0;
9522 }
9523 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9524 return Qnil;
9525 fail:
9526 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9527 return Qnil;
9528 }
9529
9530
9531 SWIGINTERN VALUE
9532 _wrap_OpalStatusMediaStream_m_type_get(int argc, VALUE *argv, VALUE self) {
9533 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9534 void *argp1 = 0 ;
9535 int res1 = 0 ;
9536 char *result = 0 ;
9537 VALUE vresult = Qnil;
9538
9539 if ((argc < 0) || (argc > 0)) {
9540 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9541 }
9542 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9543 if (!SWIG_IsOK(res1)) {
9544 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_type", 1, self ));
9545 }
9546 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9547 result = (char *) ((arg1)->m_type);
9548 vresult = SWIG_FromCharPtr((const char *)result);
9549 return vresult;
9550 fail:
9551 return Qnil;
9552 }
9553
9554
9555
9556 /*
9557 Document-method: Opal::OpalStatusMediaStream.m_format
9558
9559 call-seq:
9560 m_format -> char
9561
9562 Get value of attribute.
9563
9564 */
9565
9566 /*
9567 Document-method: Opal::OpalStatusMediaStream.m_format=
9568
9569 call-seq:
9570 m_format=(x) -> char
9571
9572 Set new value for attribute.
9573
9574 */
9575 SWIGINTERN VALUE
9576 _wrap_OpalStatusMediaStream_m_format_set(int argc, VALUE *argv, VALUE self) {
9577 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9578 char *arg2 = (char *) 0 ;
9579 void *argp1 = 0 ;
9580 int res1 = 0 ;
9581 int res2 ;
9582 char *buf2 = 0 ;
9583 int alloc2 = 0 ;
9584
9585 if ((argc < 1) || (argc > 1)) {
9586 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9587 }
9588 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9589 if (!SWIG_IsOK(res1)) {
9590 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_format", 1, self ));
9591 }
9592 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9593 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
9594 if (!SWIG_IsOK(res2)) {
9595 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_format", 2, argv[0] ));
9596 }
9597 arg2 = reinterpret_cast< char * >(buf2);
9598 if (arg2) {
9599 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
9600 arg1->m_format = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
9601 } else {
9602 arg1->m_format = 0;
9603 }
9604 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9605 return Qnil;
9606 fail:
9607 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9608 return Qnil;
9609 }
9610
9611
9612 SWIGINTERN VALUE
9613 _wrap_OpalStatusMediaStream_m_format_get(int argc, VALUE *argv, VALUE self) {
9614 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9615 void *argp1 = 0 ;
9616 int res1 = 0 ;
9617 char *result = 0 ;
9618 VALUE vresult = Qnil;
9619
9620 if ((argc < 0) || (argc > 0)) {
9621 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9622 }
9623 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9624 if (!SWIG_IsOK(res1)) {
9625 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_format", 1, self ));
9626 }
9627 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9628 result = (char *) ((arg1)->m_format);
9629 vresult = SWIG_FromCharPtr((const char *)result);
9630 return vresult;
9631 fail:
9632 return Qnil;
9633 }
9634
9635
9636
9637 /*
9638 Document-method: Opal::OpalStatusMediaStream.m_state
9639
9640 call-seq:
9641 m_state -> int
9642
9643 Get value of attribute.
9644
9645 */
9646
9647 /*
9648 Document-method: Opal::OpalStatusMediaStream.m_state=
9649
9650 call-seq:
9651 m_state=(x) -> int
9652
9653 Set new value for attribute.
9654
9655 */
9656 SWIGINTERN VALUE
9657 _wrap_OpalStatusMediaStream_m_state_set(int argc, VALUE *argv, VALUE self) {
9658 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9659 OpalMediaStates arg2 ;
9660 void *argp1 = 0 ;
9661 int res1 = 0 ;
9662 int val2 ;
9663 int ecode2 = 0 ;
9664
9665 if ((argc < 1) || (argc > 1)) {
9666 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9667 }
9668 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9669 if (!SWIG_IsOK(res1)) {
9670 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_state", 1, self ));
9671 }
9672 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9673 ecode2 = SWIG_AsVal_int(argv[0], &val2);
9674 if (!SWIG_IsOK(ecode2)) {
9675 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalMediaStates","m_state", 2, argv[0] ));
9676 }
9677 arg2 = static_cast< OpalMediaStates >(val2);
9678 if (arg1) (arg1)->m_state = arg2;
9679 return Qnil;
9680 fail:
9681 return Qnil;
9682 }
9683
9684
9685 SWIGINTERN VALUE
9686 _wrap_OpalStatusMediaStream_m_state_get(int argc, VALUE *argv, VALUE self) {
9687 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9688 void *argp1 = 0 ;
9689 int res1 = 0 ;
9690 OpalMediaStates result;
9691 VALUE vresult = Qnil;
9692
9693 if ((argc < 0) || (argc > 0)) {
9694 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9695 }
9696 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9697 if (!SWIG_IsOK(res1)) {
9698 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_state", 1, self ));
9699 }
9700 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9701 result = (OpalMediaStates) ((arg1)->m_state);
9702 vresult = SWIG_From_int(static_cast< int >(result));
9703 return vresult;
9704 fail:
9705 return Qnil;
9706 }
9707
9708
9709
9710 /*
9711 Document-method: Opal::OpalStatusMediaStream.m_volume
9712
9713 call-seq:
9714 m_volume -> int
9715
9716 Get value of attribute.
9717
9718 */
9719
9720 /*
9721 Document-method: Opal::OpalStatusMediaStream.m_volume=
9722
9723 call-seq:
9724 m_volume=(x) -> int
9725
9726 Set new value for attribute.
9727
9728 */
9729 SWIGINTERN VALUE
9730 _wrap_OpalStatusMediaStream_m_volume_set(int argc, VALUE *argv, VALUE self) {
9731 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9732 int arg2 ;
9733 void *argp1 = 0 ;
9734 int res1 = 0 ;
9735 int val2 ;
9736 int ecode2 = 0 ;
9737
9738 if ((argc < 1) || (argc > 1)) {
9739 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9740 }
9741 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9742 if (!SWIG_IsOK(res1)) {
9743 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_volume", 1, self ));
9744 }
9745 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9746 ecode2 = SWIG_AsVal_int(argv[0], &val2);
9747 if (!SWIG_IsOK(ecode2)) {
9748 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","m_volume", 2, argv[0] ));
9749 }
9750 arg2 = static_cast< int >(val2);
9751 if (arg1) (arg1)->m_volume = arg2;
9752 return Qnil;
9753 fail:
9754 return Qnil;
9755 }
9756
9757
9758 SWIGINTERN VALUE
9759 _wrap_OpalStatusMediaStream_m_volume_get(int argc, VALUE *argv, VALUE self) {
9760 OpalStatusMediaStream *arg1 = (OpalStatusMediaStream *) 0 ;
9761 void *argp1 = 0 ;
9762 int res1 = 0 ;
9763 int result;
9764 VALUE vresult = Qnil;
9765
9766 if ((argc < 0) || (argc > 0)) {
9767 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9768 }
9769 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
9770 if (!SWIG_IsOK(res1)) {
9771 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_volume", 1, self ));
9772 }
9773 arg1 = reinterpret_cast< OpalStatusMediaStream * >(argp1);
9774 result = (int) ((arg1)->m_volume);
9775 vresult = SWIG_From_int(static_cast< int >(result));
9776 return vresult;
9777 fail:
9778 return Qnil;
9779 }
9780
9781
9782 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
9783 SWIGINTERN VALUE
9784 _wrap_OpalStatusMediaStream_allocate(VALUE self) {
9785 #else
9786 SWIGINTERN VALUE
9787 _wrap_OpalStatusMediaStream_allocate(int argc, VALUE *argv, VALUE self) {
9788 #endif
9789
9790
9791 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalStatusMediaStream);
9792 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
9793 rb_obj_call_init(vresult, argc, argv);
9794 #endif
9795 return vresult;
9796 }
9797
9798
9799
9800 /*
9801 Document-method: Opal::OpalStatusMediaStream.new
9802
9803 call-seq:
9804 OpalStatusMediaStream.new
9805
9806 Class constructor.
9807
9808 */
9809 SWIGINTERN VALUE
9810 _wrap_new_OpalStatusMediaStream(int argc, VALUE *argv, VALUE self) {
9811 OpalStatusMediaStream *result = 0 ;
9812
9813 if ((argc < 0) || (argc > 0)) {
9814 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9815 }
9816 result = (OpalStatusMediaStream *)new OpalStatusMediaStream();
9817 DATA_PTR(self) = result;
9818 return self;
9819 fail:
9820 return Qnil;
9821 }
9822
9823
9824 SWIGINTERN void
9825 free_OpalStatusMediaStream(OpalStatusMediaStream *arg1) {
9826 delete arg1;
9827 }
9828
9829
9830 /*
9831 Document-class: Opal::OpalParamSetUserData
9832
9833 Proxy of C++ Opal::OpalParamSetUserData class
9834
9835
9836 */
9837 swig_class SwigClassOpalParamSetUserData;
9838
9839
9840 /*
9841 Document-method: Opal::OpalParamSetUserData.m_callToken
9842
9843 call-seq:
9844 m_callToken -> char
9845
9846 Get value of attribute.
9847
9848 */
9849
9850 /*
9851 Document-method: Opal::OpalParamSetUserData.m_callToken=
9852
9853 call-seq:
9854 m_callToken=(x) -> char
9855
9856 Set new value for attribute.
9857
9858 */
9859 SWIGINTERN VALUE
9860 _wrap_OpalParamSetUserData_m_callToken_set(int argc, VALUE *argv, VALUE self) {
9861 OpalParamSetUserData *arg1 = (OpalParamSetUserData *) 0 ;
9862 char *arg2 = (char *) 0 ;
9863 void *argp1 = 0 ;
9864 int res1 = 0 ;
9865 int res2 ;
9866 char *buf2 = 0 ;
9867 int alloc2 = 0 ;
9868
9869 if ((argc < 1) || (argc > 1)) {
9870 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9871 }
9872 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUserData, 0 | 0 );
9873 if (!SWIG_IsOK(res1)) {
9874 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUserData *","m_callToken", 1, self ));
9875 }
9876 arg1 = reinterpret_cast< OpalParamSetUserData * >(argp1);
9877 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
9878 if (!SWIG_IsOK(res2)) {
9879 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
9880 }
9881 arg2 = reinterpret_cast< char * >(buf2);
9882 if (arg2) {
9883 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
9884 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
9885 } else {
9886 arg1->m_callToken = 0;
9887 }
9888 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9889 return Qnil;
9890 fail:
9891 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
9892 return Qnil;
9893 }
9894
9895
9896 SWIGINTERN VALUE
9897 _wrap_OpalParamSetUserData_m_callToken_get(int argc, VALUE *argv, VALUE self) {
9898 OpalParamSetUserData *arg1 = (OpalParamSetUserData *) 0 ;
9899 void *argp1 = 0 ;
9900 int res1 = 0 ;
9901 char *result = 0 ;
9902 VALUE vresult = Qnil;
9903
9904 if ((argc < 0) || (argc > 0)) {
9905 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9906 }
9907 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUserData, 0 | 0 );
9908 if (!SWIG_IsOK(res1)) {
9909 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUserData *","m_callToken", 1, self ));
9910 }
9911 arg1 = reinterpret_cast< OpalParamSetUserData * >(argp1);
9912 result = (char *) ((arg1)->m_callToken);
9913 vresult = SWIG_FromCharPtr((const char *)result);
9914 return vresult;
9915 fail:
9916 return Qnil;
9917 }
9918
9919
9920
9921 /*
9922 Document-method: Opal::OpalParamSetUserData.m_userData
9923
9924 call-seq:
9925 m_userData -> void
9926
9927 Get value of attribute.
9928
9929 */
9930
9931 /*
9932 Document-method: Opal::OpalParamSetUserData.m_userData=
9933
9934 call-seq:
9935 m_userData=(x) -> void
9936
9937 Set new value for attribute.
9938
9939 */
9940 SWIGINTERN VALUE
9941 _wrap_OpalParamSetUserData_m_userData_set(int argc, VALUE *argv, VALUE self) {
9942 OpalParamSetUserData *arg1 = (OpalParamSetUserData *) 0 ;
9943 void *arg2 = (void *) 0 ;
9944 void *argp1 = 0 ;
9945 int res1 = 0 ;
9946 int res2 ;
9947
9948 if ((argc < 1) || (argc > 1)) {
9949 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9950 }
9951 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUserData, 0 | 0 );
9952 if (!SWIG_IsOK(res1)) {
9953 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUserData *","m_userData", 1, self ));
9954 }
9955 arg1 = reinterpret_cast< OpalParamSetUserData * >(argp1);
9956 res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
9957 if (!SWIG_IsOK(res2)) {
9958 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","m_userData", 2, argv[0] ));
9959 }
9960 if (arg1) (arg1)->m_userData = arg2;
9961 return Qnil;
9962 fail:
9963 return Qnil;
9964 }
9965
9966
9967 SWIGINTERN VALUE
9968 _wrap_OpalParamSetUserData_m_userData_get(int argc, VALUE *argv, VALUE self) {
9969 OpalParamSetUserData *arg1 = (OpalParamSetUserData *) 0 ;
9970 void *argp1 = 0 ;
9971 int res1 = 0 ;
9972 void *result = 0 ;
9973 VALUE vresult = Qnil;
9974
9975 if ((argc < 0) || (argc > 0)) {
9976 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9977 }
9978 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamSetUserData, 0 | 0 );
9979 if (!SWIG_IsOK(res1)) {
9980 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamSetUserData *","m_userData", 1, self ));
9981 }
9982 arg1 = reinterpret_cast< OpalParamSetUserData * >(argp1);
9983 result = (void *) ((arg1)->m_userData);
9984 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
9985 return vresult;
9986 fail:
9987 return Qnil;
9988 }
9989
9990
9991 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
9992 SWIGINTERN VALUE
9993 _wrap_OpalParamSetUserData_allocate(VALUE self) {
9994 #else
9995 SWIGINTERN VALUE
9996 _wrap_OpalParamSetUserData_allocate(int argc, VALUE *argv, VALUE self) {
9997 #endif
9998
9999
10000 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalParamSetUserData);
10001 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
10002 rb_obj_call_init(vresult, argc, argv);
10003 #endif
10004 return vresult;
10005 }
10006
10007
10008
10009 /*
10010 Document-method: Opal::OpalParamSetUserData.new
10011
10012 call-seq:
10013 OpalParamSetUserData.new
10014
10015 Class constructor.
10016
10017 */
10018 SWIGINTERN VALUE
10019 _wrap_new_OpalParamSetUserData(int argc, VALUE *argv, VALUE self) {
10020 OpalParamSetUserData *result = 0 ;
10021
10022 if ((argc < 0) || (argc > 0)) {
10023 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10024 }
10025 result = (OpalParamSetUserData *)new OpalParamSetUserData();
10026 DATA_PTR(self) = result;
10027 return self;
10028 fail:
10029 return Qnil;
10030 }
10031
10032
10033 SWIGINTERN void
10034 free_OpalParamSetUserData(OpalParamSetUserData *arg1) {
10035 delete arg1;
10036 }
10037
10038
10039 /*
10040 Document-class: Opal::OpalStatusUserInput
10041
10042 Proxy of C++ Opal::OpalStatusUserInput class
10043
10044
10045 */
10046 swig_class SwigClassOpalStatusUserInput;
10047
10048
10049 /*
10050 Document-method: Opal::OpalStatusUserInput.m_callToken
10051
10052 call-seq:
10053 m_callToken -> char
10054
10055 Get value of attribute.
10056
10057 */
10058
10059 /*
10060 Document-method: Opal::OpalStatusUserInput.m_callToken=
10061
10062 call-seq:
10063 m_callToken=(x) -> char
10064
10065 Set new value for attribute.
10066
10067 */
10068 SWIGINTERN VALUE
10069 _wrap_OpalStatusUserInput_m_callToken_set(int argc, VALUE *argv, VALUE self) {
10070 OpalStatusUserInput *arg1 = (OpalStatusUserInput *) 0 ;
10071 char *arg2 = (char *) 0 ;
10072 void *argp1 = 0 ;
10073 int res1 = 0 ;
10074 int res2 ;
10075 char *buf2 = 0 ;
10076 int alloc2 = 0 ;
10077
10078 if ((argc < 1) || (argc > 1)) {
10079 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10080 }
10081 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusUserInput, 0 | 0 );
10082 if (!SWIG_IsOK(res1)) {
10083 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusUserInput *","m_callToken", 1, self ));
10084 }
10085 arg1 = reinterpret_cast< OpalStatusUserInput * >(argp1);
10086 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
10087 if (!SWIG_IsOK(res2)) {
10088 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
10089 }
10090 arg2 = reinterpret_cast< char * >(buf2);
10091 if (arg2) {
10092 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
10093 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
10094 } else {
10095 arg1->m_callToken = 0;
10096 }
10097 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10098 return Qnil;
10099 fail:
10100 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10101 return Qnil;
10102 }
10103
10104
10105 SWIGINTERN VALUE
10106 _wrap_OpalStatusUserInput_m_callToken_get(int argc, VALUE *argv, VALUE self) {
10107 OpalStatusUserInput *arg1 = (OpalStatusUserInput *) 0 ;
10108 void *argp1 = 0 ;
10109 int res1 = 0 ;
10110 char *result = 0 ;
10111 VALUE vresult = Qnil;
10112
10113 if ((argc < 0) || (argc > 0)) {
10114 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10115 }
10116 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusUserInput, 0 | 0 );
10117 if (!SWIG_IsOK(res1)) {
10118 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusUserInput *","m_callToken", 1, self ));
10119 }
10120 arg1 = reinterpret_cast< OpalStatusUserInput * >(argp1);
10121 result = (char *) ((arg1)->m_callToken);
10122 vresult = SWIG_FromCharPtr((const char *)result);
10123 return vresult;
10124 fail:
10125 return Qnil;
10126 }
10127
10128
10129
10130 /*
10131 Document-method: Opal::OpalStatusUserInput.m_userInput
10132
10133 call-seq:
10134 m_userInput -> char
10135
10136 Get value of attribute.
10137
10138 */
10139
10140 /*
10141 Document-method: Opal::OpalStatusUserInput.m_userInput=
10142
10143 call-seq:
10144 m_userInput=(x) -> char
10145
10146 Set new value for attribute.
10147
10148 */
10149 SWIGINTERN VALUE
10150 _wrap_OpalStatusUserInput_m_userInput_set(int argc, VALUE *argv, VALUE self) {
10151 OpalStatusUserInput *arg1 = (OpalStatusUserInput *) 0 ;
10152 char *arg2 = (char *) 0 ;
10153 void *argp1 = 0 ;
10154 int res1 = 0 ;
10155 int res2 ;
10156 char *buf2 = 0 ;
10157 int alloc2 = 0 ;
10158
10159 if ((argc < 1) || (argc > 1)) {
10160 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10161 }
10162 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusUserInput, 0 | 0 );
10163 if (!SWIG_IsOK(res1)) {
10164 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusUserInput *","m_userInput", 1, self ));
10165 }
10166 arg1 = reinterpret_cast< OpalStatusUserInput * >(argp1);
10167 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
10168 if (!SWIG_IsOK(res2)) {
10169 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_userInput", 2, argv[0] ));
10170 }
10171 arg2 = reinterpret_cast< char * >(buf2);
10172 if (arg2) {
10173 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
10174 arg1->m_userInput = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
10175 } else {
10176 arg1->m_userInput = 0;
10177 }
10178 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10179 return Qnil;
10180 fail:
10181 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10182 return Qnil;
10183 }
10184
10185
10186 SWIGINTERN VALUE
10187 _wrap_OpalStatusUserInput_m_userInput_get(int argc, VALUE *argv, VALUE self) {
10188 OpalStatusUserInput *arg1 = (OpalStatusUserInput *) 0 ;
10189 void *argp1 = 0 ;
10190 int res1 = 0 ;
10191 char *result = 0 ;
10192 VALUE vresult = Qnil;
10193
10194 if ((argc < 0) || (argc > 0)) {
10195 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10196 }
10197 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusUserInput, 0 | 0 );
10198 if (!SWIG_IsOK(res1)) {
10199 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusUserInput *","m_userInput", 1, self ));
10200 }
10201 arg1 = reinterpret_cast< OpalStatusUserInput * >(argp1);
10202 result = (char *) ((arg1)->m_userInput);
10203 vresult = SWIG_FromCharPtr((const char *)result);
10204 return vresult;
10205 fail:
10206 return Qnil;
10207 }
10208
10209
10210
10211 /*
10212 Document-method: Opal::OpalStatusUserInput.m_duration
10213
10214 call-seq:
10215 m_duration -> unsigned int
10216
10217 Get value of attribute.
10218
10219 */
10220
10221 /*
10222 Document-method: Opal::OpalStatusUserInput.m_duration=
10223
10224 call-seq:
10225 m_duration=(x) -> unsigned int
10226
10227 Set new value for attribute.
10228
10229 */
10230 SWIGINTERN VALUE
10231 _wrap_OpalStatusUserInput_m_duration_set(int argc, VALUE *argv, VALUE self) {
10232 OpalStatusUserInput *arg1 = (OpalStatusUserInput *) 0 ;
10233 unsigned int arg2 ;
10234 void *argp1 = 0 ;
10235 int res1 = 0 ;
10236 unsigned int val2 ;
10237 int ecode2 = 0 ;
10238
10239 if ((argc < 1) || (argc > 1)) {
10240 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10241 }
10242 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusUserInput, 0 | 0 );
10243 if (!SWIG_IsOK(res1)) {
10244 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusUserInput *","m_duration", 1, self ));
10245 }
10246 arg1 = reinterpret_cast< OpalStatusUserInput * >(argp1);
10247 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
10248 if (!SWIG_IsOK(ecode2)) {
10249 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_duration", 2, argv[0] ));
10250 }
10251 arg2 = static_cast< unsigned int >(val2);
10252 if (arg1) (arg1)->m_duration = arg2;
10253 return Qnil;
10254 fail:
10255 return Qnil;
10256 }
10257
10258
10259 SWIGINTERN VALUE
10260 _wrap_OpalStatusUserInput_m_duration_get(int argc, VALUE *argv, VALUE self) {
10261 OpalStatusUserInput *arg1 = (OpalStatusUserInput *) 0 ;
10262 void *argp1 = 0 ;
10263 int res1 = 0 ;
10264 unsigned int result;
10265 VALUE vresult = Qnil;
10266
10267 if ((argc < 0) || (argc > 0)) {
10268 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10269 }
10270 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusUserInput, 0 | 0 );
10271 if (!SWIG_IsOK(res1)) {
10272 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusUserInput *","m_duration", 1, self ));
10273 }
10274 arg1 = reinterpret_cast< OpalStatusUserInput * >(argp1);
10275 result = (unsigned int) ((arg1)->m_duration);
10276 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
10277 return vresult;
10278 fail:
10279 return Qnil;
10280 }
10281
10282
10283 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
10284 SWIGINTERN VALUE
10285 _wrap_OpalStatusUserInput_allocate(VALUE self) {
10286 #else
10287 SWIGINTERN VALUE
10288 _wrap_OpalStatusUserInput_allocate(int argc, VALUE *argv, VALUE self) {
10289 #endif
10290
10291
10292 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalStatusUserInput);
10293 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
10294 rb_obj_call_init(vresult, argc, argv);
10295 #endif
10296 return vresult;
10297 }
10298
10299
10300
10301 /*
10302 Document-method: Opal::OpalStatusUserInput.new
10303
10304 call-seq:
10305 OpalStatusUserInput.new
10306
10307 Class constructor.
10308
10309 */
10310 SWIGINTERN VALUE
10311 _wrap_new_OpalStatusUserInput(int argc, VALUE *argv, VALUE self) {
10312 OpalStatusUserInput *result = 0 ;
10313
10314 if ((argc < 0) || (argc > 0)) {
10315 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10316 }
10317 result = (OpalStatusUserInput *)new OpalStatusUserInput();
10318 DATA_PTR(self) = result;
10319 return self;
10320 fail:
10321 return Qnil;
10322 }
10323
10324
10325 SWIGINTERN void
10326 free_OpalStatusUserInput(OpalStatusUserInput *arg1) {
10327 delete arg1;
10328 }
10329
10330
10331 /*
10332 Document-class: Opal::OpalStatusMessageWaiting
10333
10334 Proxy of C++ Opal::OpalStatusMessageWaiting class
10335
10336
10337 */
10338 swig_class SwigClassOpalStatusMessageWaiting;
10339
10340
10341 /*
10342 Document-method: Opal::OpalStatusMessageWaiting.m_party
10343
10344 call-seq:
10345 m_party -> char
10346
10347 Get value of attribute.
10348
10349 */
10350
10351 /*
10352 Document-method: Opal::OpalStatusMessageWaiting.m_party=
10353
10354 call-seq:
10355 m_party=(x) -> char
10356
10357 Set new value for attribute.
10358
10359 */
10360 SWIGINTERN VALUE
10361 _wrap_OpalStatusMessageWaiting_m_party_set(int argc, VALUE *argv, VALUE self) {
10362 OpalStatusMessageWaiting *arg1 = (OpalStatusMessageWaiting *) 0 ;
10363 char *arg2 = (char *) 0 ;
10364 void *argp1 = 0 ;
10365 int res1 = 0 ;
10366 int res2 ;
10367 char *buf2 = 0 ;
10368 int alloc2 = 0 ;
10369
10370 if ((argc < 1) || (argc > 1)) {
10371 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10372 }
10373 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMessageWaiting, 0 | 0 );
10374 if (!SWIG_IsOK(res1)) {
10375 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMessageWaiting *","m_party", 1, self ));
10376 }
10377 arg1 = reinterpret_cast< OpalStatusMessageWaiting * >(argp1);
10378 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
10379 if (!SWIG_IsOK(res2)) {
10380 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_party", 2, argv[0] ));
10381 }
10382 arg2 = reinterpret_cast< char * >(buf2);
10383 if (arg2) {
10384 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
10385 arg1->m_party = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
10386 } else {
10387 arg1->m_party = 0;
10388 }
10389 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10390 return Qnil;
10391 fail:
10392 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10393 return Qnil;
10394 }
10395
10396
10397 SWIGINTERN VALUE
10398 _wrap_OpalStatusMessageWaiting_m_party_get(int argc, VALUE *argv, VALUE self) {
10399 OpalStatusMessageWaiting *arg1 = (OpalStatusMessageWaiting *) 0 ;
10400 void *argp1 = 0 ;
10401 int res1 = 0 ;
10402 char *result = 0 ;
10403 VALUE vresult = Qnil;
10404
10405 if ((argc < 0) || (argc > 0)) {
10406 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10407 }
10408 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMessageWaiting, 0 | 0 );
10409 if (!SWIG_IsOK(res1)) {
10410 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMessageWaiting *","m_party", 1, self ));
10411 }
10412 arg1 = reinterpret_cast< OpalStatusMessageWaiting * >(argp1);
10413 result = (char *) ((arg1)->m_party);
10414 vresult = SWIG_FromCharPtr((const char *)result);
10415 return vresult;
10416 fail:
10417 return Qnil;
10418 }
10419
10420
10421
10422 /*
10423 Document-method: Opal::OpalStatusMessageWaiting.m_type
10424
10425 call-seq:
10426 m_type -> char
10427
10428 Get value of attribute.
10429
10430 */
10431
10432 /*
10433 Document-method: Opal::OpalStatusMessageWaiting.m_type=
10434
10435 call-seq:
10436 m_type=(x) -> char
10437
10438 Set new value for attribute.
10439
10440 */
10441 SWIGINTERN VALUE
10442 _wrap_OpalStatusMessageWaiting_m_type_set(int argc, VALUE *argv, VALUE self) {
10443 OpalStatusMessageWaiting *arg1 = (OpalStatusMessageWaiting *) 0 ;
10444 char *arg2 = (char *) 0 ;
10445 void *argp1 = 0 ;
10446 int res1 = 0 ;
10447 int res2 ;
10448 char *buf2 = 0 ;
10449 int alloc2 = 0 ;
10450
10451 if ((argc < 1) || (argc > 1)) {
10452 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10453 }
10454 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMessageWaiting, 0 | 0 );
10455 if (!SWIG_IsOK(res1)) {
10456 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMessageWaiting *","m_type", 1, self ));
10457 }
10458 arg1 = reinterpret_cast< OpalStatusMessageWaiting * >(argp1);
10459 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
10460 if (!SWIG_IsOK(res2)) {
10461 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_type", 2, argv[0] ));
10462 }
10463 arg2 = reinterpret_cast< char * >(buf2);
10464 if (arg2) {
10465 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
10466 arg1->m_type = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
10467 } else {
10468 arg1->m_type = 0;
10469 }
10470 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10471 return Qnil;
10472 fail:
10473 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10474 return Qnil;
10475 }
10476
10477
10478 SWIGINTERN VALUE
10479 _wrap_OpalStatusMessageWaiting_m_type_get(int argc, VALUE *argv, VALUE self) {
10480 OpalStatusMessageWaiting *arg1 = (OpalStatusMessageWaiting *) 0 ;
10481 void *argp1 = 0 ;
10482 int res1 = 0 ;
10483 char *result = 0 ;
10484 VALUE vresult = Qnil;
10485
10486 if ((argc < 0) || (argc > 0)) {
10487 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10488 }
10489 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMessageWaiting, 0 | 0 );
10490 if (!SWIG_IsOK(res1)) {
10491 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMessageWaiting *","m_type", 1, self ));
10492 }
10493 arg1 = reinterpret_cast< OpalStatusMessageWaiting * >(argp1);
10494 result = (char *) ((arg1)->m_type);
10495 vresult = SWIG_FromCharPtr((const char *)result);
10496 return vresult;
10497 fail:
10498 return Qnil;
10499 }
10500
10501
10502
10503 /*
10504 Document-method: Opal::OpalStatusMessageWaiting.m_extraInfo
10505
10506 call-seq:
10507 m_extraInfo -> char
10508
10509 Get value of attribute.
10510
10511 */
10512
10513 /*
10514 Document-method: Opal::OpalStatusMessageWaiting.m_extraInfo=
10515
10516 call-seq:
10517 m_extraInfo=(x) -> char
10518
10519 Set new value for attribute.
10520
10521 */
10522 SWIGINTERN VALUE
10523 _wrap_OpalStatusMessageWaiting_m_extraInfo_set(int argc, VALUE *argv, VALUE self) {
10524 OpalStatusMessageWaiting *arg1 = (OpalStatusMessageWaiting *) 0 ;
10525 char *arg2 = (char *) 0 ;
10526 void *argp1 = 0 ;
10527 int res1 = 0 ;
10528 int res2 ;
10529 char *buf2 = 0 ;
10530 int alloc2 = 0 ;
10531
10532 if ((argc < 1) || (argc > 1)) {
10533 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10534 }
10535 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMessageWaiting, 0 | 0 );
10536 if (!SWIG_IsOK(res1)) {
10537 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMessageWaiting *","m_extraInfo", 1, self ));
10538 }
10539 arg1 = reinterpret_cast< OpalStatusMessageWaiting * >(argp1);
10540 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
10541 if (!SWIG_IsOK(res2)) {
10542 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_extraInfo", 2, argv[0] ));
10543 }
10544 arg2 = reinterpret_cast< char * >(buf2);
10545 if (arg2) {
10546 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
10547 arg1->m_extraInfo = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
10548 } else {
10549 arg1->m_extraInfo = 0;
10550 }
10551 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10552 return Qnil;
10553 fail:
10554 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10555 return Qnil;
10556 }
10557
10558
10559 SWIGINTERN VALUE
10560 _wrap_OpalStatusMessageWaiting_m_extraInfo_get(int argc, VALUE *argv, VALUE self) {
10561 OpalStatusMessageWaiting *arg1 = (OpalStatusMessageWaiting *) 0 ;
10562 void *argp1 = 0 ;
10563 int res1 = 0 ;
10564 char *result = 0 ;
10565 VALUE vresult = Qnil;
10566
10567 if ((argc < 0) || (argc > 0)) {
10568 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10569 }
10570 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusMessageWaiting, 0 | 0 );
10571 if (!SWIG_IsOK(res1)) {
10572 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusMessageWaiting *","m_extraInfo", 1, self ));
10573 }
10574 arg1 = reinterpret_cast< OpalStatusMessageWaiting * >(argp1);
10575 result = (char *) ((arg1)->m_extraInfo);
10576 vresult = SWIG_FromCharPtr((const char *)result);
10577 return vresult;
10578 fail:
10579 return Qnil;
10580 }
10581
10582
10583 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
10584 SWIGINTERN VALUE
10585 _wrap_OpalStatusMessageWaiting_allocate(VALUE self) {
10586 #else
10587 SWIGINTERN VALUE
10588 _wrap_OpalStatusMessageWaiting_allocate(int argc, VALUE *argv, VALUE self) {
10589 #endif
10590
10591
10592 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalStatusMessageWaiting);
10593 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
10594 rb_obj_call_init(vresult, argc, argv);
10595 #endif
10596 return vresult;
10597 }
10598
10599
10600
10601 /*
10602 Document-method: Opal::OpalStatusMessageWaiting.new
10603
10604 call-seq:
10605 OpalStatusMessageWaiting.new
10606
10607 Class constructor.
10608
10609 */
10610 SWIGINTERN VALUE
10611 _wrap_new_OpalStatusMessageWaiting(int argc, VALUE *argv, VALUE self) {
10612 OpalStatusMessageWaiting *result = 0 ;
10613
10614 if ((argc < 0) || (argc > 0)) {
10615 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10616 }
10617 result = (OpalStatusMessageWaiting *)new OpalStatusMessageWaiting();
10618 DATA_PTR(self) = result;
10619 return self;
10620 fail:
10621 return Qnil;
10622 }
10623
10624
10625 SWIGINTERN void
10626 free_OpalStatusMessageWaiting(OpalStatusMessageWaiting *arg1) {
10627 delete arg1;
10628 }
10629
10630
10631 /*
10632 Document-class: Opal::OpalStatusLineAppearance
10633
10634 Proxy of C++ Opal::OpalStatusLineAppearance class
10635
10636
10637 */
10638 swig_class SwigClassOpalStatusLineAppearance;
10639
10640
10641 /*
10642 Document-method: Opal::OpalStatusLineAppearance.m_line
10643
10644 call-seq:
10645 m_line -> char
10646
10647 Get value of attribute.
10648
10649 */
10650
10651 /*
10652 Document-method: Opal::OpalStatusLineAppearance.m_line=
10653
10654 call-seq:
10655 m_line=(x) -> char
10656
10657 Set new value for attribute.
10658
10659 */
10660 SWIGINTERN VALUE
10661 _wrap_OpalStatusLineAppearance_m_line_set(int argc, VALUE *argv, VALUE self) {
10662 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
10663 char *arg2 = (char *) 0 ;
10664 void *argp1 = 0 ;
10665 int res1 = 0 ;
10666 int res2 ;
10667 char *buf2 = 0 ;
10668 int alloc2 = 0 ;
10669
10670 if ((argc < 1) || (argc > 1)) {
10671 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10672 }
10673 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
10674 if (!SWIG_IsOK(res1)) {
10675 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_line", 1, self ));
10676 }
10677 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
10678 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
10679 if (!SWIG_IsOK(res2)) {
10680 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_line", 2, argv[0] ));
10681 }
10682 arg2 = reinterpret_cast< char * >(buf2);
10683 if (arg2) {
10684 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
10685 arg1->m_line = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
10686 } else {
10687 arg1->m_line = 0;
10688 }
10689 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10690 return Qnil;
10691 fail:
10692 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10693 return Qnil;
10694 }
10695
10696
10697 SWIGINTERN VALUE
10698 _wrap_OpalStatusLineAppearance_m_line_get(int argc, VALUE *argv, VALUE self) {
10699 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
10700 void *argp1 = 0 ;
10701 int res1 = 0 ;
10702 char *result = 0 ;
10703 VALUE vresult = Qnil;
10704
10705 if ((argc < 0) || (argc > 0)) {
10706 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10707 }
10708 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
10709 if (!SWIG_IsOK(res1)) {
10710 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_line", 1, self ));
10711 }
10712 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
10713 result = (char *) ((arg1)->m_line);
10714 vresult = SWIG_FromCharPtr((const char *)result);
10715 return vresult;
10716 fail:
10717 return Qnil;
10718 }
10719
10720
10721
10722 /*
10723 Document-method: Opal::OpalStatusLineAppearance.m_state
10724
10725 call-seq:
10726 m_state -> int
10727
10728 Get value of attribute.
10729
10730 */
10731
10732 /*
10733 Document-method: Opal::OpalStatusLineAppearance.m_state=
10734
10735 call-seq:
10736 m_state=(x) -> int
10737
10738 Set new value for attribute.
10739
10740 */
10741 SWIGINTERN VALUE
10742 _wrap_OpalStatusLineAppearance_m_state_set(int argc, VALUE *argv, VALUE self) {
10743 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
10744 OpalLineAppearanceStates arg2 ;
10745 void *argp1 = 0 ;
10746 int res1 = 0 ;
10747 int val2 ;
10748 int ecode2 = 0 ;
10749
10750 if ((argc < 1) || (argc > 1)) {
10751 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10752 }
10753 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
10754 if (!SWIG_IsOK(res1)) {
10755 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_state", 1, self ));
10756 }
10757 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
10758 ecode2 = SWIG_AsVal_int(argv[0], &val2);
10759 if (!SWIG_IsOK(ecode2)) {
10760 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalLineAppearanceStates","m_state", 2, argv[0] ));
10761 }
10762 arg2 = static_cast< OpalLineAppearanceStates >(val2);
10763 if (arg1) (arg1)->m_state = arg2;
10764 return Qnil;
10765 fail:
10766 return Qnil;
10767 }
10768
10769
10770 SWIGINTERN VALUE
10771 _wrap_OpalStatusLineAppearance_m_state_get(int argc, VALUE *argv, VALUE self) {
10772 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
10773 void *argp1 = 0 ;
10774 int res1 = 0 ;
10775 OpalLineAppearanceStates result;
10776 VALUE vresult = Qnil;
10777
10778 if ((argc < 0) || (argc > 0)) {
10779 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10780 }
10781 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
10782 if (!SWIG_IsOK(res1)) {
10783 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_state", 1, self ));
10784 }
10785 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
10786 result = (OpalLineAppearanceStates) ((arg1)->m_state);
10787 vresult = SWIG_From_int(static_cast< int >(result));
10788 return vresult;
10789 fail:
10790 return Qnil;
10791 }
10792
10793
10794
10795 /*
10796 Document-method: Opal::OpalStatusLineAppearance.m_appearance
10797
10798 call-seq:
10799 m_appearance -> int
10800
10801 Get value of attribute.
10802
10803 */
10804
10805 /*
10806 Document-method: Opal::OpalStatusLineAppearance.m_appearance=
10807
10808 call-seq:
10809 m_appearance=(x) -> int
10810
10811 Set new value for attribute.
10812
10813 */
10814 SWIGINTERN VALUE
10815 _wrap_OpalStatusLineAppearance_m_appearance_set(int argc, VALUE *argv, VALUE self) {
10816 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
10817 int arg2 ;
10818 void *argp1 = 0 ;
10819 int res1 = 0 ;
10820 int val2 ;
10821 int ecode2 = 0 ;
10822
10823 if ((argc < 1) || (argc > 1)) {
10824 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10825 }
10826 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
10827 if (!SWIG_IsOK(res1)) {
10828 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_appearance", 1, self ));
10829 }
10830 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
10831 ecode2 = SWIG_AsVal_int(argv[0], &val2);
10832 if (!SWIG_IsOK(ecode2)) {
10833 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","m_appearance", 2, argv[0] ));
10834 }
10835 arg2 = static_cast< int >(val2);
10836 if (arg1) (arg1)->m_appearance = arg2;
10837 return Qnil;
10838 fail:
10839 return Qnil;
10840 }
10841
10842
10843 SWIGINTERN VALUE
10844 _wrap_OpalStatusLineAppearance_m_appearance_get(int argc, VALUE *argv, VALUE self) {
10845 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
10846 void *argp1 = 0 ;
10847 int res1 = 0 ;
10848 int result;
10849 VALUE vresult = Qnil;
10850
10851 if ((argc < 0) || (argc > 0)) {
10852 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10853 }
10854 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
10855 if (!SWIG_IsOK(res1)) {
10856 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_appearance", 1, self ));
10857 }
10858 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
10859 result = (int) ((arg1)->m_appearance);
10860 vresult = SWIG_From_int(static_cast< int >(result));
10861 return vresult;
10862 fail:
10863 return Qnil;
10864 }
10865
10866
10867
10868 /*
10869 Document-method: Opal::OpalStatusLineAppearance.m_callId
10870
10871 call-seq:
10872 m_callId -> char
10873
10874 Get value of attribute.
10875
10876 */
10877
10878 /*
10879 Document-method: Opal::OpalStatusLineAppearance.m_callId=
10880
10881 call-seq:
10882 m_callId=(x) -> char
10883
10884 Set new value for attribute.
10885
10886 */
10887 SWIGINTERN VALUE
10888 _wrap_OpalStatusLineAppearance_m_callId_set(int argc, VALUE *argv, VALUE self) {
10889 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
10890 char *arg2 = (char *) 0 ;
10891 void *argp1 = 0 ;
10892 int res1 = 0 ;
10893 int res2 ;
10894 char *buf2 = 0 ;
10895 int alloc2 = 0 ;
10896
10897 if ((argc < 1) || (argc > 1)) {
10898 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10899 }
10900 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
10901 if (!SWIG_IsOK(res1)) {
10902 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_callId", 1, self ));
10903 }
10904 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
10905 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
10906 if (!SWIG_IsOK(res2)) {
10907 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callId", 2, argv[0] ));
10908 }
10909 arg2 = reinterpret_cast< char * >(buf2);
10910 if (arg2) {
10911 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
10912 arg1->m_callId = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
10913 } else {
10914 arg1->m_callId = 0;
10915 }
10916 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10917 return Qnil;
10918 fail:
10919 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10920 return Qnil;
10921 }
10922
10923
10924 SWIGINTERN VALUE
10925 _wrap_OpalStatusLineAppearance_m_callId_get(int argc, VALUE *argv, VALUE self) {
10926 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
10927 void *argp1 = 0 ;
10928 int res1 = 0 ;
10929 char *result = 0 ;
10930 VALUE vresult = Qnil;
10931
10932 if ((argc < 0) || (argc > 0)) {
10933 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10934 }
10935 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
10936 if (!SWIG_IsOK(res1)) {
10937 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_callId", 1, self ));
10938 }
10939 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
10940 result = (char *) ((arg1)->m_callId);
10941 vresult = SWIG_FromCharPtr((const char *)result);
10942 return vresult;
10943 fail:
10944 return Qnil;
10945 }
10946
10947
10948
10949 /*
10950 Document-method: Opal::OpalStatusLineAppearance.m_partyA
10951
10952 call-seq:
10953 m_partyA -> char
10954
10955 Get value of attribute.
10956
10957 */
10958
10959 /*
10960 Document-method: Opal::OpalStatusLineAppearance.m_partyA=
10961
10962 call-seq:
10963 m_partyA=(x) -> char
10964
10965 Set new value for attribute.
10966
10967 */
10968 SWIGINTERN VALUE
10969 _wrap_OpalStatusLineAppearance_m_partyA_set(int argc, VALUE *argv, VALUE self) {
10970 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
10971 char *arg2 = (char *) 0 ;
10972 void *argp1 = 0 ;
10973 int res1 = 0 ;
10974 int res2 ;
10975 char *buf2 = 0 ;
10976 int alloc2 = 0 ;
10977
10978 if ((argc < 1) || (argc > 1)) {
10979 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10980 }
10981 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
10982 if (!SWIG_IsOK(res1)) {
10983 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_partyA", 1, self ));
10984 }
10985 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
10986 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
10987 if (!SWIG_IsOK(res2)) {
10988 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_partyA", 2, argv[0] ));
10989 }
10990 arg2 = reinterpret_cast< char * >(buf2);
10991 if (arg2) {
10992 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
10993 arg1->m_partyA = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
10994 } else {
10995 arg1->m_partyA = 0;
10996 }
10997 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10998 return Qnil;
10999 fail:
11000 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11001 return Qnil;
11002 }
11003
11004
11005 SWIGINTERN VALUE
11006 _wrap_OpalStatusLineAppearance_m_partyA_get(int argc, VALUE *argv, VALUE self) {
11007 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
11008 void *argp1 = 0 ;
11009 int res1 = 0 ;
11010 char *result = 0 ;
11011 VALUE vresult = Qnil;
11012
11013 if ((argc < 0) || (argc > 0)) {
11014 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11015 }
11016 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
11017 if (!SWIG_IsOK(res1)) {
11018 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_partyA", 1, self ));
11019 }
11020 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
11021 result = (char *) ((arg1)->m_partyA);
11022 vresult = SWIG_FromCharPtr((const char *)result);
11023 return vresult;
11024 fail:
11025 return Qnil;
11026 }
11027
11028
11029
11030 /*
11031 Document-method: Opal::OpalStatusLineAppearance.m_partyB
11032
11033 call-seq:
11034 m_partyB -> char
11035
11036 Get value of attribute.
11037
11038 */
11039
11040 /*
11041 Document-method: Opal::OpalStatusLineAppearance.m_partyB=
11042
11043 call-seq:
11044 m_partyB=(x) -> char
11045
11046 Set new value for attribute.
11047
11048 */
11049 SWIGINTERN VALUE
11050 _wrap_OpalStatusLineAppearance_m_partyB_set(int argc, VALUE *argv, VALUE self) {
11051 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
11052 char *arg2 = (char *) 0 ;
11053 void *argp1 = 0 ;
11054 int res1 = 0 ;
11055 int res2 ;
11056 char *buf2 = 0 ;
11057 int alloc2 = 0 ;
11058
11059 if ((argc < 1) || (argc > 1)) {
11060 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11061 }
11062 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
11063 if (!SWIG_IsOK(res1)) {
11064 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_partyB", 1, self ));
11065 }
11066 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
11067 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
11068 if (!SWIG_IsOK(res2)) {
11069 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_partyB", 2, argv[0] ));
11070 }
11071 arg2 = reinterpret_cast< char * >(buf2);
11072 if (arg2) {
11073 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
11074 arg1->m_partyB = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
11075 } else {
11076 arg1->m_partyB = 0;
11077 }
11078 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11079 return Qnil;
11080 fail:
11081 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11082 return Qnil;
11083 }
11084
11085
11086 SWIGINTERN VALUE
11087 _wrap_OpalStatusLineAppearance_m_partyB_get(int argc, VALUE *argv, VALUE self) {
11088 OpalStatusLineAppearance *arg1 = (OpalStatusLineAppearance *) 0 ;
11089 void *argp1 = 0 ;
11090 int res1 = 0 ;
11091 char *result = 0 ;
11092 VALUE vresult = Qnil;
11093
11094 if ((argc < 0) || (argc > 0)) {
11095 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11096 }
11097 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
11098 if (!SWIG_IsOK(res1)) {
11099 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_partyB", 1, self ));
11100 }
11101 arg1 = reinterpret_cast< OpalStatusLineAppearance * >(argp1);
11102 result = (char *) ((arg1)->m_partyB);
11103 vresult = SWIG_FromCharPtr((const char *)result);
11104 return vresult;
11105 fail:
11106 return Qnil;
11107 }
11108
11109
11110 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
11111 SWIGINTERN VALUE
11112 _wrap_OpalStatusLineAppearance_allocate(VALUE self) {
11113 #else
11114 SWIGINTERN VALUE
11115 _wrap_OpalStatusLineAppearance_allocate(int argc, VALUE *argv, VALUE self) {
11116 #endif
11117
11118
11119 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalStatusLineAppearance);
11120 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
11121 rb_obj_call_init(vresult, argc, argv);
11122 #endif
11123 return vresult;
11124 }
11125
11126
11127
11128 /*
11129 Document-method: Opal::OpalStatusLineAppearance.new
11130
11131 call-seq:
11132 OpalStatusLineAppearance.new
11133
11134 Class constructor.
11135
11136 */
11137 SWIGINTERN VALUE
11138 _wrap_new_OpalStatusLineAppearance(int argc, VALUE *argv, VALUE self) {
11139 OpalStatusLineAppearance *result = 0 ;
11140
11141 if ((argc < 0) || (argc > 0)) {
11142 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11143 }
11144 result = (OpalStatusLineAppearance *)new OpalStatusLineAppearance();
11145 DATA_PTR(self) = result;
11146 return self;
11147 fail:
11148 return Qnil;
11149 }
11150
11151
11152 SWIGINTERN void
11153 free_OpalStatusLineAppearance(OpalStatusLineAppearance *arg1) {
11154 delete arg1;
11155 }
11156
11157
11158 /*
11159 Document-class: Opal::OpalParamRecording
11160
11161 Proxy of C++ Opal::OpalParamRecording class
11162
11163
11164 */
11165 swig_class SwigClassOpalParamRecording;
11166
11167
11168 /*
11169 Document-method: Opal::OpalParamRecording.m_callToken
11170
11171 call-seq:
11172 m_callToken -> char
11173
11174 Get value of attribute.
11175
11176 */
11177
11178 /*
11179 Document-method: Opal::OpalParamRecording.m_callToken=
11180
11181 call-seq:
11182 m_callToken=(x) -> char
11183
11184 Set new value for attribute.
11185
11186 */
11187 SWIGINTERN VALUE
11188 _wrap_OpalParamRecording_m_callToken_set(int argc, VALUE *argv, VALUE self) {
11189 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11190 char *arg2 = (char *) 0 ;
11191 void *argp1 = 0 ;
11192 int res1 = 0 ;
11193 int res2 ;
11194 char *buf2 = 0 ;
11195 int alloc2 = 0 ;
11196
11197 if ((argc < 1) || (argc > 1)) {
11198 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11199 }
11200 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11201 if (!SWIG_IsOK(res1)) {
11202 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_callToken", 1, self ));
11203 }
11204 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11205 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
11206 if (!SWIG_IsOK(res2)) {
11207 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
11208 }
11209 arg2 = reinterpret_cast< char * >(buf2);
11210 if (arg2) {
11211 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
11212 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
11213 } else {
11214 arg1->m_callToken = 0;
11215 }
11216 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11217 return Qnil;
11218 fail:
11219 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11220 return Qnil;
11221 }
11222
11223
11224 SWIGINTERN VALUE
11225 _wrap_OpalParamRecording_m_callToken_get(int argc, VALUE *argv, VALUE self) {
11226 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11227 void *argp1 = 0 ;
11228 int res1 = 0 ;
11229 char *result = 0 ;
11230 VALUE vresult = Qnil;
11231
11232 if ((argc < 0) || (argc > 0)) {
11233 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11234 }
11235 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11236 if (!SWIG_IsOK(res1)) {
11237 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_callToken", 1, self ));
11238 }
11239 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11240 result = (char *) ((arg1)->m_callToken);
11241 vresult = SWIG_FromCharPtr((const char *)result);
11242 return vresult;
11243 fail:
11244 return Qnil;
11245 }
11246
11247
11248
11249 /*
11250 Document-method: Opal::OpalParamRecording.m_file
11251
11252 call-seq:
11253 m_file -> char
11254
11255 Get value of attribute.
11256
11257 */
11258
11259 /*
11260 Document-method: Opal::OpalParamRecording.m_file=
11261
11262 call-seq:
11263 m_file=(x) -> char
11264
11265 Set new value for attribute.
11266
11267 */
11268 SWIGINTERN VALUE
11269 _wrap_OpalParamRecording_m_file_set(int argc, VALUE *argv, VALUE self) {
11270 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11271 char *arg2 = (char *) 0 ;
11272 void *argp1 = 0 ;
11273 int res1 = 0 ;
11274 int res2 ;
11275 char *buf2 = 0 ;
11276 int alloc2 = 0 ;
11277
11278 if ((argc < 1) || (argc > 1)) {
11279 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11280 }
11281 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11282 if (!SWIG_IsOK(res1)) {
11283 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_file", 1, self ));
11284 }
11285 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11286 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
11287 if (!SWIG_IsOK(res2)) {
11288 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_file", 2, argv[0] ));
11289 }
11290 arg2 = reinterpret_cast< char * >(buf2);
11291 if (arg2) {
11292 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
11293 arg1->m_file = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
11294 } else {
11295 arg1->m_file = 0;
11296 }
11297 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11298 return Qnil;
11299 fail:
11300 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11301 return Qnil;
11302 }
11303
11304
11305 SWIGINTERN VALUE
11306 _wrap_OpalParamRecording_m_file_get(int argc, VALUE *argv, VALUE self) {
11307 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11308 void *argp1 = 0 ;
11309 int res1 = 0 ;
11310 char *result = 0 ;
11311 VALUE vresult = Qnil;
11312
11313 if ((argc < 0) || (argc > 0)) {
11314 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11315 }
11316 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11317 if (!SWIG_IsOK(res1)) {
11318 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_file", 1, self ));
11319 }
11320 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11321 result = (char *) ((arg1)->m_file);
11322 vresult = SWIG_FromCharPtr((const char *)result);
11323 return vresult;
11324 fail:
11325 return Qnil;
11326 }
11327
11328
11329
11330 /*
11331 Document-method: Opal::OpalParamRecording.m_channels
11332
11333 call-seq:
11334 m_channels -> unsigned int
11335
11336 Get value of attribute.
11337
11338 */
11339
11340 /*
11341 Document-method: Opal::OpalParamRecording.m_channels=
11342
11343 call-seq:
11344 m_channels=(x) -> unsigned int
11345
11346 Set new value for attribute.
11347
11348 */
11349 SWIGINTERN VALUE
11350 _wrap_OpalParamRecording_m_channels_set(int argc, VALUE *argv, VALUE self) {
11351 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11352 unsigned int arg2 ;
11353 void *argp1 = 0 ;
11354 int res1 = 0 ;
11355 unsigned int val2 ;
11356 int ecode2 = 0 ;
11357
11358 if ((argc < 1) || (argc > 1)) {
11359 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11360 }
11361 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11362 if (!SWIG_IsOK(res1)) {
11363 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_channels", 1, self ));
11364 }
11365 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11366 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
11367 if (!SWIG_IsOK(ecode2)) {
11368 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_channels", 2, argv[0] ));
11369 }
11370 arg2 = static_cast< unsigned int >(val2);
11371 if (arg1) (arg1)->m_channels = arg2;
11372 return Qnil;
11373 fail:
11374 return Qnil;
11375 }
11376
11377
11378 SWIGINTERN VALUE
11379 _wrap_OpalParamRecording_m_channels_get(int argc, VALUE *argv, VALUE self) {
11380 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11381 void *argp1 = 0 ;
11382 int res1 = 0 ;
11383 unsigned int result;
11384 VALUE vresult = Qnil;
11385
11386 if ((argc < 0) || (argc > 0)) {
11387 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11388 }
11389 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11390 if (!SWIG_IsOK(res1)) {
11391 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_channels", 1, self ));
11392 }
11393 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11394 result = (unsigned int) ((arg1)->m_channels);
11395 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
11396 return vresult;
11397 fail:
11398 return Qnil;
11399 }
11400
11401
11402
11403 /*
11404 Document-method: Opal::OpalParamRecording.m_audioFormat
11405
11406 call-seq:
11407 m_audioFormat -> char
11408
11409 Get value of attribute.
11410
11411 */
11412
11413 /*
11414 Document-method: Opal::OpalParamRecording.m_audioFormat=
11415
11416 call-seq:
11417 m_audioFormat=(x) -> char
11418
11419 Set new value for attribute.
11420
11421 */
11422 SWIGINTERN VALUE
11423 _wrap_OpalParamRecording_m_audioFormat_set(int argc, VALUE *argv, VALUE self) {
11424 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11425 char *arg2 = (char *) 0 ;
11426 void *argp1 = 0 ;
11427 int res1 = 0 ;
11428 int res2 ;
11429 char *buf2 = 0 ;
11430 int alloc2 = 0 ;
11431
11432 if ((argc < 1) || (argc > 1)) {
11433 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11434 }
11435 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11436 if (!SWIG_IsOK(res1)) {
11437 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_audioFormat", 1, self ));
11438 }
11439 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11440 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
11441 if (!SWIG_IsOK(res2)) {
11442 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_audioFormat", 2, argv[0] ));
11443 }
11444 arg2 = reinterpret_cast< char * >(buf2);
11445 if (arg2) {
11446 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
11447 arg1->m_audioFormat = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
11448 } else {
11449 arg1->m_audioFormat = 0;
11450 }
11451 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11452 return Qnil;
11453 fail:
11454 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11455 return Qnil;
11456 }
11457
11458
11459 SWIGINTERN VALUE
11460 _wrap_OpalParamRecording_m_audioFormat_get(int argc, VALUE *argv, VALUE self) {
11461 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11462 void *argp1 = 0 ;
11463 int res1 = 0 ;
11464 char *result = 0 ;
11465 VALUE vresult = Qnil;
11466
11467 if ((argc < 0) || (argc > 0)) {
11468 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11469 }
11470 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11471 if (!SWIG_IsOK(res1)) {
11472 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_audioFormat", 1, self ));
11473 }
11474 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11475 result = (char *) ((arg1)->m_audioFormat);
11476 vresult = SWIG_FromCharPtr((const char *)result);
11477 return vresult;
11478 fail:
11479 return Qnil;
11480 }
11481
11482
11483
11484 /*
11485 Document-method: Opal::OpalParamRecording.m_videoFormat
11486
11487 call-seq:
11488 m_videoFormat -> char
11489
11490 Get value of attribute.
11491
11492 */
11493
11494 /*
11495 Document-method: Opal::OpalParamRecording.m_videoFormat=
11496
11497 call-seq:
11498 m_videoFormat=(x) -> char
11499
11500 Set new value for attribute.
11501
11502 */
11503 SWIGINTERN VALUE
11504 _wrap_OpalParamRecording_m_videoFormat_set(int argc, VALUE *argv, VALUE self) {
11505 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11506 char *arg2 = (char *) 0 ;
11507 void *argp1 = 0 ;
11508 int res1 = 0 ;
11509 int res2 ;
11510 char *buf2 = 0 ;
11511 int alloc2 = 0 ;
11512
11513 if ((argc < 1) || (argc > 1)) {
11514 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11515 }
11516 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11517 if (!SWIG_IsOK(res1)) {
11518 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_videoFormat", 1, self ));
11519 }
11520 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11521 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
11522 if (!SWIG_IsOK(res2)) {
11523 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_videoFormat", 2, argv[0] ));
11524 }
11525 arg2 = reinterpret_cast< char * >(buf2);
11526 if (arg2) {
11527 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
11528 arg1->m_videoFormat = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
11529 } else {
11530 arg1->m_videoFormat = 0;
11531 }
11532 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11533 return Qnil;
11534 fail:
11535 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11536 return Qnil;
11537 }
11538
11539
11540 SWIGINTERN VALUE
11541 _wrap_OpalParamRecording_m_videoFormat_get(int argc, VALUE *argv, VALUE self) {
11542 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11543 void *argp1 = 0 ;
11544 int res1 = 0 ;
11545 char *result = 0 ;
11546 VALUE vresult = Qnil;
11547
11548 if ((argc < 0) || (argc > 0)) {
11549 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11550 }
11551 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11552 if (!SWIG_IsOK(res1)) {
11553 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_videoFormat", 1, self ));
11554 }
11555 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11556 result = (char *) ((arg1)->m_videoFormat);
11557 vresult = SWIG_FromCharPtr((const char *)result);
11558 return vresult;
11559 fail:
11560 return Qnil;
11561 }
11562
11563
11564
11565 /*
11566 Document-method: Opal::OpalParamRecording.m_videoWidth
11567
11568 call-seq:
11569 m_videoWidth -> unsigned int
11570
11571 Get value of attribute.
11572
11573 */
11574
11575 /*
11576 Document-method: Opal::OpalParamRecording.m_videoWidth=
11577
11578 call-seq:
11579 m_videoWidth=(x) -> unsigned int
11580
11581 Set new value for attribute.
11582
11583 */
11584 SWIGINTERN VALUE
11585 _wrap_OpalParamRecording_m_videoWidth_set(int argc, VALUE *argv, VALUE self) {
11586 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11587 unsigned int arg2 ;
11588 void *argp1 = 0 ;
11589 int res1 = 0 ;
11590 unsigned int val2 ;
11591 int ecode2 = 0 ;
11592
11593 if ((argc < 1) || (argc > 1)) {
11594 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11595 }
11596 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11597 if (!SWIG_IsOK(res1)) {
11598 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_videoWidth", 1, self ));
11599 }
11600 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11601 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
11602 if (!SWIG_IsOK(ecode2)) {
11603 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_videoWidth", 2, argv[0] ));
11604 }
11605 arg2 = static_cast< unsigned int >(val2);
11606 if (arg1) (arg1)->m_videoWidth = arg2;
11607 return Qnil;
11608 fail:
11609 return Qnil;
11610 }
11611
11612
11613 SWIGINTERN VALUE
11614 _wrap_OpalParamRecording_m_videoWidth_get(int argc, VALUE *argv, VALUE self) {
11615 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11616 void *argp1 = 0 ;
11617 int res1 = 0 ;
11618 unsigned int result;
11619 VALUE vresult = Qnil;
11620
11621 if ((argc < 0) || (argc > 0)) {
11622 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11623 }
11624 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11625 if (!SWIG_IsOK(res1)) {
11626 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_videoWidth", 1, self ));
11627 }
11628 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11629 result = (unsigned int) ((arg1)->m_videoWidth);
11630 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
11631 return vresult;
11632 fail:
11633 return Qnil;
11634 }
11635
11636
11637
11638 /*
11639 Document-method: Opal::OpalParamRecording.m_videoHeight
11640
11641 call-seq:
11642 m_videoHeight -> unsigned int
11643
11644 Get value of attribute.
11645
11646 */
11647
11648 /*
11649 Document-method: Opal::OpalParamRecording.m_videoHeight=
11650
11651 call-seq:
11652 m_videoHeight=(x) -> unsigned int
11653
11654 Set new value for attribute.
11655
11656 */
11657 SWIGINTERN VALUE
11658 _wrap_OpalParamRecording_m_videoHeight_set(int argc, VALUE *argv, VALUE self) {
11659 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11660 unsigned int arg2 ;
11661 void *argp1 = 0 ;
11662 int res1 = 0 ;
11663 unsigned int val2 ;
11664 int ecode2 = 0 ;
11665
11666 if ((argc < 1) || (argc > 1)) {
11667 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11668 }
11669 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11670 if (!SWIG_IsOK(res1)) {
11671 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_videoHeight", 1, self ));
11672 }
11673 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11674 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
11675 if (!SWIG_IsOK(ecode2)) {
11676 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_videoHeight", 2, argv[0] ));
11677 }
11678 arg2 = static_cast< unsigned int >(val2);
11679 if (arg1) (arg1)->m_videoHeight = arg2;
11680 return Qnil;
11681 fail:
11682 return Qnil;
11683 }
11684
11685
11686 SWIGINTERN VALUE
11687 _wrap_OpalParamRecording_m_videoHeight_get(int argc, VALUE *argv, VALUE self) {
11688 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11689 void *argp1 = 0 ;
11690 int res1 = 0 ;
11691 unsigned int result;
11692 VALUE vresult = Qnil;
11693
11694 if ((argc < 0) || (argc > 0)) {
11695 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11696 }
11697 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11698 if (!SWIG_IsOK(res1)) {
11699 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_videoHeight", 1, self ));
11700 }
11701 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11702 result = (unsigned int) ((arg1)->m_videoHeight);
11703 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
11704 return vresult;
11705 fail:
11706 return Qnil;
11707 }
11708
11709
11710
11711 /*
11712 Document-method: Opal::OpalParamRecording.m_videoRate
11713
11714 call-seq:
11715 m_videoRate -> unsigned int
11716
11717 Get value of attribute.
11718
11719 */
11720
11721 /*
11722 Document-method: Opal::OpalParamRecording.m_videoRate=
11723
11724 call-seq:
11725 m_videoRate=(x) -> unsigned int
11726
11727 Set new value for attribute.
11728
11729 */
11730 SWIGINTERN VALUE
11731 _wrap_OpalParamRecording_m_videoRate_set(int argc, VALUE *argv, VALUE self) {
11732 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11733 unsigned int arg2 ;
11734 void *argp1 = 0 ;
11735 int res1 = 0 ;
11736 unsigned int val2 ;
11737 int ecode2 = 0 ;
11738
11739 if ((argc < 1) || (argc > 1)) {
11740 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11741 }
11742 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11743 if (!SWIG_IsOK(res1)) {
11744 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_videoRate", 1, self ));
11745 }
11746 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11747 ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
11748 if (!SWIG_IsOK(ecode2)) {
11749 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","m_videoRate", 2, argv[0] ));
11750 }
11751 arg2 = static_cast< unsigned int >(val2);
11752 if (arg1) (arg1)->m_videoRate = arg2;
11753 return Qnil;
11754 fail:
11755 return Qnil;
11756 }
11757
11758
11759 SWIGINTERN VALUE
11760 _wrap_OpalParamRecording_m_videoRate_get(int argc, VALUE *argv, VALUE self) {
11761 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11762 void *argp1 = 0 ;
11763 int res1 = 0 ;
11764 unsigned int result;
11765 VALUE vresult = Qnil;
11766
11767 if ((argc < 0) || (argc > 0)) {
11768 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11769 }
11770 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11771 if (!SWIG_IsOK(res1)) {
11772 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_videoRate", 1, self ));
11773 }
11774 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11775 result = (unsigned int) ((arg1)->m_videoRate);
11776 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
11777 return vresult;
11778 fail:
11779 return Qnil;
11780 }
11781
11782
11783
11784 /*
11785 Document-method: Opal::OpalParamRecording.m_videoMixing
11786
11787 call-seq:
11788 m_videoMixing -> int
11789
11790 Get value of attribute.
11791
11792 */
11793
11794 /*
11795 Document-method: Opal::OpalParamRecording.m_videoMixing=
11796
11797 call-seq:
11798 m_videoMixing=(x) -> int
11799
11800 Set new value for attribute.
11801
11802 */
11803 SWIGINTERN VALUE
11804 _wrap_OpalParamRecording_m_videoMixing_set(int argc, VALUE *argv, VALUE self) {
11805 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11806 OpalVideoRecordMixMode arg2 ;
11807 void *argp1 = 0 ;
11808 int res1 = 0 ;
11809 int val2 ;
11810 int ecode2 = 0 ;
11811
11812 if ((argc < 1) || (argc > 1)) {
11813 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11814 }
11815 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11816 if (!SWIG_IsOK(res1)) {
11817 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_videoMixing", 1, self ));
11818 }
11819 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11820 ecode2 = SWIG_AsVal_int(argv[0], &val2);
11821 if (!SWIG_IsOK(ecode2)) {
11822 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalVideoRecordMixMode","m_videoMixing", 2, argv[0] ));
11823 }
11824 arg2 = static_cast< OpalVideoRecordMixMode >(val2);
11825 if (arg1) (arg1)->m_videoMixing = arg2;
11826 return Qnil;
11827 fail:
11828 return Qnil;
11829 }
11830
11831
11832 SWIGINTERN VALUE
11833 _wrap_OpalParamRecording_m_videoMixing_get(int argc, VALUE *argv, VALUE self) {
11834 OpalParamRecording *arg1 = (OpalParamRecording *) 0 ;
11835 void *argp1 = 0 ;
11836 int res1 = 0 ;
11837 OpalVideoRecordMixMode result;
11838 VALUE vresult = Qnil;
11839
11840 if ((argc < 0) || (argc > 0)) {
11841 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11842 }
11843 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
11844 if (!SWIG_IsOK(res1)) {
11845 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamRecording *","m_videoMixing", 1, self ));
11846 }
11847 arg1 = reinterpret_cast< OpalParamRecording * >(argp1);
11848 result = (OpalVideoRecordMixMode) ((arg1)->m_videoMixing);
11849 vresult = SWIG_From_int(static_cast< int >(result));
11850 return vresult;
11851 fail:
11852 return Qnil;
11853 }
11854
11855
11856 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
11857 SWIGINTERN VALUE
11858 _wrap_OpalParamRecording_allocate(VALUE self) {
11859 #else
11860 SWIGINTERN VALUE
11861 _wrap_OpalParamRecording_allocate(int argc, VALUE *argv, VALUE self) {
11862 #endif
11863
11864
11865 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalParamRecording);
11866 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
11867 rb_obj_call_init(vresult, argc, argv);
11868 #endif
11869 return vresult;
11870 }
11871
11872
11873
11874 /*
11875 Document-method: Opal::OpalParamRecording.new
11876
11877 call-seq:
11878 OpalParamRecording.new
11879
11880 Class constructor.
11881
11882 */
11883 SWIGINTERN VALUE
11884 _wrap_new_OpalParamRecording(int argc, VALUE *argv, VALUE self) {
11885 OpalParamRecording *result = 0 ;
11886
11887 if ((argc < 0) || (argc > 0)) {
11888 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11889 }
11890 result = (OpalParamRecording *)new OpalParamRecording();
11891 DATA_PTR(self) = result;
11892 return self;
11893 fail:
11894 return Qnil;
11895 }
11896
11897
11898 SWIGINTERN void
11899 free_OpalParamRecording(OpalParamRecording *arg1) {
11900 delete arg1;
11901 }
11902
11903
11904 /*
11905 Document-class: Opal::OpalStatusTransferCall
11906
11907 Proxy of C++ Opal::OpalStatusTransferCall class
11908
11909
11910 */
11911 swig_class SwigClassOpalStatusTransferCall;
11912
11913
11914 /*
11915 Document-method: Opal::OpalStatusTransferCall.m_callToken
11916
11917 call-seq:
11918 m_callToken -> char
11919
11920 Get value of attribute.
11921
11922 */
11923
11924 /*
11925 Document-method: Opal::OpalStatusTransferCall.m_callToken=
11926
11927 call-seq:
11928 m_callToken=(x) -> char
11929
11930 Set new value for attribute.
11931
11932 */
11933 SWIGINTERN VALUE
11934 _wrap_OpalStatusTransferCall_m_callToken_set(int argc, VALUE *argv, VALUE self) {
11935 OpalStatusTransferCall *arg1 = (OpalStatusTransferCall *) 0 ;
11936 char *arg2 = (char *) 0 ;
11937 void *argp1 = 0 ;
11938 int res1 = 0 ;
11939 int res2 ;
11940 char *buf2 = 0 ;
11941 int alloc2 = 0 ;
11942
11943 if ((argc < 1) || (argc > 1)) {
11944 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11945 }
11946 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusTransferCall, 0 | 0 );
11947 if (!SWIG_IsOK(res1)) {
11948 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusTransferCall *","m_callToken", 1, self ));
11949 }
11950 arg1 = reinterpret_cast< OpalStatusTransferCall * >(argp1);
11951 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
11952 if (!SWIG_IsOK(res2)) {
11953 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
11954 }
11955 arg2 = reinterpret_cast< char * >(buf2);
11956 if (arg2) {
11957 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
11958 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
11959 } else {
11960 arg1->m_callToken = 0;
11961 }
11962 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11963 return Qnil;
11964 fail:
11965 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11966 return Qnil;
11967 }
11968
11969
11970 SWIGINTERN VALUE
11971 _wrap_OpalStatusTransferCall_m_callToken_get(int argc, VALUE *argv, VALUE self) {
11972 OpalStatusTransferCall *arg1 = (OpalStatusTransferCall *) 0 ;
11973 void *argp1 = 0 ;
11974 int res1 = 0 ;
11975 char *result = 0 ;
11976 VALUE vresult = Qnil;
11977
11978 if ((argc < 0) || (argc > 0)) {
11979 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11980 }
11981 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusTransferCall, 0 | 0 );
11982 if (!SWIG_IsOK(res1)) {
11983 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusTransferCall *","m_callToken", 1, self ));
11984 }
11985 arg1 = reinterpret_cast< OpalStatusTransferCall * >(argp1);
11986 result = (char *) ((arg1)->m_callToken);
11987 vresult = SWIG_FromCharPtr((const char *)result);
11988 return vresult;
11989 fail:
11990 return Qnil;
11991 }
11992
11993
11994
11995 /*
11996 Document-method: Opal::OpalStatusTransferCall.m_protocolCallId
11997
11998 call-seq:
11999 m_protocolCallId -> char
12000
12001 Get value of attribute.
12002
12003 */
12004
12005 /*
12006 Document-method: Opal::OpalStatusTransferCall.m_protocolCallId=
12007
12008 call-seq:
12009 m_protocolCallId=(x) -> char
12010
12011 Set new value for attribute.
12012
12013 */
12014 SWIGINTERN VALUE
12015 _wrap_OpalStatusTransferCall_m_protocolCallId_set(int argc, VALUE *argv, VALUE self) {
12016 OpalStatusTransferCall *arg1 = (OpalStatusTransferCall *) 0 ;
12017 char *arg2 = (char *) 0 ;
12018 void *argp1 = 0 ;
12019 int res1 = 0 ;
12020 int res2 ;
12021 char *buf2 = 0 ;
12022 int alloc2 = 0 ;
12023
12024 if ((argc < 1) || (argc > 1)) {
12025 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12026 }
12027 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusTransferCall, 0 | 0 );
12028 if (!SWIG_IsOK(res1)) {
12029 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusTransferCall *","m_protocolCallId", 1, self ));
12030 }
12031 arg1 = reinterpret_cast< OpalStatusTransferCall * >(argp1);
12032 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
12033 if (!SWIG_IsOK(res2)) {
12034 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_protocolCallId", 2, argv[0] ));
12035 }
12036 arg2 = reinterpret_cast< char * >(buf2);
12037 if (arg2) {
12038 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
12039 arg1->m_protocolCallId = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
12040 } else {
12041 arg1->m_protocolCallId = 0;
12042 }
12043 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12044 return Qnil;
12045 fail:
12046 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12047 return Qnil;
12048 }
12049
12050
12051 SWIGINTERN VALUE
12052 _wrap_OpalStatusTransferCall_m_protocolCallId_get(int argc, VALUE *argv, VALUE self) {
12053 OpalStatusTransferCall *arg1 = (OpalStatusTransferCall *) 0 ;
12054 void *argp1 = 0 ;
12055 int res1 = 0 ;
12056 char *result = 0 ;
12057 VALUE vresult = Qnil;
12058
12059 if ((argc < 0) || (argc > 0)) {
12060 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12061 }
12062 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusTransferCall, 0 | 0 );
12063 if (!SWIG_IsOK(res1)) {
12064 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusTransferCall *","m_protocolCallId", 1, self ));
12065 }
12066 arg1 = reinterpret_cast< OpalStatusTransferCall * >(argp1);
12067 result = (char *) ((arg1)->m_protocolCallId);
12068 vresult = SWIG_FromCharPtr((const char *)result);
12069 return vresult;
12070 fail:
12071 return Qnil;
12072 }
12073
12074
12075
12076 /*
12077 Document-method: Opal::OpalStatusTransferCall.m_result
12078
12079 call-seq:
12080 m_result -> char
12081
12082 Get value of attribute.
12083
12084 */
12085
12086 /*
12087 Document-method: Opal::OpalStatusTransferCall.m_result=
12088
12089 call-seq:
12090 m_result=(x) -> char
12091
12092 Set new value for attribute.
12093
12094 */
12095 SWIGINTERN VALUE
12096 _wrap_OpalStatusTransferCall_m_result_set(int argc, VALUE *argv, VALUE self) {
12097 OpalStatusTransferCall *arg1 = (OpalStatusTransferCall *) 0 ;
12098 char *arg2 = (char *) 0 ;
12099 void *argp1 = 0 ;
12100 int res1 = 0 ;
12101 int res2 ;
12102 char *buf2 = 0 ;
12103 int alloc2 = 0 ;
12104
12105 if ((argc < 1) || (argc > 1)) {
12106 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12107 }
12108 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusTransferCall, 0 | 0 );
12109 if (!SWIG_IsOK(res1)) {
12110 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusTransferCall *","m_result", 1, self ));
12111 }
12112 arg1 = reinterpret_cast< OpalStatusTransferCall * >(argp1);
12113 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
12114 if (!SWIG_IsOK(res2)) {
12115 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_result", 2, argv[0] ));
12116 }
12117 arg2 = reinterpret_cast< char * >(buf2);
12118 if (arg2) {
12119 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
12120 arg1->m_result = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
12121 } else {
12122 arg1->m_result = 0;
12123 }
12124 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12125 return Qnil;
12126 fail:
12127 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12128 return Qnil;
12129 }
12130
12131
12132 SWIGINTERN VALUE
12133 _wrap_OpalStatusTransferCall_m_result_get(int argc, VALUE *argv, VALUE self) {
12134 OpalStatusTransferCall *arg1 = (OpalStatusTransferCall *) 0 ;
12135 void *argp1 = 0 ;
12136 int res1 = 0 ;
12137 char *result = 0 ;
12138 VALUE vresult = Qnil;
12139
12140 if ((argc < 0) || (argc > 0)) {
12141 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12142 }
12143 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusTransferCall, 0 | 0 );
12144 if (!SWIG_IsOK(res1)) {
12145 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusTransferCall *","m_result", 1, self ));
12146 }
12147 arg1 = reinterpret_cast< OpalStatusTransferCall * >(argp1);
12148 result = (char *) ((arg1)->m_result);
12149 vresult = SWIG_FromCharPtr((const char *)result);
12150 return vresult;
12151 fail:
12152 return Qnil;
12153 }
12154
12155
12156
12157 /*
12158 Document-method: Opal::OpalStatusTransferCall.m_info
12159
12160 call-seq:
12161 m_info -> char
12162
12163 Get value of attribute.
12164
12165 */
12166
12167 /*
12168 Document-method: Opal::OpalStatusTransferCall.m_info=
12169
12170 call-seq:
12171 m_info=(x) -> char
12172
12173 Set new value for attribute.
12174
12175 */
12176 SWIGINTERN VALUE
12177 _wrap_OpalStatusTransferCall_m_info_set(int argc, VALUE *argv, VALUE self) {
12178 OpalStatusTransferCall *arg1 = (OpalStatusTransferCall *) 0 ;
12179 char *arg2 = (char *) 0 ;
12180 void *argp1 = 0 ;
12181 int res1 = 0 ;
12182 int res2 ;
12183 char *buf2 = 0 ;
12184 int alloc2 = 0 ;
12185
12186 if ((argc < 1) || (argc > 1)) {
12187 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12188 }
12189 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusTransferCall, 0 | 0 );
12190 if (!SWIG_IsOK(res1)) {
12191 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusTransferCall *","m_info", 1, self ));
12192 }
12193 arg1 = reinterpret_cast< OpalStatusTransferCall * >(argp1);
12194 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
12195 if (!SWIG_IsOK(res2)) {
12196 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_info", 2, argv[0] ));
12197 }
12198 arg2 = reinterpret_cast< char * >(buf2);
12199 if (arg2) {
12200 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
12201 arg1->m_info = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
12202 } else {
12203 arg1->m_info = 0;
12204 }
12205 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12206 return Qnil;
12207 fail:
12208 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12209 return Qnil;
12210 }
12211
12212
12213 SWIGINTERN VALUE
12214 _wrap_OpalStatusTransferCall_m_info_get(int argc, VALUE *argv, VALUE self) {
12215 OpalStatusTransferCall *arg1 = (OpalStatusTransferCall *) 0 ;
12216 void *argp1 = 0 ;
12217 int res1 = 0 ;
12218 char *result = 0 ;
12219 VALUE vresult = Qnil;
12220
12221 if ((argc < 0) || (argc > 0)) {
12222 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12223 }
12224 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusTransferCall, 0 | 0 );
12225 if (!SWIG_IsOK(res1)) {
12226 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusTransferCall *","m_info", 1, self ));
12227 }
12228 arg1 = reinterpret_cast< OpalStatusTransferCall * >(argp1);
12229 result = (char *) ((arg1)->m_info);
12230 vresult = SWIG_FromCharPtr((const char *)result);
12231 return vresult;
12232 fail:
12233 return Qnil;
12234 }
12235
12236
12237 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
12238 SWIGINTERN VALUE
12239 _wrap_OpalStatusTransferCall_allocate(VALUE self) {
12240 #else
12241 SWIGINTERN VALUE
12242 _wrap_OpalStatusTransferCall_allocate(int argc, VALUE *argv, VALUE self) {
12243 #endif
12244
12245
12246 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalStatusTransferCall);
12247 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
12248 rb_obj_call_init(vresult, argc, argv);
12249 #endif
12250 return vresult;
12251 }
12252
12253
12254
12255 /*
12256 Document-method: Opal::OpalStatusTransferCall.new
12257
12258 call-seq:
12259 OpalStatusTransferCall.new
12260
12261 Class constructor.
12262
12263 */
12264 SWIGINTERN VALUE
12265 _wrap_new_OpalStatusTransferCall(int argc, VALUE *argv, VALUE self) {
12266 OpalStatusTransferCall *result = 0 ;
12267
12268 if ((argc < 0) || (argc > 0)) {
12269 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12270 }
12271 result = (OpalStatusTransferCall *)new OpalStatusTransferCall();
12272 DATA_PTR(self) = result;
12273 return self;
12274 fail:
12275 return Qnil;
12276 }
12277
12278
12279 SWIGINTERN void
12280 free_OpalStatusTransferCall(OpalStatusTransferCall *arg1) {
12281 delete arg1;
12282 }
12283
12284
12285 /*
12286 Document-class: Opal::OpalStatusIVR
12287
12288 Proxy of C++ Opal::OpalStatusIVR class
12289
12290
12291 */
12292 swig_class SwigClassOpalStatusIVR;
12293
12294
12295 /*
12296 Document-method: Opal::OpalStatusIVR.m_callToken
12297
12298 call-seq:
12299 m_callToken -> char
12300
12301 Get value of attribute.
12302
12303 */
12304
12305 /*
12306 Document-method: Opal::OpalStatusIVR.m_callToken=
12307
12308 call-seq:
12309 m_callToken=(x) -> char
12310
12311 Set new value for attribute.
12312
12313 */
12314 SWIGINTERN VALUE
12315 _wrap_OpalStatusIVR_m_callToken_set(int argc, VALUE *argv, VALUE self) {
12316 OpalStatusIVR *arg1 = (OpalStatusIVR *) 0 ;
12317 char *arg2 = (char *) 0 ;
12318 void *argp1 = 0 ;
12319 int res1 = 0 ;
12320 int res2 ;
12321 char *buf2 = 0 ;
12322 int alloc2 = 0 ;
12323
12324 if ((argc < 1) || (argc > 1)) {
12325 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12326 }
12327 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIVR, 0 | 0 );
12328 if (!SWIG_IsOK(res1)) {
12329 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIVR *","m_callToken", 1, self ));
12330 }
12331 arg1 = reinterpret_cast< OpalStatusIVR * >(argp1);
12332 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
12333 if (!SWIG_IsOK(res2)) {
12334 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
12335 }
12336 arg2 = reinterpret_cast< char * >(buf2);
12337 if (arg2) {
12338 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
12339 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
12340 } else {
12341 arg1->m_callToken = 0;
12342 }
12343 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12344 return Qnil;
12345 fail:
12346 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12347 return Qnil;
12348 }
12349
12350
12351 SWIGINTERN VALUE
12352 _wrap_OpalStatusIVR_m_callToken_get(int argc, VALUE *argv, VALUE self) {
12353 OpalStatusIVR *arg1 = (OpalStatusIVR *) 0 ;
12354 void *argp1 = 0 ;
12355 int res1 = 0 ;
12356 char *result = 0 ;
12357 VALUE vresult = Qnil;
12358
12359 if ((argc < 0) || (argc > 0)) {
12360 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12361 }
12362 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIVR, 0 | 0 );
12363 if (!SWIG_IsOK(res1)) {
12364 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIVR *","m_callToken", 1, self ));
12365 }
12366 arg1 = reinterpret_cast< OpalStatusIVR * >(argp1);
12367 result = (char *) ((arg1)->m_callToken);
12368 vresult = SWIG_FromCharPtr((const char *)result);
12369 return vresult;
12370 fail:
12371 return Qnil;
12372 }
12373
12374
12375
12376 /*
12377 Document-method: Opal::OpalStatusIVR.m_variables
12378
12379 call-seq:
12380 m_variables -> char
12381
12382 Get value of attribute.
12383
12384 */
12385
12386 /*
12387 Document-method: Opal::OpalStatusIVR.m_variables=
12388
12389 call-seq:
12390 m_variables=(x) -> char
12391
12392 Set new value for attribute.
12393
12394 */
12395 SWIGINTERN VALUE
12396 _wrap_OpalStatusIVR_m_variables_set(int argc, VALUE *argv, VALUE self) {
12397 OpalStatusIVR *arg1 = (OpalStatusIVR *) 0 ;
12398 char *arg2 = (char *) 0 ;
12399 void *argp1 = 0 ;
12400 int res1 = 0 ;
12401 int res2 ;
12402 char *buf2 = 0 ;
12403 int alloc2 = 0 ;
12404
12405 if ((argc < 1) || (argc > 1)) {
12406 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12407 }
12408 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIVR, 0 | 0 );
12409 if (!SWIG_IsOK(res1)) {
12410 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIVR *","m_variables", 1, self ));
12411 }
12412 arg1 = reinterpret_cast< OpalStatusIVR * >(argp1);
12413 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
12414 if (!SWIG_IsOK(res2)) {
12415 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_variables", 2, argv[0] ));
12416 }
12417 arg2 = reinterpret_cast< char * >(buf2);
12418 if (arg2) {
12419 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
12420 arg1->m_variables = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
12421 } else {
12422 arg1->m_variables = 0;
12423 }
12424 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12425 return Qnil;
12426 fail:
12427 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12428 return Qnil;
12429 }
12430
12431
12432 SWIGINTERN VALUE
12433 _wrap_OpalStatusIVR_m_variables_get(int argc, VALUE *argv, VALUE self) {
12434 OpalStatusIVR *arg1 = (OpalStatusIVR *) 0 ;
12435 void *argp1 = 0 ;
12436 int res1 = 0 ;
12437 char *result = 0 ;
12438 VALUE vresult = Qnil;
12439
12440 if ((argc < 0) || (argc > 0)) {
12441 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12442 }
12443 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusIVR, 0 | 0 );
12444 if (!SWIG_IsOK(res1)) {
12445 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusIVR *","m_variables", 1, self ));
12446 }
12447 arg1 = reinterpret_cast< OpalStatusIVR * >(argp1);
12448 result = (char *) ((arg1)->m_variables);
12449 vresult = SWIG_FromCharPtr((const char *)result);
12450 return vresult;
12451 fail:
12452 return Qnil;
12453 }
12454
12455
12456 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
12457 SWIGINTERN VALUE
12458 _wrap_OpalStatusIVR_allocate(VALUE self) {
12459 #else
12460 SWIGINTERN VALUE
12461 _wrap_OpalStatusIVR_allocate(int argc, VALUE *argv, VALUE self) {
12462 #endif
12463
12464
12465 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalStatusIVR);
12466 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
12467 rb_obj_call_init(vresult, argc, argv);
12468 #endif
12469 return vresult;
12470 }
12471
12472
12473
12474 /*
12475 Document-method: Opal::OpalStatusIVR.new
12476
12477 call-seq:
12478 OpalStatusIVR.new
12479
12480 Class constructor.
12481
12482 */
12483 SWIGINTERN VALUE
12484 _wrap_new_OpalStatusIVR(int argc, VALUE *argv, VALUE self) {
12485 OpalStatusIVR *result = 0 ;
12486
12487 if ((argc < 0) || (argc > 0)) {
12488 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12489 }
12490 result = (OpalStatusIVR *)new OpalStatusIVR();
12491 DATA_PTR(self) = result;
12492 return self;
12493 fail:
12494 return Qnil;
12495 }
12496
12497
12498 SWIGINTERN void
12499 free_OpalStatusIVR(OpalStatusIVR *arg1) {
12500 delete arg1;
12501 }
12502
12503
12504 /*
12505 Document-class: Opal::OpalStatusCallCleared
12506
12507 Proxy of C++ Opal::OpalStatusCallCleared class
12508
12509
12510 */
12511 swig_class SwigClassOpalStatusCallCleared;
12512
12513
12514 /*
12515 Document-method: Opal::OpalStatusCallCleared.m_callToken
12516
12517 call-seq:
12518 m_callToken -> char
12519
12520 Get value of attribute.
12521
12522 */
12523
12524 /*
12525 Document-method: Opal::OpalStatusCallCleared.m_callToken=
12526
12527 call-seq:
12528 m_callToken=(x) -> char
12529
12530 Set new value for attribute.
12531
12532 */
12533 SWIGINTERN VALUE
12534 _wrap_OpalStatusCallCleared_m_callToken_set(int argc, VALUE *argv, VALUE self) {
12535 OpalStatusCallCleared *arg1 = (OpalStatusCallCleared *) 0 ;
12536 char *arg2 = (char *) 0 ;
12537 void *argp1 = 0 ;
12538 int res1 = 0 ;
12539 int res2 ;
12540 char *buf2 = 0 ;
12541 int alloc2 = 0 ;
12542
12543 if ((argc < 1) || (argc > 1)) {
12544 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12545 }
12546 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusCallCleared, 0 | 0 );
12547 if (!SWIG_IsOK(res1)) {
12548 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusCallCleared *","m_callToken", 1, self ));
12549 }
12550 arg1 = reinterpret_cast< OpalStatusCallCleared * >(argp1);
12551 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
12552 if (!SWIG_IsOK(res2)) {
12553 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
12554 }
12555 arg2 = reinterpret_cast< char * >(buf2);
12556 if (arg2) {
12557 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
12558 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
12559 } else {
12560 arg1->m_callToken = 0;
12561 }
12562 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12563 return Qnil;
12564 fail:
12565 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12566 return Qnil;
12567 }
12568
12569
12570 SWIGINTERN VALUE
12571 _wrap_OpalStatusCallCleared_m_callToken_get(int argc, VALUE *argv, VALUE self) {
12572 OpalStatusCallCleared *arg1 = (OpalStatusCallCleared *) 0 ;
12573 void *argp1 = 0 ;
12574 int res1 = 0 ;
12575 char *result = 0 ;
12576 VALUE vresult = Qnil;
12577
12578 if ((argc < 0) || (argc > 0)) {
12579 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12580 }
12581 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusCallCleared, 0 | 0 );
12582 if (!SWIG_IsOK(res1)) {
12583 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusCallCleared *","m_callToken", 1, self ));
12584 }
12585 arg1 = reinterpret_cast< OpalStatusCallCleared * >(argp1);
12586 result = (char *) ((arg1)->m_callToken);
12587 vresult = SWIG_FromCharPtr((const char *)result);
12588 return vresult;
12589 fail:
12590 return Qnil;
12591 }
12592
12593
12594
12595 /*
12596 Document-method: Opal::OpalStatusCallCleared.m_reason
12597
12598 call-seq:
12599 m_reason -> char
12600
12601 Get value of attribute.
12602
12603 */
12604
12605 /*
12606 Document-method: Opal::OpalStatusCallCleared.m_reason=
12607
12608 call-seq:
12609 m_reason=(x) -> char
12610
12611 Set new value for attribute.
12612
12613 */
12614 SWIGINTERN VALUE
12615 _wrap_OpalStatusCallCleared_m_reason_set(int argc, VALUE *argv, VALUE self) {
12616 OpalStatusCallCleared *arg1 = (OpalStatusCallCleared *) 0 ;
12617 char *arg2 = (char *) 0 ;
12618 void *argp1 = 0 ;
12619 int res1 = 0 ;
12620 int res2 ;
12621 char *buf2 = 0 ;
12622 int alloc2 = 0 ;
12623
12624 if ((argc < 1) || (argc > 1)) {
12625 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12626 }
12627 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusCallCleared, 0 | 0 );
12628 if (!SWIG_IsOK(res1)) {
12629 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusCallCleared *","m_reason", 1, self ));
12630 }
12631 arg1 = reinterpret_cast< OpalStatusCallCleared * >(argp1);
12632 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
12633 if (!SWIG_IsOK(res2)) {
12634 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_reason", 2, argv[0] ));
12635 }
12636 arg2 = reinterpret_cast< char * >(buf2);
12637 if (arg2) {
12638 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
12639 arg1->m_reason = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
12640 } else {
12641 arg1->m_reason = 0;
12642 }
12643 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12644 return Qnil;
12645 fail:
12646 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12647 return Qnil;
12648 }
12649
12650
12651 SWIGINTERN VALUE
12652 _wrap_OpalStatusCallCleared_m_reason_get(int argc, VALUE *argv, VALUE self) {
12653 OpalStatusCallCleared *arg1 = (OpalStatusCallCleared *) 0 ;
12654 void *argp1 = 0 ;
12655 int res1 = 0 ;
12656 char *result = 0 ;
12657 VALUE vresult = Qnil;
12658
12659 if ((argc < 0) || (argc > 0)) {
12660 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12661 }
12662 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalStatusCallCleared, 0 | 0 );
12663 if (!SWIG_IsOK(res1)) {
12664 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalStatusCallCleared *","m_reason", 1, self ));
12665 }
12666 arg1 = reinterpret_cast< OpalStatusCallCleared * >(argp1);
12667 result = (char *) ((arg1)->m_reason);
12668 vresult = SWIG_FromCharPtr((const char *)result);
12669 return vresult;
12670 fail:
12671 return Qnil;
12672 }
12673
12674
12675 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
12676 SWIGINTERN VALUE
12677 _wrap_OpalStatusCallCleared_allocate(VALUE self) {
12678 #else
12679 SWIGINTERN VALUE
12680 _wrap_OpalStatusCallCleared_allocate(int argc, VALUE *argv, VALUE self) {
12681 #endif
12682
12683
12684 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalStatusCallCleared);
12685 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
12686 rb_obj_call_init(vresult, argc, argv);
12687 #endif
12688 return vresult;
12689 }
12690
12691
12692
12693 /*
12694 Document-method: Opal::OpalStatusCallCleared.new
12695
12696 call-seq:
12697 OpalStatusCallCleared.new
12698
12699 Class constructor.
12700
12701 */
12702 SWIGINTERN VALUE
12703 _wrap_new_OpalStatusCallCleared(int argc, VALUE *argv, VALUE self) {
12704 OpalStatusCallCleared *result = 0 ;
12705
12706 if ((argc < 0) || (argc > 0)) {
12707 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12708 }
12709 result = (OpalStatusCallCleared *)new OpalStatusCallCleared();
12710 DATA_PTR(self) = result;
12711 return self;
12712 fail:
12713 return Qnil;
12714 }
12715
12716
12717 SWIGINTERN void
12718 free_OpalStatusCallCleared(OpalStatusCallCleared *arg1) {
12719 delete arg1;
12720 }
12721
12722
12723 /*
12724 Document-class: Opal::OpalParamCallCleared
12725
12726 Proxy of C++ Opal::OpalParamCallCleared class
12727
12728
12729 */
12730 swig_class SwigClassOpalParamCallCleared;
12731
12732
12733 /*
12734 Document-method: Opal::OpalParamCallCleared.m_callToken
12735
12736 call-seq:
12737 m_callToken -> char
12738
12739 Get value of attribute.
12740
12741 */
12742
12743 /*
12744 Document-method: Opal::OpalParamCallCleared.m_callToken=
12745
12746 call-seq:
12747 m_callToken=(x) -> char
12748
12749 Set new value for attribute.
12750
12751 */
12752 SWIGINTERN VALUE
12753 _wrap_OpalParamCallCleared_m_callToken_set(int argc, VALUE *argv, VALUE self) {
12754 OpalParamCallCleared *arg1 = (OpalParamCallCleared *) 0 ;
12755 char *arg2 = (char *) 0 ;
12756 void *argp1 = 0 ;
12757 int res1 = 0 ;
12758 int res2 ;
12759 char *buf2 = 0 ;
12760 int alloc2 = 0 ;
12761
12762 if ((argc < 1) || (argc > 1)) {
12763 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12764 }
12765 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamCallCleared, 0 | 0 );
12766 if (!SWIG_IsOK(res1)) {
12767 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamCallCleared *","m_callToken", 1, self ));
12768 }
12769 arg1 = reinterpret_cast< OpalParamCallCleared * >(argp1);
12770 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
12771 if (!SWIG_IsOK(res2)) {
12772 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
12773 }
12774 arg2 = reinterpret_cast< char * >(buf2);
12775 if (arg2) {
12776 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
12777 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
12778 } else {
12779 arg1->m_callToken = 0;
12780 }
12781 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12782 return Qnil;
12783 fail:
12784 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
12785 return Qnil;
12786 }
12787
12788
12789 SWIGINTERN VALUE
12790 _wrap_OpalParamCallCleared_m_callToken_get(int argc, VALUE *argv, VALUE self) {
12791 OpalParamCallCleared *arg1 = (OpalParamCallCleared *) 0 ;
12792 void *argp1 = 0 ;
12793 int res1 = 0 ;
12794 char *result = 0 ;
12795 VALUE vresult = Qnil;
12796
12797 if ((argc < 0) || (argc > 0)) {
12798 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12799 }
12800 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamCallCleared, 0 | 0 );
12801 if (!SWIG_IsOK(res1)) {
12802 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamCallCleared *","m_callToken", 1, self ));
12803 }
12804 arg1 = reinterpret_cast< OpalParamCallCleared * >(argp1);
12805 result = (char *) ((arg1)->m_callToken);
12806 vresult = SWIG_FromCharPtr((const char *)result);
12807 return vresult;
12808 fail:
12809 return Qnil;
12810 }
12811
12812
12813
12814 /*
12815 Document-method: Opal::OpalParamCallCleared.m_reason
12816
12817 call-seq:
12818 m_reason -> int
12819
12820 Get value of attribute.
12821
12822 */
12823
12824 /*
12825 Document-method: Opal::OpalParamCallCleared.m_reason=
12826
12827 call-seq:
12828 m_reason=(x) -> int
12829
12830 Set new value for attribute.
12831
12832 */
12833 SWIGINTERN VALUE
12834 _wrap_OpalParamCallCleared_m_reason_set(int argc, VALUE *argv, VALUE self) {
12835 OpalParamCallCleared *arg1 = (OpalParamCallCleared *) 0 ;
12836 OpalCallEndReason arg2 ;
12837 void *argp1 = 0 ;
12838 int res1 = 0 ;
12839 int val2 ;
12840 int ecode2 = 0 ;
12841
12842 if ((argc < 1) || (argc > 1)) {
12843 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12844 }
12845 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamCallCleared, 0 | 0 );
12846 if (!SWIG_IsOK(res1)) {
12847 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamCallCleared *","m_reason", 1, self ));
12848 }
12849 arg1 = reinterpret_cast< OpalParamCallCleared * >(argp1);
12850 ecode2 = SWIG_AsVal_int(argv[0], &val2);
12851 if (!SWIG_IsOK(ecode2)) {
12852 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalCallEndReason","m_reason", 2, argv[0] ));
12853 }
12854 arg2 = static_cast< OpalCallEndReason >(val2);
12855 if (arg1) (arg1)->m_reason = arg2;
12856 return Qnil;
12857 fail:
12858 return Qnil;
12859 }
12860
12861
12862 SWIGINTERN VALUE
12863 _wrap_OpalParamCallCleared_m_reason_get(int argc, VALUE *argv, VALUE self) {
12864 OpalParamCallCleared *arg1 = (OpalParamCallCleared *) 0 ;
12865 void *argp1 = 0 ;
12866 int res1 = 0 ;
12867 OpalCallEndReason result;
12868 VALUE vresult = Qnil;
12869
12870 if ((argc < 0) || (argc > 0)) {
12871 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12872 }
12873 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalParamCallCleared, 0 | 0 );
12874 if (!SWIG_IsOK(res1)) {
12875 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalParamCallCleared *","m_reason", 1, self ));
12876 }
12877 arg1 = reinterpret_cast< OpalParamCallCleared * >(argp1);
12878 result = (OpalCallEndReason) ((arg1)->m_reason);
12879 vresult = SWIG_From_int(static_cast< int >(result));
12880 return vresult;
12881 fail:
12882 return Qnil;
12883 }
12884
12885
12886 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
12887 SWIGINTERN VALUE
12888 _wrap_OpalParamCallCleared_allocate(VALUE self) {
12889 #else
12890 SWIGINTERN VALUE
12891 _wrap_OpalParamCallCleared_allocate(int argc, VALUE *argv, VALUE self) {
12892 #endif
12893
12894
12895 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalParamCallCleared);
12896 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
12897 rb_obj_call_init(vresult, argc, argv);
12898 #endif
12899 return vresult;
12900 }
12901
12902
12903
12904 /*
12905 Document-method: Opal::OpalParamCallCleared.new
12906
12907 call-seq:
12908 OpalParamCallCleared.new
12909
12910 Class constructor.
12911
12912 */
12913 SWIGINTERN VALUE
12914 _wrap_new_OpalParamCallCleared(int argc, VALUE *argv, VALUE self) {
12915 OpalParamCallCleared *result = 0 ;
12916
12917 if ((argc < 0) || (argc > 0)) {
12918 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12919 }
12920 result = (OpalParamCallCleared *)new OpalParamCallCleared();
12921 DATA_PTR(self) = result;
12922 return self;
12923 fail:
12924 return Qnil;
12925 }
12926
12927
12928 SWIGINTERN void
12929 free_OpalParamCallCleared(OpalParamCallCleared *arg1) {
12930 delete arg1;
12931 }
12932
12933
12934 /*
12935 Document-class: Opal::OpalMessage
12936
12937 Proxy of C++ Opal::OpalMessage class
12938
12939
12940 */
12941 swig_class SwigClassOpalMessage;
12942
12943
12944 /*
12945 Document-method: Opal::OpalMessage.m_type
12946
12947 call-seq:
12948 m_type -> int
12949
12950 Get value of attribute.
12951
12952 */
12953
12954 /*
12955 Document-method: Opal::OpalMessage.m_type=
12956
12957 call-seq:
12958 m_type=(x) -> int
12959
12960 Set new value for attribute.
12961
12962 */
12963 SWIGINTERN VALUE
12964 _wrap_OpalMessage_m_type_set(int argc, VALUE *argv, VALUE self) {
12965 OpalMessage *arg1 = (OpalMessage *) 0 ;
12966 OpalMessageType arg2 ;
12967 void *argp1 = 0 ;
12968 int res1 = 0 ;
12969 int val2 ;
12970 int ecode2 = 0 ;
12971
12972 if ((argc < 1) || (argc > 1)) {
12973 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12974 }
12975 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage, 0 | 0 );
12976 if (!SWIG_IsOK(res1)) {
12977 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage *","m_type", 1, self ));
12978 }
12979 arg1 = reinterpret_cast< OpalMessage * >(argp1);
12980 ecode2 = SWIG_AsVal_int(argv[0], &val2);
12981 if (!SWIG_IsOK(ecode2)) {
12982 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalMessageType","m_type", 2, argv[0] ));
12983 }
12984 arg2 = static_cast< OpalMessageType >(val2);
12985 if (arg1) (arg1)->m_type = arg2;
12986 return Qnil;
12987 fail:
12988 return Qnil;
12989 }
12990
12991
12992 SWIGINTERN VALUE
12993 _wrap_OpalMessage_m_type_get(int argc, VALUE *argv, VALUE self) {
12994 OpalMessage *arg1 = (OpalMessage *) 0 ;
12995 void *argp1 = 0 ;
12996 int res1 = 0 ;
12997 OpalMessageType result;
12998 VALUE vresult = Qnil;
12999
13000 if ((argc < 0) || (argc > 0)) {
13001 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13002 }
13003 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage, 0 | 0 );
13004 if (!SWIG_IsOK(res1)) {
13005 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage *","m_type", 1, self ));
13006 }
13007 arg1 = reinterpret_cast< OpalMessage * >(argp1);
13008 result = (OpalMessageType) ((arg1)->m_type);
13009 vresult = SWIG_From_int(static_cast< int >(result));
13010 return vresult;
13011 fail:
13012 return Qnil;
13013 }
13014
13015
13016
13017 /*
13018 Document-method: Opal::OpalMessage.m_param
13019
13020 call-seq:
13021 m_param -> OpalMessage_m_param
13022
13023 Get value of attribute.
13024
13025 */
13026 SWIGINTERN VALUE
13027 _wrap_OpalMessage_m_param_get(int argc, VALUE *argv, VALUE self) {
13028 OpalMessage *arg1 = (OpalMessage *) 0 ;
13029 void *argp1 = 0 ;
13030 int res1 = 0 ;
13031 OpalMessage_m_param *result = 0 ;
13032 VALUE vresult = Qnil;
13033
13034 if ((argc < 0) || (argc > 0)) {
13035 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13036 }
13037 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage, 0 | 0 );
13038 if (!SWIG_IsOK(res1)) {
13039 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage *","m_param", 1, self ));
13040 }
13041 arg1 = reinterpret_cast< OpalMessage * >(argp1);
13042 result = (OpalMessage_m_param *)& ((arg1)->m_param);
13043 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13044 return vresult;
13045 fail:
13046 return Qnil;
13047 }
13048
13049
13050 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
13051 SWIGINTERN VALUE
13052 _wrap_OpalMessage_allocate(VALUE self) {
13053 #else
13054 SWIGINTERN VALUE
13055 _wrap_OpalMessage_allocate(int argc, VALUE *argv, VALUE self) {
13056 #endif
13057
13058
13059 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalMessage);
13060 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
13061 rb_obj_call_init(vresult, argc, argv);
13062 #endif
13063 return vresult;
13064 }
13065
13066
13067
13068 /*
13069 Document-method: Opal::OpalMessage.new
13070
13071 call-seq:
13072 OpalMessage.new
13073
13074 Class constructor.
13075
13076 */
13077 SWIGINTERN VALUE
13078 _wrap_new_OpalMessage(int argc, VALUE *argv, VALUE self) {
13079 OpalMessage *result = 0 ;
13080
13081 if ((argc < 0) || (argc > 0)) {
13082 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13083 }
13084 result = (OpalMessage *)new OpalMessage();
13085 DATA_PTR(self) = result;
13086 return self;
13087 fail:
13088 return Qnil;
13089 }
13090
13091
13092 SWIGINTERN void
13093 free_OpalMessage(OpalMessage *arg1) {
13094 delete arg1;
13095 }
13096
13097
13098 /*
13099 Document-class: Opal::OpalMessage_m_param
13100
13101 Proxy of C++ Opal::OpalMessage_m_param class
13102
13103
13104 */
13105 swig_class SwigClassOpalMessage_m_param;
13106
13107
13108 /*
13109 Document-method: Opal::OpalMessage_m_param.m_commandError
13110
13111 call-seq:
13112 m_commandError -> char
13113
13114 Get value of attribute.
13115
13116 */
13117
13118 /*
13119 Document-method: Opal::OpalMessage_m_param.m_commandError=
13120
13121 call-seq:
13122 m_commandError=(x) -> char
13123
13124 Set new value for attribute.
13125
13126 */
13127 SWIGINTERN VALUE
13128 _wrap_OpalMessage_m_param_m_commandError_set(int argc, VALUE *argv, VALUE self) {
13129 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13130 char *arg2 = (char *) 0 ;
13131 void *argp1 = 0 ;
13132 int res1 = 0 ;
13133 int res2 ;
13134 char *buf2 = 0 ;
13135 int alloc2 = 0 ;
13136
13137 if ((argc < 1) || (argc > 1)) {
13138 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13139 }
13140 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13141 if (!SWIG_IsOK(res1)) {
13142 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_commandError", 1, self ));
13143 }
13144 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13145 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
13146 if (!SWIG_IsOK(res2)) {
13147 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_commandError", 2, argv[0] ));
13148 }
13149 arg2 = reinterpret_cast< char * >(buf2);
13150 if (arg2) {
13151 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
13152 arg1->m_commandError = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
13153 } else {
13154 arg1->m_commandError = 0;
13155 }
13156 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
13157 return Qnil;
13158 fail:
13159 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
13160 return Qnil;
13161 }
13162
13163
13164 SWIGINTERN VALUE
13165 _wrap_OpalMessage_m_param_m_commandError_get(int argc, VALUE *argv, VALUE self) {
13166 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13167 void *argp1 = 0 ;
13168 int res1 = 0 ;
13169 char *result = 0 ;
13170 VALUE vresult = Qnil;
13171
13172 if ((argc < 0) || (argc > 0)) {
13173 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13174 }
13175 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13176 if (!SWIG_IsOK(res1)) {
13177 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_commandError", 1, self ));
13178 }
13179 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13180 result = (char *) ((arg1)->m_commandError);
13181 vresult = SWIG_FromCharPtr((const char *)result);
13182 return vresult;
13183 fail:
13184 return Qnil;
13185 }
13186
13187
13188
13189 /*
13190 Document-method: Opal::OpalMessage_m_param.m_general
13191
13192 call-seq:
13193 m_general -> OpalParamGeneral
13194
13195 Get value of attribute.
13196
13197 */
13198
13199 /*
13200 Document-method: Opal::OpalMessage_m_param.m_general=
13201
13202 call-seq:
13203 m_general=(x) -> OpalParamGeneral
13204
13205 Set new value for attribute.
13206
13207 */
13208 SWIGINTERN VALUE
13209 _wrap_OpalMessage_m_param_m_general_set(int argc, VALUE *argv, VALUE self) {
13210 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13211 OpalParamGeneral *arg2 = (OpalParamGeneral *) 0 ;
13212 void *argp1 = 0 ;
13213 int res1 = 0 ;
13214 void *argp2 = 0 ;
13215 int res2 = 0 ;
13216
13217 if ((argc < 1) || (argc > 1)) {
13218 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13219 }
13220 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13221 if (!SWIG_IsOK(res1)) {
13222 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_general", 1, self ));
13223 }
13224 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13225 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
13226 if (!SWIG_IsOK(res2)) {
13227 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalParamGeneral *","m_general", 2, argv[0] ));
13228 }
13229 arg2 = reinterpret_cast< OpalParamGeneral * >(argp2);
13230 if (arg1) (arg1)->m_general = *arg2;
13231 return Qnil;
13232 fail:
13233 return Qnil;
13234 }
13235
13236
13237 SWIGINTERN VALUE
13238 _wrap_OpalMessage_m_param_m_general_get(int argc, VALUE *argv, VALUE self) {
13239 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13240 void *argp1 = 0 ;
13241 int res1 = 0 ;
13242 OpalParamGeneral *result = 0 ;
13243 VALUE vresult = Qnil;
13244
13245 if ((argc < 0) || (argc > 0)) {
13246 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13247 }
13248 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13249 if (!SWIG_IsOK(res1)) {
13250 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_general", 1, self ));
13251 }
13252 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13253 result = (OpalParamGeneral *)& ((arg1)->m_general);
13254 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
13255 return vresult;
13256 fail:
13257 return Qnil;
13258 }
13259
13260
13261
13262 /*
13263 Document-method: Opal::OpalMessage_m_param.m_protocol
13264
13265 call-seq:
13266 m_protocol -> OpalParamProtocol
13267
13268 Get value of attribute.
13269
13270 */
13271
13272 /*
13273 Document-method: Opal::OpalMessage_m_param.m_protocol=
13274
13275 call-seq:
13276 m_protocol=(x) -> OpalParamProtocol
13277
13278 Set new value for attribute.
13279
13280 */
13281 SWIGINTERN VALUE
13282 _wrap_OpalMessage_m_param_m_protocol_set(int argc, VALUE *argv, VALUE self) {
13283 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13284 OpalParamProtocol *arg2 = (OpalParamProtocol *) 0 ;
13285 void *argp1 = 0 ;
13286 int res1 = 0 ;
13287 void *argp2 = 0 ;
13288 int res2 = 0 ;
13289
13290 if ((argc < 1) || (argc > 1)) {
13291 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13292 }
13293 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13294 if (!SWIG_IsOK(res1)) {
13295 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_protocol", 1, self ));
13296 }
13297 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13298 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
13299 if (!SWIG_IsOK(res2)) {
13300 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalParamProtocol *","m_protocol", 2, argv[0] ));
13301 }
13302 arg2 = reinterpret_cast< OpalParamProtocol * >(argp2);
13303 if (arg1) (arg1)->m_protocol = *arg2;
13304 return Qnil;
13305 fail:
13306 return Qnil;
13307 }
13308
13309
13310 SWIGINTERN VALUE
13311 _wrap_OpalMessage_m_param_m_protocol_get(int argc, VALUE *argv, VALUE self) {
13312 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13313 void *argp1 = 0 ;
13314 int res1 = 0 ;
13315 OpalParamProtocol *result = 0 ;
13316 VALUE vresult = Qnil;
13317
13318 if ((argc < 0) || (argc > 0)) {
13319 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13320 }
13321 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13322 if (!SWIG_IsOK(res1)) {
13323 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_protocol", 1, self ));
13324 }
13325 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13326 result = (OpalParamProtocol *)& ((arg1)->m_protocol);
13327 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
13328 return vresult;
13329 fail:
13330 return Qnil;
13331 }
13332
13333
13334
13335 /*
13336 Document-method: Opal::OpalMessage_m_param.m_registrationInfo
13337
13338 call-seq:
13339 m_registrationInfo -> OpalParamRegistration
13340
13341 Get value of attribute.
13342
13343 */
13344
13345 /*
13346 Document-method: Opal::OpalMessage_m_param.m_registrationInfo=
13347
13348 call-seq:
13349 m_registrationInfo=(x) -> OpalParamRegistration
13350
13351 Set new value for attribute.
13352
13353 */
13354 SWIGINTERN VALUE
13355 _wrap_OpalMessage_m_param_m_registrationInfo_set(int argc, VALUE *argv, VALUE self) {
13356 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13357 OpalParamRegistration *arg2 = (OpalParamRegistration *) 0 ;
13358 void *argp1 = 0 ;
13359 int res1 = 0 ;
13360 void *argp2 = 0 ;
13361 int res2 = 0 ;
13362
13363 if ((argc < 1) || (argc > 1)) {
13364 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13365 }
13366 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13367 if (!SWIG_IsOK(res1)) {
13368 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_registrationInfo", 1, self ));
13369 }
13370 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13371 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
13372 if (!SWIG_IsOK(res2)) {
13373 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalParamRegistration *","m_registrationInfo", 2, argv[0] ));
13374 }
13375 arg2 = reinterpret_cast< OpalParamRegistration * >(argp2);
13376 if (arg1) (arg1)->m_registrationInfo = *arg2;
13377 return Qnil;
13378 fail:
13379 return Qnil;
13380 }
13381
13382
13383 SWIGINTERN VALUE
13384 _wrap_OpalMessage_m_param_m_registrationInfo_get(int argc, VALUE *argv, VALUE self) {
13385 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13386 void *argp1 = 0 ;
13387 int res1 = 0 ;
13388 OpalParamRegistration *result = 0 ;
13389 VALUE vresult = Qnil;
13390
13391 if ((argc < 0) || (argc > 0)) {
13392 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13393 }
13394 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13395 if (!SWIG_IsOK(res1)) {
13396 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_registrationInfo", 1, self ));
13397 }
13398 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13399 result = (OpalParamRegistration *)& ((arg1)->m_registrationInfo);
13400 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
13401 return vresult;
13402 fail:
13403 return Qnil;
13404 }
13405
13406
13407
13408 /*
13409 Document-method: Opal::OpalMessage_m_param.m_registrationStatus
13410
13411 call-seq:
13412 m_registrationStatus -> OpalStatusRegistration
13413
13414 Get value of attribute.
13415
13416 */
13417
13418 /*
13419 Document-method: Opal::OpalMessage_m_param.m_registrationStatus=
13420
13421 call-seq:
13422 m_registrationStatus=(x) -> OpalStatusRegistration
13423
13424 Set new value for attribute.
13425
13426 */
13427 SWIGINTERN VALUE
13428 _wrap_OpalMessage_m_param_m_registrationStatus_set(int argc, VALUE *argv, VALUE self) {
13429 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13430 OpalStatusRegistration *arg2 = (OpalStatusRegistration *) 0 ;
13431 void *argp1 = 0 ;
13432 int res1 = 0 ;
13433 void *argp2 = 0 ;
13434 int res2 = 0 ;
13435
13436 if ((argc < 1) || (argc > 1)) {
13437 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13438 }
13439 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13440 if (!SWIG_IsOK(res1)) {
13441 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_registrationStatus", 1, self ));
13442 }
13443 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13444 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
13445 if (!SWIG_IsOK(res2)) {
13446 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalStatusRegistration *","m_registrationStatus", 2, argv[0] ));
13447 }
13448 arg2 = reinterpret_cast< OpalStatusRegistration * >(argp2);
13449 if (arg1) (arg1)->m_registrationStatus = *arg2;
13450 return Qnil;
13451 fail:
13452 return Qnil;
13453 }
13454
13455
13456 SWIGINTERN VALUE
13457 _wrap_OpalMessage_m_param_m_registrationStatus_get(int argc, VALUE *argv, VALUE self) {
13458 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13459 void *argp1 = 0 ;
13460 int res1 = 0 ;
13461 OpalStatusRegistration *result = 0 ;
13462 VALUE vresult = Qnil;
13463
13464 if ((argc < 0) || (argc > 0)) {
13465 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13466 }
13467 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13468 if (!SWIG_IsOK(res1)) {
13469 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_registrationStatus", 1, self ));
13470 }
13471 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13472 result = (OpalStatusRegistration *)& ((arg1)->m_registrationStatus);
13473 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
13474 return vresult;
13475 fail:
13476 return Qnil;
13477 }
13478
13479
13480
13481 /*
13482 Document-method: Opal::OpalMessage_m_param.m_callSetUp
13483
13484 call-seq:
13485 m_callSetUp -> OpalParamSetUpCall
13486
13487 Get value of attribute.
13488
13489 */
13490
13491 /*
13492 Document-method: Opal::OpalMessage_m_param.m_callSetUp=
13493
13494 call-seq:
13495 m_callSetUp=(x) -> OpalParamSetUpCall
13496
13497 Set new value for attribute.
13498
13499 */
13500 SWIGINTERN VALUE
13501 _wrap_OpalMessage_m_param_m_callSetUp_set(int argc, VALUE *argv, VALUE self) {
13502 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13503 OpalParamSetUpCall *arg2 = (OpalParamSetUpCall *) 0 ;
13504 void *argp1 = 0 ;
13505 int res1 = 0 ;
13506 void *argp2 = 0 ;
13507 int res2 = 0 ;
13508
13509 if ((argc < 1) || (argc > 1)) {
13510 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13511 }
13512 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13513 if (!SWIG_IsOK(res1)) {
13514 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_callSetUp", 1, self ));
13515 }
13516 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13517 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
13518 if (!SWIG_IsOK(res2)) {
13519 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalParamSetUpCall *","m_callSetUp", 2, argv[0] ));
13520 }
13521 arg2 = reinterpret_cast< OpalParamSetUpCall * >(argp2);
13522 if (arg1) (arg1)->m_callSetUp = *arg2;
13523 return Qnil;
13524 fail:
13525 return Qnil;
13526 }
13527
13528
13529 SWIGINTERN VALUE
13530 _wrap_OpalMessage_m_param_m_callSetUp_get(int argc, VALUE *argv, VALUE self) {
13531 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13532 void *argp1 = 0 ;
13533 int res1 = 0 ;
13534 OpalParamSetUpCall *result = 0 ;
13535 VALUE vresult = Qnil;
13536
13537 if ((argc < 0) || (argc > 0)) {
13538 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13539 }
13540 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13541 if (!SWIG_IsOK(res1)) {
13542 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_callSetUp", 1, self ));
13543 }
13544 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13545 result = (OpalParamSetUpCall *)& ((arg1)->m_callSetUp);
13546 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
13547 return vresult;
13548 fail:
13549 return Qnil;
13550 }
13551
13552
13553
13554 /*
13555 Document-method: Opal::OpalMessage_m_param.m_callToken
13556
13557 call-seq:
13558 m_callToken -> char
13559
13560 Get value of attribute.
13561
13562 */
13563
13564 /*
13565 Document-method: Opal::OpalMessage_m_param.m_callToken=
13566
13567 call-seq:
13568 m_callToken=(x) -> char
13569
13570 Set new value for attribute.
13571
13572 */
13573 SWIGINTERN VALUE
13574 _wrap_OpalMessage_m_param_m_callToken_set(int argc, VALUE *argv, VALUE self) {
13575 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13576 char *arg2 = (char *) 0 ;
13577 void *argp1 = 0 ;
13578 int res1 = 0 ;
13579 int res2 ;
13580 char *buf2 = 0 ;
13581 int alloc2 = 0 ;
13582
13583 if ((argc < 1) || (argc > 1)) {
13584 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13585 }
13586 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13587 if (!SWIG_IsOK(res1)) {
13588 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_callToken", 1, self ));
13589 }
13590 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13591 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
13592 if (!SWIG_IsOK(res2)) {
13593 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","m_callToken", 2, argv[0] ));
13594 }
13595 arg2 = reinterpret_cast< char * >(buf2);
13596 if (arg2) {
13597 size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
13598 arg1->m_callToken = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
13599 } else {
13600 arg1->m_callToken = 0;
13601 }
13602 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
13603 return Qnil;
13604 fail:
13605 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
13606 return Qnil;
13607 }
13608
13609
13610 SWIGINTERN VALUE
13611 _wrap_OpalMessage_m_param_m_callToken_get(int argc, VALUE *argv, VALUE self) {
13612 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13613 void *argp1 = 0 ;
13614 int res1 = 0 ;
13615 char *result = 0 ;
13616 VALUE vresult = Qnil;
13617
13618 if ((argc < 0) || (argc > 0)) {
13619 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13620 }
13621 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13622 if (!SWIG_IsOK(res1)) {
13623 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_callToken", 1, self ));
13624 }
13625 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13626 result = (char *) ((arg1)->m_callToken);
13627 vresult = SWIG_FromCharPtr((const char *)result);
13628 return vresult;
13629 fail:
13630 return Qnil;
13631 }
13632
13633
13634
13635 /*
13636 Document-method: Opal::OpalMessage_m_param.m_incomingCall
13637
13638 call-seq:
13639 m_incomingCall -> OpalStatusIncomingCall
13640
13641 Get value of attribute.
13642
13643 */
13644
13645 /*
13646 Document-method: Opal::OpalMessage_m_param.m_incomingCall=
13647
13648 call-seq:
13649 m_incomingCall=(x) -> OpalStatusIncomingCall
13650
13651 Set new value for attribute.
13652
13653 */
13654 SWIGINTERN VALUE
13655 _wrap_OpalMessage_m_param_m_incomingCall_set(int argc, VALUE *argv, VALUE self) {
13656 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13657 OpalStatusIncomingCall *arg2 = (OpalStatusIncomingCall *) 0 ;
13658 void *argp1 = 0 ;
13659 int res1 = 0 ;
13660 void *argp2 = 0 ;
13661 int res2 = 0 ;
13662
13663 if ((argc < 1) || (argc > 1)) {
13664 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13665 }
13666 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13667 if (!SWIG_IsOK(res1)) {
13668 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_incomingCall", 1, self ));
13669 }
13670 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13671 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
13672 if (!SWIG_IsOK(res2)) {
13673 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalStatusIncomingCall *","m_incomingCall", 2, argv[0] ));
13674 }
13675 arg2 = reinterpret_cast< OpalStatusIncomingCall * >(argp2);
13676 if (arg1) (arg1)->m_incomingCall = *arg2;
13677 return Qnil;
13678 fail:
13679 return Qnil;
13680 }
13681
13682
13683 SWIGINTERN VALUE
13684 _wrap_OpalMessage_m_param_m_incomingCall_get(int argc, VALUE *argv, VALUE self) {
13685 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13686 void *argp1 = 0 ;
13687 int res1 = 0 ;
13688 OpalStatusIncomingCall *result = 0 ;
13689 VALUE vresult = Qnil;
13690
13691 if ((argc < 0) || (argc > 0)) {
13692 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13693 }
13694 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13695 if (!SWIG_IsOK(res1)) {
13696 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_incomingCall", 1, self ));
13697 }
13698 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13699 result = (OpalStatusIncomingCall *)& ((arg1)->m_incomingCall);
13700 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
13701 return vresult;
13702 fail:
13703 return Qnil;
13704 }
13705
13706
13707
13708 /*
13709 Document-method: Opal::OpalMessage_m_param.m_answerCall
13710
13711 call-seq:
13712 m_answerCall -> OpalParamAnswerCall
13713
13714 Get value of attribute.
13715
13716 */
13717
13718 /*
13719 Document-method: Opal::OpalMessage_m_param.m_answerCall=
13720
13721 call-seq:
13722 m_answerCall=(x) -> OpalParamAnswerCall
13723
13724 Set new value for attribute.
13725
13726 */
13727 SWIGINTERN VALUE
13728 _wrap_OpalMessage_m_param_m_answerCall_set(int argc, VALUE *argv, VALUE self) {
13729 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13730 OpalParamAnswerCall *arg2 = (OpalParamAnswerCall *) 0 ;
13731 void *argp1 = 0 ;
13732 int res1 = 0 ;
13733 void *argp2 = 0 ;
13734 int res2 = 0 ;
13735
13736 if ((argc < 1) || (argc > 1)) {
13737 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13738 }
13739 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13740 if (!SWIG_IsOK(res1)) {
13741 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_answerCall", 1, self ));
13742 }
13743 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13744 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalParamAnswerCall, 0 | 0 );
13745 if (!SWIG_IsOK(res2)) {
13746 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalParamAnswerCall *","m_answerCall", 2, argv[0] ));
13747 }
13748 arg2 = reinterpret_cast< OpalParamAnswerCall * >(argp2);
13749 if (arg1) (arg1)->m_answerCall = *arg2;
13750 return Qnil;
13751 fail:
13752 return Qnil;
13753 }
13754
13755
13756 SWIGINTERN VALUE
13757 _wrap_OpalMessage_m_param_m_answerCall_get(int argc, VALUE *argv, VALUE self) {
13758 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13759 void *argp1 = 0 ;
13760 int res1 = 0 ;
13761 OpalParamAnswerCall *result = 0 ;
13762 VALUE vresult = Qnil;
13763
13764 if ((argc < 0) || (argc > 0)) {
13765 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13766 }
13767 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13768 if (!SWIG_IsOK(res1)) {
13769 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_answerCall", 1, self ));
13770 }
13771 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13772 result = (OpalParamAnswerCall *)& ((arg1)->m_answerCall);
13773 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamAnswerCall, 0 | 0 );
13774 return vresult;
13775 fail:
13776 return Qnil;
13777 }
13778
13779
13780
13781 /*
13782 Document-method: Opal::OpalMessage_m_param.m_userInput
13783
13784 call-seq:
13785 m_userInput -> OpalStatusUserInput
13786
13787 Get value of attribute.
13788
13789 */
13790
13791 /*
13792 Document-method: Opal::OpalMessage_m_param.m_userInput=
13793
13794 call-seq:
13795 m_userInput=(x) -> OpalStatusUserInput
13796
13797 Set new value for attribute.
13798
13799 */
13800 SWIGINTERN VALUE
13801 _wrap_OpalMessage_m_param_m_userInput_set(int argc, VALUE *argv, VALUE self) {
13802 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13803 OpalStatusUserInput *arg2 = (OpalStatusUserInput *) 0 ;
13804 void *argp1 = 0 ;
13805 int res1 = 0 ;
13806 void *argp2 = 0 ;
13807 int res2 = 0 ;
13808
13809 if ((argc < 1) || (argc > 1)) {
13810 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13811 }
13812 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13813 if (!SWIG_IsOK(res1)) {
13814 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_userInput", 1, self ));
13815 }
13816 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13817 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalStatusUserInput, 0 | 0 );
13818 if (!SWIG_IsOK(res2)) {
13819 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalStatusUserInput *","m_userInput", 2, argv[0] ));
13820 }
13821 arg2 = reinterpret_cast< OpalStatusUserInput * >(argp2);
13822 if (arg1) (arg1)->m_userInput = *arg2;
13823 return Qnil;
13824 fail:
13825 return Qnil;
13826 }
13827
13828
13829 SWIGINTERN VALUE
13830 _wrap_OpalMessage_m_param_m_userInput_get(int argc, VALUE *argv, VALUE self) {
13831 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13832 void *argp1 = 0 ;
13833 int res1 = 0 ;
13834 OpalStatusUserInput *result = 0 ;
13835 VALUE vresult = Qnil;
13836
13837 if ((argc < 0) || (argc > 0)) {
13838 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13839 }
13840 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13841 if (!SWIG_IsOK(res1)) {
13842 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_userInput", 1, self ));
13843 }
13844 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13845 result = (OpalStatusUserInput *)& ((arg1)->m_userInput);
13846 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusUserInput, 0 | 0 );
13847 return vresult;
13848 fail:
13849 return Qnil;
13850 }
13851
13852
13853
13854 /*
13855 Document-method: Opal::OpalMessage_m_param.m_messageWaiting
13856
13857 call-seq:
13858 m_messageWaiting -> OpalStatusMessageWaiting
13859
13860 Get value of attribute.
13861
13862 */
13863
13864 /*
13865 Document-method: Opal::OpalMessage_m_param.m_messageWaiting=
13866
13867 call-seq:
13868 m_messageWaiting=(x) -> OpalStatusMessageWaiting
13869
13870 Set new value for attribute.
13871
13872 */
13873 SWIGINTERN VALUE
13874 _wrap_OpalMessage_m_param_m_messageWaiting_set(int argc, VALUE *argv, VALUE self) {
13875 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13876 OpalStatusMessageWaiting *arg2 = (OpalStatusMessageWaiting *) 0 ;
13877 void *argp1 = 0 ;
13878 int res1 = 0 ;
13879 void *argp2 = 0 ;
13880 int res2 = 0 ;
13881
13882 if ((argc < 1) || (argc > 1)) {
13883 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13884 }
13885 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13886 if (!SWIG_IsOK(res1)) {
13887 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_messageWaiting", 1, self ));
13888 }
13889 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13890 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalStatusMessageWaiting, 0 | 0 );
13891 if (!SWIG_IsOK(res2)) {
13892 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalStatusMessageWaiting *","m_messageWaiting", 2, argv[0] ));
13893 }
13894 arg2 = reinterpret_cast< OpalStatusMessageWaiting * >(argp2);
13895 if (arg1) (arg1)->m_messageWaiting = *arg2;
13896 return Qnil;
13897 fail:
13898 return Qnil;
13899 }
13900
13901
13902 SWIGINTERN VALUE
13903 _wrap_OpalMessage_m_param_m_messageWaiting_get(int argc, VALUE *argv, VALUE self) {
13904 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13905 void *argp1 = 0 ;
13906 int res1 = 0 ;
13907 OpalStatusMessageWaiting *result = 0 ;
13908 VALUE vresult = Qnil;
13909
13910 if ((argc < 0) || (argc > 0)) {
13911 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13912 }
13913 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13914 if (!SWIG_IsOK(res1)) {
13915 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_messageWaiting", 1, self ));
13916 }
13917 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13918 result = (OpalStatusMessageWaiting *)& ((arg1)->m_messageWaiting);
13919 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusMessageWaiting, 0 | 0 );
13920 return vresult;
13921 fail:
13922 return Qnil;
13923 }
13924
13925
13926
13927 /*
13928 Document-method: Opal::OpalMessage_m_param.m_lineAppearance
13929
13930 call-seq:
13931 m_lineAppearance -> OpalStatusLineAppearance
13932
13933 Get value of attribute.
13934
13935 */
13936
13937 /*
13938 Document-method: Opal::OpalMessage_m_param.m_lineAppearance=
13939
13940 call-seq:
13941 m_lineAppearance=(x) -> OpalStatusLineAppearance
13942
13943 Set new value for attribute.
13944
13945 */
13946 SWIGINTERN VALUE
13947 _wrap_OpalMessage_m_param_m_lineAppearance_set(int argc, VALUE *argv, VALUE self) {
13948 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13949 OpalStatusLineAppearance *arg2 = (OpalStatusLineAppearance *) 0 ;
13950 void *argp1 = 0 ;
13951 int res1 = 0 ;
13952 void *argp2 = 0 ;
13953 int res2 = 0 ;
13954
13955 if ((argc < 1) || (argc > 1)) {
13956 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13957 }
13958 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13959 if (!SWIG_IsOK(res1)) {
13960 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_lineAppearance", 1, self ));
13961 }
13962 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13963 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
13964 if (!SWIG_IsOK(res2)) {
13965 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalStatusLineAppearance *","m_lineAppearance", 2, argv[0] ));
13966 }
13967 arg2 = reinterpret_cast< OpalStatusLineAppearance * >(argp2);
13968 if (arg1) (arg1)->m_lineAppearance = *arg2;
13969 return Qnil;
13970 fail:
13971 return Qnil;
13972 }
13973
13974
13975 SWIGINTERN VALUE
13976 _wrap_OpalMessage_m_param_m_lineAppearance_get(int argc, VALUE *argv, VALUE self) {
13977 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
13978 void *argp1 = 0 ;
13979 int res1 = 0 ;
13980 OpalStatusLineAppearance *result = 0 ;
13981 VALUE vresult = Qnil;
13982
13983 if ((argc < 0) || (argc > 0)) {
13984 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13985 }
13986 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
13987 if (!SWIG_IsOK(res1)) {
13988 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_lineAppearance", 1, self ));
13989 }
13990 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
13991 result = (OpalStatusLineAppearance *)& ((arg1)->m_lineAppearance);
13992 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
13993 return vresult;
13994 fail:
13995 return Qnil;
13996 }
13997
13998
13999
14000 /*
14001 Document-method: Opal::OpalMessage_m_param.m_callCleared
14002
14003 call-seq:
14004 m_callCleared -> OpalStatusCallCleared
14005
14006 Get value of attribute.
14007
14008 */
14009
14010 /*
14011 Document-method: Opal::OpalMessage_m_param.m_callCleared=
14012
14013 call-seq:
14014 m_callCleared=(x) -> OpalStatusCallCleared
14015
14016 Set new value for attribute.
14017
14018 */
14019 SWIGINTERN VALUE
14020 _wrap_OpalMessage_m_param_m_callCleared_set(int argc, VALUE *argv, VALUE self) {
14021 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14022 OpalStatusCallCleared *arg2 = (OpalStatusCallCleared *) 0 ;
14023 void *argp1 = 0 ;
14024 int res1 = 0 ;
14025 void *argp2 = 0 ;
14026 int res2 = 0 ;
14027
14028 if ((argc < 1) || (argc > 1)) {
14029 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14030 }
14031 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14032 if (!SWIG_IsOK(res1)) {
14033 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_callCleared", 1, self ));
14034 }
14035 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14036 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalStatusCallCleared, 0 | 0 );
14037 if (!SWIG_IsOK(res2)) {
14038 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalStatusCallCleared *","m_callCleared", 2, argv[0] ));
14039 }
14040 arg2 = reinterpret_cast< OpalStatusCallCleared * >(argp2);
14041 if (arg1) (arg1)->m_callCleared = *arg2;
14042 return Qnil;
14043 fail:
14044 return Qnil;
14045 }
14046
14047
14048 SWIGINTERN VALUE
14049 _wrap_OpalMessage_m_param_m_callCleared_get(int argc, VALUE *argv, VALUE self) {
14050 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14051 void *argp1 = 0 ;
14052 int res1 = 0 ;
14053 OpalStatusCallCleared *result = 0 ;
14054 VALUE vresult = Qnil;
14055
14056 if ((argc < 0) || (argc > 0)) {
14057 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14058 }
14059 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14060 if (!SWIG_IsOK(res1)) {
14061 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_callCleared", 1, self ));
14062 }
14063 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14064 result = (OpalStatusCallCleared *)& ((arg1)->m_callCleared);
14065 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusCallCleared, 0 | 0 );
14066 return vresult;
14067 fail:
14068 return Qnil;
14069 }
14070
14071
14072
14073 /*
14074 Document-method: Opal::OpalMessage_m_param.m_clearCall
14075
14076 call-seq:
14077 m_clearCall -> OpalParamCallCleared
14078
14079 Get value of attribute.
14080
14081 */
14082
14083 /*
14084 Document-method: Opal::OpalMessage_m_param.m_clearCall=
14085
14086 call-seq:
14087 m_clearCall=(x) -> OpalParamCallCleared
14088
14089 Set new value for attribute.
14090
14091 */
14092 SWIGINTERN VALUE
14093 _wrap_OpalMessage_m_param_m_clearCall_set(int argc, VALUE *argv, VALUE self) {
14094 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14095 OpalParamCallCleared *arg2 = (OpalParamCallCleared *) 0 ;
14096 void *argp1 = 0 ;
14097 int res1 = 0 ;
14098 void *argp2 = 0 ;
14099 int res2 = 0 ;
14100
14101 if ((argc < 1) || (argc > 1)) {
14102 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14103 }
14104 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14105 if (!SWIG_IsOK(res1)) {
14106 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_clearCall", 1, self ));
14107 }
14108 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14109 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalParamCallCleared, 0 | 0 );
14110 if (!SWIG_IsOK(res2)) {
14111 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalParamCallCleared *","m_clearCall", 2, argv[0] ));
14112 }
14113 arg2 = reinterpret_cast< OpalParamCallCleared * >(argp2);
14114 if (arg1) (arg1)->m_clearCall = *arg2;
14115 return Qnil;
14116 fail:
14117 return Qnil;
14118 }
14119
14120
14121 SWIGINTERN VALUE
14122 _wrap_OpalMessage_m_param_m_clearCall_get(int argc, VALUE *argv, VALUE self) {
14123 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14124 void *argp1 = 0 ;
14125 int res1 = 0 ;
14126 OpalParamCallCleared *result = 0 ;
14127 VALUE vresult = Qnil;
14128
14129 if ((argc < 0) || (argc > 0)) {
14130 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14131 }
14132 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14133 if (!SWIG_IsOK(res1)) {
14134 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_clearCall", 1, self ));
14135 }
14136 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14137 result = (OpalParamCallCleared *)& ((arg1)->m_clearCall);
14138 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamCallCleared, 0 | 0 );
14139 return vresult;
14140 fail:
14141 return Qnil;
14142 }
14143
14144
14145
14146 /*
14147 Document-method: Opal::OpalMessage_m_param.m_mediaStream
14148
14149 call-seq:
14150 m_mediaStream -> OpalStatusMediaStream
14151
14152 Get value of attribute.
14153
14154 */
14155
14156 /*
14157 Document-method: Opal::OpalMessage_m_param.m_mediaStream=
14158
14159 call-seq:
14160 m_mediaStream=(x) -> OpalStatusMediaStream
14161
14162 Set new value for attribute.
14163
14164 */
14165 SWIGINTERN VALUE
14166 _wrap_OpalMessage_m_param_m_mediaStream_set(int argc, VALUE *argv, VALUE self) {
14167 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14168 OpalStatusMediaStream *arg2 = (OpalStatusMediaStream *) 0 ;
14169 void *argp1 = 0 ;
14170 int res1 = 0 ;
14171 void *argp2 = 0 ;
14172 int res2 = 0 ;
14173
14174 if ((argc < 1) || (argc > 1)) {
14175 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14176 }
14177 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14178 if (!SWIG_IsOK(res1)) {
14179 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_mediaStream", 1, self ));
14180 }
14181 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14182 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
14183 if (!SWIG_IsOK(res2)) {
14184 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalStatusMediaStream *","m_mediaStream", 2, argv[0] ));
14185 }
14186 arg2 = reinterpret_cast< OpalStatusMediaStream * >(argp2);
14187 if (arg1) (arg1)->m_mediaStream = *arg2;
14188 return Qnil;
14189 fail:
14190 return Qnil;
14191 }
14192
14193
14194 SWIGINTERN VALUE
14195 _wrap_OpalMessage_m_param_m_mediaStream_get(int argc, VALUE *argv, VALUE self) {
14196 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14197 void *argp1 = 0 ;
14198 int res1 = 0 ;
14199 OpalStatusMediaStream *result = 0 ;
14200 VALUE vresult = Qnil;
14201
14202 if ((argc < 0) || (argc > 0)) {
14203 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14204 }
14205 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14206 if (!SWIG_IsOK(res1)) {
14207 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_mediaStream", 1, self ));
14208 }
14209 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14210 result = (OpalStatusMediaStream *)& ((arg1)->m_mediaStream);
14211 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
14212 return vresult;
14213 fail:
14214 return Qnil;
14215 }
14216
14217
14218
14219 /*
14220 Document-method: Opal::OpalMessage_m_param.m_setUserData
14221
14222 call-seq:
14223 m_setUserData -> OpalParamSetUserData
14224
14225 Get value of attribute.
14226
14227 */
14228
14229 /*
14230 Document-method: Opal::OpalMessage_m_param.m_setUserData=
14231
14232 call-seq:
14233 m_setUserData=(x) -> OpalParamSetUserData
14234
14235 Set new value for attribute.
14236
14237 */
14238 SWIGINTERN VALUE
14239 _wrap_OpalMessage_m_param_m_setUserData_set(int argc, VALUE *argv, VALUE self) {
14240 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14241 OpalParamSetUserData *arg2 = (OpalParamSetUserData *) 0 ;
14242 void *argp1 = 0 ;
14243 int res1 = 0 ;
14244 void *argp2 = 0 ;
14245 int res2 = 0 ;
14246
14247 if ((argc < 1) || (argc > 1)) {
14248 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14249 }
14250 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14251 if (!SWIG_IsOK(res1)) {
14252 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_setUserData", 1, self ));
14253 }
14254 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14255 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalParamSetUserData, 0 | 0 );
14256 if (!SWIG_IsOK(res2)) {
14257 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalParamSetUserData *","m_setUserData", 2, argv[0] ));
14258 }
14259 arg2 = reinterpret_cast< OpalParamSetUserData * >(argp2);
14260 if (arg1) (arg1)->m_setUserData = *arg2;
14261 return Qnil;
14262 fail:
14263 return Qnil;
14264 }
14265
14266
14267 SWIGINTERN VALUE
14268 _wrap_OpalMessage_m_param_m_setUserData_get(int argc, VALUE *argv, VALUE self) {
14269 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14270 void *argp1 = 0 ;
14271 int res1 = 0 ;
14272 OpalParamSetUserData *result = 0 ;
14273 VALUE vresult = Qnil;
14274
14275 if ((argc < 0) || (argc > 0)) {
14276 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14277 }
14278 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14279 if (!SWIG_IsOK(res1)) {
14280 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_setUserData", 1, self ));
14281 }
14282 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14283 result = (OpalParamSetUserData *)& ((arg1)->m_setUserData);
14284 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamSetUserData, 0 | 0 );
14285 return vresult;
14286 fail:
14287 return Qnil;
14288 }
14289
14290
14291
14292 /*
14293 Document-method: Opal::OpalMessage_m_param.m_recording
14294
14295 call-seq:
14296 m_recording -> OpalParamRecording
14297
14298 Get value of attribute.
14299
14300 */
14301
14302 /*
14303 Document-method: Opal::OpalMessage_m_param.m_recording=
14304
14305 call-seq:
14306 m_recording=(x) -> OpalParamRecording
14307
14308 Set new value for attribute.
14309
14310 */
14311 SWIGINTERN VALUE
14312 _wrap_OpalMessage_m_param_m_recording_set(int argc, VALUE *argv, VALUE self) {
14313 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14314 OpalParamRecording *arg2 = (OpalParamRecording *) 0 ;
14315 void *argp1 = 0 ;
14316 int res1 = 0 ;
14317 void *argp2 = 0 ;
14318 int res2 = 0 ;
14319
14320 if ((argc < 1) || (argc > 1)) {
14321 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14322 }
14323 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14324 if (!SWIG_IsOK(res1)) {
14325 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_recording", 1, self ));
14326 }
14327 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14328 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalParamRecording, 0 | 0 );
14329 if (!SWIG_IsOK(res2)) {
14330 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalParamRecording *","m_recording", 2, argv[0] ));
14331 }
14332 arg2 = reinterpret_cast< OpalParamRecording * >(argp2);
14333 if (arg1) (arg1)->m_recording = *arg2;
14334 return Qnil;
14335 fail:
14336 return Qnil;
14337 }
14338
14339
14340 SWIGINTERN VALUE
14341 _wrap_OpalMessage_m_param_m_recording_get(int argc, VALUE *argv, VALUE self) {
14342 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14343 void *argp1 = 0 ;
14344 int res1 = 0 ;
14345 OpalParamRecording *result = 0 ;
14346 VALUE vresult = Qnil;
14347
14348 if ((argc < 0) || (argc > 0)) {
14349 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14350 }
14351 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14352 if (!SWIG_IsOK(res1)) {
14353 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_recording", 1, self ));
14354 }
14355 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14356 result = (OpalParamRecording *)& ((arg1)->m_recording);
14357 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamRecording, 0 | 0 );
14358 return vresult;
14359 fail:
14360 return Qnil;
14361 }
14362
14363
14364
14365 /*
14366 Document-method: Opal::OpalMessage_m_param.m_transferStatus
14367
14368 call-seq:
14369 m_transferStatus -> OpalStatusTransferCall
14370
14371 Get value of attribute.
14372
14373 */
14374
14375 /*
14376 Document-method: Opal::OpalMessage_m_param.m_transferStatus=
14377
14378 call-seq:
14379 m_transferStatus=(x) -> OpalStatusTransferCall
14380
14381 Set new value for attribute.
14382
14383 */
14384 SWIGINTERN VALUE
14385 _wrap_OpalMessage_m_param_m_transferStatus_set(int argc, VALUE *argv, VALUE self) {
14386 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14387 OpalStatusTransferCall *arg2 = (OpalStatusTransferCall *) 0 ;
14388 void *argp1 = 0 ;
14389 int res1 = 0 ;
14390 void *argp2 = 0 ;
14391 int res2 = 0 ;
14392
14393 if ((argc < 1) || (argc > 1)) {
14394 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14395 }
14396 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14397 if (!SWIG_IsOK(res1)) {
14398 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_transferStatus", 1, self ));
14399 }
14400 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14401 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalStatusTransferCall, 0 | 0 );
14402 if (!SWIG_IsOK(res2)) {
14403 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalStatusTransferCall *","m_transferStatus", 2, argv[0] ));
14404 }
14405 arg2 = reinterpret_cast< OpalStatusTransferCall * >(argp2);
14406 if (arg1) (arg1)->m_transferStatus = *arg2;
14407 return Qnil;
14408 fail:
14409 return Qnil;
14410 }
14411
14412
14413 SWIGINTERN VALUE
14414 _wrap_OpalMessage_m_param_m_transferStatus_get(int argc, VALUE *argv, VALUE self) {
14415 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14416 void *argp1 = 0 ;
14417 int res1 = 0 ;
14418 OpalStatusTransferCall *result = 0 ;
14419 VALUE vresult = Qnil;
14420
14421 if ((argc < 0) || (argc > 0)) {
14422 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14423 }
14424 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14425 if (!SWIG_IsOK(res1)) {
14426 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_transferStatus", 1, self ));
14427 }
14428 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14429 result = (OpalStatusTransferCall *)& ((arg1)->m_transferStatus);
14430 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusTransferCall, 0 | 0 );
14431 return vresult;
14432 fail:
14433 return Qnil;
14434 }
14435
14436
14437
14438 /*
14439 Document-method: Opal::OpalMessage_m_param.m_ivrStatus
14440
14441 call-seq:
14442 m_ivrStatus -> OpalStatusIVR
14443
14444 Get value of attribute.
14445
14446 */
14447
14448 /*
14449 Document-method: Opal::OpalMessage_m_param.m_ivrStatus=
14450
14451 call-seq:
14452 m_ivrStatus=(x) -> OpalStatusIVR
14453
14454 Set new value for attribute.
14455
14456 */
14457 SWIGINTERN VALUE
14458 _wrap_OpalMessage_m_param_m_ivrStatus_set(int argc, VALUE *argv, VALUE self) {
14459 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14460 OpalStatusIVR *arg2 = (OpalStatusIVR *) 0 ;
14461 void *argp1 = 0 ;
14462 int res1 = 0 ;
14463 void *argp2 = 0 ;
14464 int res2 = 0 ;
14465
14466 if ((argc < 1) || (argc > 1)) {
14467 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14468 }
14469 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14470 if (!SWIG_IsOK(res1)) {
14471 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_ivrStatus", 1, self ));
14472 }
14473 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14474 res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OpalStatusIVR, 0 | 0 );
14475 if (!SWIG_IsOK(res2)) {
14476 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalStatusIVR *","m_ivrStatus", 2, argv[0] ));
14477 }
14478 arg2 = reinterpret_cast< OpalStatusIVR * >(argp2);
14479 if (arg1) (arg1)->m_ivrStatus = *arg2;
14480 return Qnil;
14481 fail:
14482 return Qnil;
14483 }
14484
14485
14486 SWIGINTERN VALUE
14487 _wrap_OpalMessage_m_param_m_ivrStatus_get(int argc, VALUE *argv, VALUE self) {
14488 OpalMessage_m_param *arg1 = (OpalMessage_m_param *) 0 ;
14489 void *argp1 = 0 ;
14490 int res1 = 0 ;
14491 OpalStatusIVR *result = 0 ;
14492 VALUE vresult = Qnil;
14493
14494 if ((argc < 0) || (argc > 0)) {
14495 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14496 }
14497 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessage_m_param, 0 | 0 );
14498 if (!SWIG_IsOK(res1)) {
14499 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessage_m_param *","m_ivrStatus", 1, self ));
14500 }
14501 arg1 = reinterpret_cast< OpalMessage_m_param * >(argp1);
14502 result = (OpalStatusIVR *)& ((arg1)->m_ivrStatus);
14503 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusIVR, 0 | 0 );
14504 return vresult;
14505 fail:
14506 return Qnil;
14507 }
14508
14509
14510 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
14511 SWIGINTERN VALUE
14512 _wrap_OpalMessage_m_param_allocate(VALUE self) {
14513 #else
14514 SWIGINTERN VALUE
14515 _wrap_OpalMessage_m_param_allocate(int argc, VALUE *argv, VALUE self) {
14516 #endif
14517
14518
14519 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalMessage_m_param);
14520 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
14521 rb_obj_call_init(vresult, argc, argv);
14522 #endif
14523 return vresult;
14524 }
14525
14526
14527
14528 /*
14529 Document-method: Opal::OpalMessage_m_param.new
14530
14531 call-seq:
14532 OpalMessage_m_param.new
14533
14534 Class constructor.
14535
14536 */
14537 SWIGINTERN VALUE
14538 _wrap_new_OpalMessage_m_param(int argc, VALUE *argv, VALUE self) {
14539 OpalMessage_m_param *result = 0 ;
14540
14541 if ((argc < 0) || (argc > 0)) {
14542 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14543 }
14544 result = (OpalMessage_m_param *)new OpalMessage_m_param();
14545 DATA_PTR(self) = result;
14546 return self;
14547 fail:
14548 return Qnil;
14549 }
14550
14551
14552 SWIGINTERN void
14553 free_OpalMessage_m_param(OpalMessage_m_param *arg1) {
14554 delete arg1;
14555 }
14556
14557
14558 /*
14559 Document-class: Opal::OpalMessagePtr
14560
14561 Proxy of C++ Opal::OpalMessagePtr class
14562
14563
14564 */
14565 swig_class SwigClassOpalMessagePtr;
14566
14567
14568 /*
14569 Document-method: Opal::OpalMessagePtr.new
14570
14571 call-seq:
14572 OpalMessagePtr.new(OpalMessageType type=OpalIndCommandError)
14573 OpalMessagePtr.new
14574
14575 Class constructor.
14576
14577 */
14578 SWIGINTERN VALUE
14579 _wrap_new_OpalMessagePtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
14580 OpalMessageType arg1 ;
14581 int val1 ;
14582 int ecode1 = 0 ;
14583 OpalMessagePtr *result = 0 ;
14584
14585 if ((argc < 1) || (argc > 1)) {
14586 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14587 }
14588 ecode1 = SWIG_AsVal_int(argv[0], &val1);
14589 if (!SWIG_IsOK(ecode1)) {
14590 SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "OpalMessageType","OpalMessagePtr", 1, argv[0] ));
14591 }
14592 arg1 = static_cast< OpalMessageType >(val1);
14593 result = (OpalMessagePtr *)new OpalMessagePtr(arg1);
14594 DATA_PTR(self) = result;
14595 return self;
14596 fail:
14597 return Qnil;
14598 }
14599
14600
14601 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
14602 SWIGINTERN VALUE
14603 _wrap_OpalMessagePtr_allocate(VALUE self) {
14604 #else
14605 SWIGINTERN VALUE
14606 _wrap_OpalMessagePtr_allocate(int argc, VALUE *argv, VALUE self) {
14607 #endif
14608
14609
14610 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalMessagePtr);
14611 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
14612 rb_obj_call_init(vresult, argc, argv);
14613 #endif
14614 return vresult;
14615 }
14616
14617
14618 SWIGINTERN VALUE
14619 _wrap_new_OpalMessagePtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
14620 OpalMessagePtr *result = 0 ;
14621
14622 if ((argc < 0) || (argc > 0)) {
14623 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14624 }
14625 result = (OpalMessagePtr *)new OpalMessagePtr();
14626 DATA_PTR(self) = result;
14627 return self;
14628 fail:
14629 return Qnil;
14630 }
14631
14632
14633 SWIGINTERN VALUE _wrap_new_OpalMessagePtr(int nargs, VALUE *args, VALUE self) {
14634 int argc;
14635 VALUE argv[1];
14636 int ii;
14637
14638 argc = nargs;
14639 if (argc > 1) SWIG_fail;
14640 for (ii = 0; (ii < argc); ++ii) {
14641 argv[ii] = args[ii];
14642 }
14643 if (argc == 0) {
14644 return _wrap_new_OpalMessagePtr__SWIG_1(nargs, args, self);
14645 }
14646 if (argc == 1) {
14647 int _v;
14648 {
14649 int res = SWIG_AsVal_int(argv[0], NULL);
14650 _v = SWIG_CheckState(res);
14651 }
14652 if (_v) {
14653 return _wrap_new_OpalMessagePtr__SWIG_0(nargs, args, self);
14654 }
14655 }
14656
14657 fail:
14658 Ruby_Format_OverloadedError( argc, 1, "OpalMessagePtr.new",
14659 " OpalMessagePtr.new(OpalMessageType type)\n"
14660 " OpalMessagePtr.new()\n");
14661
14662 return Qnil;
14663 }
14664
14665
14666 SWIGINTERN void
14667 free_OpalMessagePtr(OpalMessagePtr *arg1) {
14668 delete arg1;
14669 }
14670
14671
14672 /*
14673 Document-method: Opal::OpalMessagePtr.GetType
14674
14675 call-seq:
14676 GetType -> int
14677
14678 An instance method.
14679
14680 */
14681 SWIGINTERN VALUE
14682 _wrap_OpalMessagePtr_GetType(int argc, VALUE *argv, VALUE self) {
14683 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
14684 void *argp1 = 0 ;
14685 int res1 = 0 ;
14686 OpalMessageType result;
14687 VALUE vresult = Qnil;
14688
14689 if ((argc < 0) || (argc > 0)) {
14690 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14691 }
14692 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
14693 if (!SWIG_IsOK(res1)) {
14694 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetType", 1, self ));
14695 }
14696 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
14697 result = (OpalMessageType)((OpalMessagePtr const *)arg1)->GetType();
14698 vresult = SWIG_From_int(static_cast< int >(result));
14699 return vresult;
14700 fail:
14701 return Qnil;
14702 }
14703
14704
14705
14706 /*
14707 Document-method: Opal::OpalMessagePtr.SetType
14708
14709 call-seq:
14710 SetType(OpalMessageType type)
14711
14712 An instance method.
14713
14714 */
14715 SWIGINTERN VALUE
14716 _wrap_OpalMessagePtr_SetType(int argc, VALUE *argv, VALUE self) {
14717 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
14718 OpalMessageType arg2 ;
14719 void *argp1 = 0 ;
14720 int res1 = 0 ;
14721 int val2 ;
14722 int ecode2 = 0 ;
14723
14724 if ((argc < 1) || (argc > 1)) {
14725 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14726 }
14727 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
14728 if (!SWIG_IsOK(res1)) {
14729 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr *","SetType", 1, self ));
14730 }
14731 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
14732 ecode2 = SWIG_AsVal_int(argv[0], &val2);
14733 if (!SWIG_IsOK(ecode2)) {
14734 SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "OpalMessageType","SetType", 2, argv[0] ));
14735 }
14736 arg2 = static_cast< OpalMessageType >(val2);
14737 (arg1)->SetType(arg2);
14738 return Qnil;
14739 fail:
14740 return Qnil;
14741 }
14742
14743
14744
14745 /*
14746 Document-method: Opal::OpalMessagePtr.GetCallToken
14747
14748 call-seq:
14749 GetCallToken -> char
14750
14751 An instance method.
14752
14753 */
14754 SWIGINTERN VALUE
14755 _wrap_OpalMessagePtr_GetCallToken(int argc, VALUE *argv, VALUE self) {
14756 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
14757 void *argp1 = 0 ;
14758 int res1 = 0 ;
14759 char *result = 0 ;
14760 VALUE vresult = Qnil;
14761
14762 if ((argc < 0) || (argc > 0)) {
14763 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14764 }
14765 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
14766 if (!SWIG_IsOK(res1)) {
14767 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetCallToken", 1, self ));
14768 }
14769 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
14770 result = (char *)((OpalMessagePtr const *)arg1)->GetCallToken();
14771 vresult = SWIG_FromCharPtr((const char *)result);
14772 return vresult;
14773 fail:
14774 return Qnil;
14775 }
14776
14777
14778
14779 /*
14780 Document-method: Opal::OpalMessagePtr.SetCallToken
14781
14782 call-seq:
14783 SetCallToken(char token)
14784
14785 An instance method.
14786
14787 */
14788 SWIGINTERN VALUE
14789 _wrap_OpalMessagePtr_SetCallToken(int argc, VALUE *argv, VALUE self) {
14790 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
14791 char *arg2 = (char *) 0 ;
14792 void *argp1 = 0 ;
14793 int res1 = 0 ;
14794 int res2 ;
14795 char *buf2 = 0 ;
14796 int alloc2 = 0 ;
14797
14798 if ((argc < 1) || (argc > 1)) {
14799 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14800 }
14801 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
14802 if (!SWIG_IsOK(res1)) {
14803 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr *","SetCallToken", 1, self ));
14804 }
14805 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
14806 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
14807 if (!SWIG_IsOK(res2)) {
14808 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","SetCallToken", 2, argv[0] ));
14809 }
14810 arg2 = reinterpret_cast< char * >(buf2);
14811 (arg1)->SetCallToken((char const *)arg2);
14812 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
14813 return Qnil;
14814 fail:
14815 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
14816 return Qnil;
14817 }
14818
14819
14820
14821 /*
14822 Document-method: Opal::OpalMessagePtr.GetCommandError
14823
14824 call-seq:
14825 GetCommandError -> char
14826
14827 An instance method.
14828
14829 */
14830 SWIGINTERN VALUE
14831 _wrap_OpalMessagePtr_GetCommandError(int argc, VALUE *argv, VALUE self) {
14832 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
14833 void *argp1 = 0 ;
14834 int res1 = 0 ;
14835 char *result = 0 ;
14836 VALUE vresult = Qnil;
14837
14838 if ((argc < 0) || (argc > 0)) {
14839 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14840 }
14841 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
14842 if (!SWIG_IsOK(res1)) {
14843 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetCommandError", 1, self ));
14844 }
14845 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
14846 result = (char *)((OpalMessagePtr const *)arg1)->GetCommandError();
14847 vresult = SWIG_FromCharPtr((const char *)result);
14848 return vresult;
14849 fail:
14850 return Qnil;
14851 }
14852
14853
14854
14855 /*
14856 Document-method: Opal::OpalMessagePtr.GetGeneralParams
14857
14858 call-seq:
14859 GetGeneralParams -> OpalParamGeneral
14860
14861 An instance method.
14862
14863 */
14864 SWIGINTERN VALUE
14865 _wrap_OpalMessagePtr_GetGeneralParams(int argc, VALUE *argv, VALUE self) {
14866 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
14867 void *argp1 = 0 ;
14868 int res1 = 0 ;
14869 OpalParamGeneral *result = 0 ;
14870 VALUE vresult = Qnil;
14871
14872 if ((argc < 0) || (argc > 0)) {
14873 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14874 }
14875 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
14876 if (!SWIG_IsOK(res1)) {
14877 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetGeneralParams", 1, self ));
14878 }
14879 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
14880 result = (OpalParamGeneral *)((OpalMessagePtr const *)arg1)->GetGeneralParams();
14881 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamGeneral, 0 | 0 );
14882 return vresult;
14883 fail:
14884 return Qnil;
14885 }
14886
14887
14888
14889 /*
14890 Document-method: Opal::OpalMessagePtr.GetProtocolParams
14891
14892 call-seq:
14893 GetProtocolParams -> OpalParamProtocol
14894
14895 An instance method.
14896
14897 */
14898 SWIGINTERN VALUE
14899 _wrap_OpalMessagePtr_GetProtocolParams(int argc, VALUE *argv, VALUE self) {
14900 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
14901 void *argp1 = 0 ;
14902 int res1 = 0 ;
14903 OpalParamProtocol *result = 0 ;
14904 VALUE vresult = Qnil;
14905
14906 if ((argc < 0) || (argc > 0)) {
14907 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14908 }
14909 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
14910 if (!SWIG_IsOK(res1)) {
14911 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetProtocolParams", 1, self ));
14912 }
14913 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
14914 result = (OpalParamProtocol *)((OpalMessagePtr const *)arg1)->GetProtocolParams();
14915 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamProtocol, 0 | 0 );
14916 return vresult;
14917 fail:
14918 return Qnil;
14919 }
14920
14921
14922
14923 /*
14924 Document-method: Opal::OpalMessagePtr.GetRegistrationInfo
14925
14926 call-seq:
14927 GetRegistrationInfo -> OpalParamRegistration
14928
14929 An instance method.
14930
14931 */
14932 SWIGINTERN VALUE
14933 _wrap_OpalMessagePtr_GetRegistrationInfo(int argc, VALUE *argv, VALUE self) {
14934 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
14935 void *argp1 = 0 ;
14936 int res1 = 0 ;
14937 OpalParamRegistration *result = 0 ;
14938 VALUE vresult = Qnil;
14939
14940 if ((argc < 0) || (argc > 0)) {
14941 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14942 }
14943 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
14944 if (!SWIG_IsOK(res1)) {
14945 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetRegistrationInfo", 1, self ));
14946 }
14947 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
14948 result = (OpalParamRegistration *)((OpalMessagePtr const *)arg1)->GetRegistrationInfo();
14949 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamRegistration, 0 | 0 );
14950 return vresult;
14951 fail:
14952 return Qnil;
14953 }
14954
14955
14956
14957 /*
14958 Document-method: Opal::OpalMessagePtr.GetRegistrationStatus
14959
14960 call-seq:
14961 GetRegistrationStatus -> OpalStatusRegistration
14962
14963 An instance method.
14964
14965 */
14966 SWIGINTERN VALUE
14967 _wrap_OpalMessagePtr_GetRegistrationStatus(int argc, VALUE *argv, VALUE self) {
14968 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
14969 void *argp1 = 0 ;
14970 int res1 = 0 ;
14971 OpalStatusRegistration *result = 0 ;
14972 VALUE vresult = Qnil;
14973
14974 if ((argc < 0) || (argc > 0)) {
14975 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14976 }
14977 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
14978 if (!SWIG_IsOK(res1)) {
14979 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetRegistrationStatus", 1, self ));
14980 }
14981 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
14982 result = (OpalStatusRegistration *)((OpalMessagePtr const *)arg1)->GetRegistrationStatus();
14983 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusRegistration, 0 | 0 );
14984 return vresult;
14985 fail:
14986 return Qnil;
14987 }
14988
14989
14990
14991 /*
14992 Document-method: Opal::OpalMessagePtr.GetCallSetUp
14993
14994 call-seq:
14995 GetCallSetUp -> OpalParamSetUpCall
14996
14997 An instance method.
14998
14999 */
15000 SWIGINTERN VALUE
15001 _wrap_OpalMessagePtr_GetCallSetUp(int argc, VALUE *argv, VALUE self) {
15002 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15003 void *argp1 = 0 ;
15004 int res1 = 0 ;
15005 OpalParamSetUpCall *result = 0 ;
15006 VALUE vresult = Qnil;
15007
15008 if ((argc < 0) || (argc > 0)) {
15009 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15010 }
15011 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15012 if (!SWIG_IsOK(res1)) {
15013 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetCallSetUp", 1, self ));
15014 }
15015 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15016 result = (OpalParamSetUpCall *)((OpalMessagePtr const *)arg1)->GetCallSetUp();
15017 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamSetUpCall, 0 | 0 );
15018 return vresult;
15019 fail:
15020 return Qnil;
15021 }
15022
15023
15024
15025 /*
15026 Document-method: Opal::OpalMessagePtr.GetIncomingCall
15027
15028 call-seq:
15029 GetIncomingCall -> OpalStatusIncomingCall
15030
15031 An instance method.
15032
15033 */
15034 SWIGINTERN VALUE
15035 _wrap_OpalMessagePtr_GetIncomingCall(int argc, VALUE *argv, VALUE self) {
15036 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15037 void *argp1 = 0 ;
15038 int res1 = 0 ;
15039 OpalStatusIncomingCall *result = 0 ;
15040 VALUE vresult = Qnil;
15041
15042 if ((argc < 0) || (argc > 0)) {
15043 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15044 }
15045 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15046 if (!SWIG_IsOK(res1)) {
15047 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetIncomingCall", 1, self ));
15048 }
15049 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15050 result = (OpalStatusIncomingCall *)((OpalMessagePtr const *)arg1)->GetIncomingCall();
15051 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusIncomingCall, 0 | 0 );
15052 return vresult;
15053 fail:
15054 return Qnil;
15055 }
15056
15057
15058
15059 /*
15060 Document-method: Opal::OpalMessagePtr.GetAnswerCall
15061
15062 call-seq:
15063 GetAnswerCall -> OpalParamAnswerCall
15064
15065 An instance method.
15066
15067 */
15068 SWIGINTERN VALUE
15069 _wrap_OpalMessagePtr_GetAnswerCall(int argc, VALUE *argv, VALUE self) {
15070 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15071 void *argp1 = 0 ;
15072 int res1 = 0 ;
15073 OpalParamAnswerCall *result = 0 ;
15074 VALUE vresult = Qnil;
15075
15076 if ((argc < 0) || (argc > 0)) {
15077 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15078 }
15079 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15080 if (!SWIG_IsOK(res1)) {
15081 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetAnswerCall", 1, self ));
15082 }
15083 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15084 result = (OpalParamAnswerCall *)((OpalMessagePtr const *)arg1)->GetAnswerCall();
15085 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamAnswerCall, 0 | 0 );
15086 return vresult;
15087 fail:
15088 return Qnil;
15089 }
15090
15091
15092
15093 /*
15094 Document-method: Opal::OpalMessagePtr.GetUserInput
15095
15096 call-seq:
15097 GetUserInput -> OpalStatusUserInput
15098
15099 An instance method.
15100
15101 */
15102 SWIGINTERN VALUE
15103 _wrap_OpalMessagePtr_GetUserInput(int argc, VALUE *argv, VALUE self) {
15104 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15105 void *argp1 = 0 ;
15106 int res1 = 0 ;
15107 OpalStatusUserInput *result = 0 ;
15108 VALUE vresult = Qnil;
15109
15110 if ((argc < 0) || (argc > 0)) {
15111 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15112 }
15113 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15114 if (!SWIG_IsOK(res1)) {
15115 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetUserInput", 1, self ));
15116 }
15117 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15118 result = (OpalStatusUserInput *)((OpalMessagePtr const *)arg1)->GetUserInput();
15119 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusUserInput, 0 | 0 );
15120 return vresult;
15121 fail:
15122 return Qnil;
15123 }
15124
15125
15126
15127 /*
15128 Document-method: Opal::OpalMessagePtr.GetMessageWaiting
15129
15130 call-seq:
15131 GetMessageWaiting -> OpalStatusMessageWaiting
15132
15133 An instance method.
15134
15135 */
15136 SWIGINTERN VALUE
15137 _wrap_OpalMessagePtr_GetMessageWaiting(int argc, VALUE *argv, VALUE self) {
15138 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15139 void *argp1 = 0 ;
15140 int res1 = 0 ;
15141 OpalStatusMessageWaiting *result = 0 ;
15142 VALUE vresult = Qnil;
15143
15144 if ((argc < 0) || (argc > 0)) {
15145 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15146 }
15147 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15148 if (!SWIG_IsOK(res1)) {
15149 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetMessageWaiting", 1, self ));
15150 }
15151 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15152 result = (OpalStatusMessageWaiting *)((OpalMessagePtr const *)arg1)->GetMessageWaiting();
15153 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusMessageWaiting, 0 | 0 );
15154 return vresult;
15155 fail:
15156 return Qnil;
15157 }
15158
15159
15160
15161 /*
15162 Document-method: Opal::OpalMessagePtr.GetLineAppearance
15163
15164 call-seq:
15165 GetLineAppearance -> OpalStatusLineAppearance
15166
15167 An instance method.
15168
15169 */
15170 SWIGINTERN VALUE
15171 _wrap_OpalMessagePtr_GetLineAppearance(int argc, VALUE *argv, VALUE self) {
15172 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15173 void *argp1 = 0 ;
15174 int res1 = 0 ;
15175 OpalStatusLineAppearance *result = 0 ;
15176 VALUE vresult = Qnil;
15177
15178 if ((argc < 0) || (argc > 0)) {
15179 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15180 }
15181 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15182 if (!SWIG_IsOK(res1)) {
15183 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetLineAppearance", 1, self ));
15184 }
15185 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15186 result = (OpalStatusLineAppearance *)((OpalMessagePtr const *)arg1)->GetLineAppearance();
15187 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusLineAppearance, 0 | 0 );
15188 return vresult;
15189 fail:
15190 return Qnil;
15191 }
15192
15193
15194
15195 /*
15196 Document-method: Opal::OpalMessagePtr.GetCallCleared
15197
15198 call-seq:
15199 GetCallCleared -> OpalStatusCallCleared
15200
15201 An instance method.
15202
15203 */
15204 SWIGINTERN VALUE
15205 _wrap_OpalMessagePtr_GetCallCleared(int argc, VALUE *argv, VALUE self) {
15206 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15207 void *argp1 = 0 ;
15208 int res1 = 0 ;
15209 OpalStatusCallCleared *result = 0 ;
15210 VALUE vresult = Qnil;
15211
15212 if ((argc < 0) || (argc > 0)) {
15213 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15214 }
15215 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15216 if (!SWIG_IsOK(res1)) {
15217 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetCallCleared", 1, self ));
15218 }
15219 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15220 result = (OpalStatusCallCleared *)((OpalMessagePtr const *)arg1)->GetCallCleared();
15221 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusCallCleared, 0 | 0 );
15222 return vresult;
15223 fail:
15224 return Qnil;
15225 }
15226
15227
15228
15229 /*
15230 Document-method: Opal::OpalMessagePtr.GetClearCall
15231
15232 call-seq:
15233 GetClearCall -> OpalParamCallCleared
15234
15235 An instance method.
15236
15237 */
15238 SWIGINTERN VALUE
15239 _wrap_OpalMessagePtr_GetClearCall(int argc, VALUE *argv, VALUE self) {
15240 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15241 void *argp1 = 0 ;
15242 int res1 = 0 ;
15243 OpalParamCallCleared *result = 0 ;
15244 VALUE vresult = Qnil;
15245
15246 if ((argc < 0) || (argc > 0)) {
15247 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15248 }
15249 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15250 if (!SWIG_IsOK(res1)) {
15251 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetClearCall", 1, self ));
15252 }
15253 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15254 result = (OpalParamCallCleared *)((OpalMessagePtr const *)arg1)->GetClearCall();
15255 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamCallCleared, 0 | 0 );
15256 return vresult;
15257 fail:
15258 return Qnil;
15259 }
15260
15261
15262
15263 /*
15264 Document-method: Opal::OpalMessagePtr.GetMediaStream
15265
15266 call-seq:
15267 GetMediaStream -> OpalStatusMediaStream
15268
15269 An instance method.
15270
15271 */
15272 SWIGINTERN VALUE
15273 _wrap_OpalMessagePtr_GetMediaStream(int argc, VALUE *argv, VALUE self) {
15274 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15275 void *argp1 = 0 ;
15276 int res1 = 0 ;
15277 OpalStatusMediaStream *result = 0 ;
15278 VALUE vresult = Qnil;
15279
15280 if ((argc < 0) || (argc > 0)) {
15281 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15282 }
15283 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15284 if (!SWIG_IsOK(res1)) {
15285 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetMediaStream", 1, self ));
15286 }
15287 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15288 result = (OpalStatusMediaStream *)((OpalMessagePtr const *)arg1)->GetMediaStream();
15289 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusMediaStream, 0 | 0 );
15290 return vresult;
15291 fail:
15292 return Qnil;
15293 }
15294
15295
15296
15297 /*
15298 Document-method: Opal::OpalMessagePtr.GetSetUserData
15299
15300 call-seq:
15301 GetSetUserData -> OpalParamSetUserData
15302
15303 An instance method.
15304
15305 */
15306 SWIGINTERN VALUE
15307 _wrap_OpalMessagePtr_GetSetUserData(int argc, VALUE *argv, VALUE self) {
15308 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15309 void *argp1 = 0 ;
15310 int res1 = 0 ;
15311 OpalParamSetUserData *result = 0 ;
15312 VALUE vresult = Qnil;
15313
15314 if ((argc < 0) || (argc > 0)) {
15315 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15316 }
15317 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15318 if (!SWIG_IsOK(res1)) {
15319 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetSetUserData", 1, self ));
15320 }
15321 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15322 result = (OpalParamSetUserData *)((OpalMessagePtr const *)arg1)->GetSetUserData();
15323 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamSetUserData, 0 | 0 );
15324 return vresult;
15325 fail:
15326 return Qnil;
15327 }
15328
15329
15330
15331 /*
15332 Document-method: Opal::OpalMessagePtr.GetRecording
15333
15334 call-seq:
15335 GetRecording -> OpalParamRecording
15336
15337 An instance method.
15338
15339 */
15340 SWIGINTERN VALUE
15341 _wrap_OpalMessagePtr_GetRecording(int argc, VALUE *argv, VALUE self) {
15342 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15343 void *argp1 = 0 ;
15344 int res1 = 0 ;
15345 OpalParamRecording *result = 0 ;
15346 VALUE vresult = Qnil;
15347
15348 if ((argc < 0) || (argc > 0)) {
15349 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15350 }
15351 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15352 if (!SWIG_IsOK(res1)) {
15353 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetRecording", 1, self ));
15354 }
15355 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15356 result = (OpalParamRecording *)((OpalMessagePtr const *)arg1)->GetRecording();
15357 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalParamRecording, 0 | 0 );
15358 return vresult;
15359 fail:
15360 return Qnil;
15361 }
15362
15363
15364
15365 /*
15366 Document-method: Opal::OpalMessagePtr.GetTransferStatus
15367
15368 call-seq:
15369 GetTransferStatus -> OpalStatusTransferCall
15370
15371 An instance method.
15372
15373 */
15374 SWIGINTERN VALUE
15375 _wrap_OpalMessagePtr_GetTransferStatus(int argc, VALUE *argv, VALUE self) {
15376 OpalMessagePtr *arg1 = (OpalMessagePtr *) 0 ;
15377 void *argp1 = 0 ;
15378 int res1 = 0 ;
15379 OpalStatusTransferCall *result = 0 ;
15380 VALUE vresult = Qnil;
15381
15382 if ((argc < 0) || (argc > 0)) {
15383 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15384 }
15385 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalMessagePtr, 0 | 0 );
15386 if (!SWIG_IsOK(res1)) {
15387 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalMessagePtr const *","GetTransferStatus", 1, self ));
15388 }
15389 arg1 = reinterpret_cast< OpalMessagePtr * >(argp1);
15390 result = (OpalStatusTransferCall *)((OpalMessagePtr const *)arg1)->GetTransferStatus();
15391 vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OpalStatusTransferCall, 0 | 0 );
15392 return vresult;
15393 fail:
15394 return Qnil;
15395 }
15396
15397
15398
15399 /*
15400 Document-class: Opal::OpalContext
15401
15402 Proxy of C++ Opal::OpalContext class
15403
15404
15405 */
15406 swig_class SwigClassOpalContext;
15407
15408 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
15409 SWIGINTERN VALUE
15410 _wrap_OpalContext_allocate(VALUE self) {
15411 #else
15412 SWIGINTERN VALUE
15413 _wrap_OpalContext_allocate(int argc, VALUE *argv, VALUE self) {
15414 #endif
15415
15416
15417 VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OpalContext);
15418 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
15419 rb_obj_call_init(vresult, argc, argv);
15420 #endif
15421 return vresult;
15422 }
15423
15424
15425
15426 /*
15427 Document-method: Opal::OpalContext.new
15428
15429 call-seq:
15430 OpalContext.new
15431
15432 Class constructor.
15433
15434 */
15435 SWIGINTERN VALUE
15436 _wrap_new_OpalContext(int argc, VALUE *argv, VALUE self) {
15437 OpalContext *result = 0 ;
15438
15439 if ((argc < 0) || (argc > 0)) {
15440 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15441 }
15442 result = (OpalContext *)new OpalContext();
15443 DATA_PTR(self) = result;
15444 return self;
15445 fail:
15446 return Qnil;
15447 }
15448
15449
15450 SWIGINTERN void
15451 free_OpalContext(OpalContext *arg1) {
15452 delete arg1;
15453 }
15454
15455
15456 /*
15457 Document-method: Opal::OpalContext.Initialise
15458
15459 call-seq:
15460 Initialise(char options, unsigned int version=27) -> unsigned int
15461 Initialise(char options) -> unsigned int
15462
15463 An instance method.
15464
15465 */
15466 SWIGINTERN VALUE
15467 _wrap_OpalContext_Initialise__SWIG_0(int argc, VALUE *argv, VALUE self) {
15468 OpalContext *arg1 = (OpalContext *) 0 ;
15469 char *arg2 = (char *) 0 ;
15470 unsigned int arg3 ;
15471 void *argp1 = 0 ;
15472 int res1 = 0 ;
15473 int res2 ;
15474 char *buf2 = 0 ;
15475 int alloc2 = 0 ;
15476 unsigned int val3 ;
15477 int ecode3 = 0 ;
15478 unsigned int result;
15479 VALUE vresult = Qnil;
15480
15481 if ((argc < 2) || (argc > 2)) {
15482 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
15483 }
15484 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
15485 if (!SWIG_IsOK(res1)) {
15486 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","Initialise", 1, self ));
15487 }
15488 arg1 = reinterpret_cast< OpalContext * >(argp1);
15489 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
15490 if (!SWIG_IsOK(res2)) {
15491 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","Initialise", 2, argv[0] ));
15492 }
15493 arg2 = reinterpret_cast< char * >(buf2);
15494 ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
15495 if (!SWIG_IsOK(ecode3)) {
15496 SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","Initialise", 3, argv[1] ));
15497 }
15498 arg3 = static_cast< unsigned int >(val3);
15499 result = (unsigned int)(arg1)->Initialise((char const *)arg2,arg3);
15500 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
15501 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15502 return vresult;
15503 fail:
15504 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15505 return Qnil;
15506 }
15507
15508
15509 SWIGINTERN VALUE
15510 _wrap_OpalContext_Initialise__SWIG_1(int argc, VALUE *argv, VALUE self) {
15511 OpalContext *arg1 = (OpalContext *) 0 ;
15512 char *arg2 = (char *) 0 ;
15513 void *argp1 = 0 ;
15514 int res1 = 0 ;
15515 int res2 ;
15516 char *buf2 = 0 ;
15517 int alloc2 = 0 ;
15518 unsigned int result;
15519 VALUE vresult = Qnil;
15520
15521 if ((argc < 1) || (argc > 1)) {
15522 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15523 }
15524 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
15525 if (!SWIG_IsOK(res1)) {
15526 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","Initialise", 1, self ));
15527 }
15528 arg1 = reinterpret_cast< OpalContext * >(argp1);
15529 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
15530 if (!SWIG_IsOK(res2)) {
15531 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","Initialise", 2, argv[0] ));
15532 }
15533 arg2 = reinterpret_cast< char * >(buf2);
15534 result = (unsigned int)(arg1)->Initialise((char const *)arg2);
15535 vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
15536 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15537 return vresult;
15538 fail:
15539 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15540 return Qnil;
15541 }
15542
15543
15544 SWIGINTERN VALUE _wrap_OpalContext_Initialise(int nargs, VALUE *args, VALUE self) {
15545 int argc;
15546 VALUE argv[4];
15547 int ii;
15548
15549 argc = nargs + 1;
15550 argv[0] = self;
15551 if (argc > 4) SWIG_fail;
15552 for (ii = 1; (ii < argc); ++ii) {
15553 argv[ii] = args[ii-1];
15554 }
15555 if (argc == 2) {
15556 int _v;
15557 void *vptr = 0;
15558 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpalContext, 0);
15559 _v = SWIG_CheckState(res);
15560 if (_v) {
15561 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15562 _v = SWIG_CheckState(res);
15563 if (_v) {
15564 return _wrap_OpalContext_Initialise__SWIG_1(nargs, args, self);
15565 }
15566 }
15567 }
15568 if (argc == 3) {
15569 int _v;
15570 void *vptr = 0;
15571 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpalContext, 0);
15572 _v = SWIG_CheckState(res);
15573 if (_v) {
15574 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
15575 _v = SWIG_CheckState(res);
15576 if (_v) {
15577 {
15578 int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
15579 _v = SWIG_CheckState(res);
15580 }
15581 if (_v) {
15582 return _wrap_OpalContext_Initialise__SWIG_0(nargs, args, self);
15583 }
15584 }
15585 }
15586 }
15587
15588 fail:
15589 Ruby_Format_OverloadedError( argc, 4, "OpalContext.Initialise",
15590 " unsigned int OpalContext.Initialise(char const *options, unsigned int version)\n"
15591 " unsigned int OpalContext.Initialise(char const *options)\n");
15592
15593 return Qnil;
15594 }
15595
15596
15597
15598 /*
15599 Document-method: Opal::OpalContext.IsInitialised
15600
15601 call-seq:
15602 IsInitialised -> bool
15603
15604 An instance method.
15605
15606 */
15607 SWIGINTERN VALUE
15608 _wrap_OpalContext_IsInitialised(int argc, VALUE *argv, VALUE self) {
15609 OpalContext *arg1 = (OpalContext *) 0 ;
15610 void *argp1 = 0 ;
15611 int res1 = 0 ;
15612 bool result;
15613 VALUE vresult = Qnil;
15614
15615 if ((argc < 0) || (argc > 0)) {
15616 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15617 }
15618 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
15619 if (!SWIG_IsOK(res1)) {
15620 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext const *","IsInitialised", 1, self ));
15621 }
15622 arg1 = reinterpret_cast< OpalContext * >(argp1);
15623 result = (bool)((OpalContext const *)arg1)->IsInitialised();
15624 vresult = SWIG_From_bool(static_cast< bool >(result));
15625 return vresult;
15626 fail:
15627 return Qnil;
15628 }
15629
15630
15631
15632 /*
15633 Document-method: Opal::OpalContext.ShutDown
15634
15635 call-seq:
15636 ShutDown
15637
15638 An instance method.
15639
15640 */
15641 SWIGINTERN VALUE
15642 _wrap_OpalContext_ShutDown(int argc, VALUE *argv, VALUE self) {
15643 OpalContext *arg1 = (OpalContext *) 0 ;
15644 void *argp1 = 0 ;
15645 int res1 = 0 ;
15646
15647 if ((argc < 0) || (argc > 0)) {
15648 rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15649 }
15650 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
15651 if (!SWIG_IsOK(res1)) {
15652 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","ShutDown", 1, self ));
15653 }
15654 arg1 = reinterpret_cast< OpalContext * >(argp1);
15655 (arg1)->ShutDown();
15656 return Qnil;
15657 fail:
15658 return Qnil;
15659 }
15660
15661
15662
15663 /*
15664 Document-method: Opal::OpalContext.GetMessage
15665
15666 call-seq:
15667 GetMessage(OpalMessagePtr message, unsigned int timeout=0) -> bool
15668 GetMessage(OpalMessagePtr message) -> bool
15669
15670 An instance method.
15671
15672 */
15673 SWIGINTERN VALUE
15674 _wrap_OpalContext_GetMessage__SWIG_0(int argc, VALUE *argv, VALUE self) {
15675 OpalContext *arg1 = (OpalContext *) 0 ;
15676 OpalMessagePtr *arg2 = 0 ;
15677 unsigned int arg3 ;
15678 void *argp1 = 0 ;
15679 int res1 = 0 ;
15680 void *argp2 = 0 ;
15681 int res2 = 0 ;
15682 unsigned int val3 ;
15683 int ecode3 = 0 ;
15684 bool result;
15685 VALUE vresult = Qnil;
15686
15687 if ((argc < 2) || (argc > 2)) {
15688 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
15689 }
15690 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
15691 if (!SWIG_IsOK(res1)) {
15692 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","GetMessage", 1, self ));
15693 }
15694 arg1 = reinterpret_cast< OpalContext * >(argp1);
15695 res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_OpalMessagePtr, 0 );
15696 if (!SWIG_IsOK(res2)) {
15697 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalMessagePtr &","GetMessage", 2, argv[0] ));
15698 }
15699 if (!argp2) {
15700 SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "OpalMessagePtr &","GetMessage", 2, argv[0]));
15701 }
15702 arg2 = reinterpret_cast< OpalMessagePtr * >(argp2);
15703 ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
15704 if (!SWIG_IsOK(ecode3)) {
15705 SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","GetMessage", 3, argv[1] ));
15706 }
15707 arg3 = static_cast< unsigned int >(val3);
15708 result = (bool)(arg1)->GetMessage(*arg2,arg3);
15709 vresult = SWIG_From_bool(static_cast< bool >(result));
15710 return vresult;
15711 fail:
15712 return Qnil;
15713 }
15714
15715
15716 SWIGINTERN VALUE
15717 _wrap_OpalContext_GetMessage__SWIG_1(int argc, VALUE *argv, VALUE self) {
15718 OpalContext *arg1 = (OpalContext *) 0 ;
15719 OpalMessagePtr *arg2 = 0 ;
15720 void *argp1 = 0 ;
15721 int res1 = 0 ;
15722 void *argp2 = 0 ;
15723 int res2 = 0 ;
15724 bool result;
15725 VALUE vresult = Qnil;
15726
15727 if ((argc < 1) || (argc > 1)) {
15728 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15729 }
15730 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
15731 if (!SWIG_IsOK(res1)) {
15732 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","GetMessage", 1, self ));
15733 }
15734 arg1 = reinterpret_cast< OpalContext * >(argp1);
15735 res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_OpalMessagePtr, 0 );
15736 if (!SWIG_IsOK(res2)) {
15737 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalMessagePtr &","GetMessage", 2, argv[0] ));
15738 }
15739 if (!argp2) {
15740 SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "OpalMessagePtr &","GetMessage", 2, argv[0]));
15741 }
15742 arg2 = reinterpret_cast< OpalMessagePtr * >(argp2);
15743 result = (bool)(arg1)->GetMessage(*arg2);
15744 vresult = SWIG_From_bool(static_cast< bool >(result));
15745 return vresult;
15746 fail:
15747 return Qnil;
15748 }
15749
15750
15751 SWIGINTERN VALUE _wrap_OpalContext_GetMessage(int nargs, VALUE *args, VALUE self) {
15752 int argc;
15753 VALUE argv[4];
15754 int ii;
15755
15756 argc = nargs + 1;
15757 argv[0] = self;
15758 if (argc > 4) SWIG_fail;
15759 for (ii = 1; (ii < argc); ++ii) {
15760 argv[ii] = args[ii-1];
15761 }
15762 if (argc == 2) {
15763 int _v;
15764 void *vptr = 0;
15765 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpalContext, 0);
15766 _v = SWIG_CheckState(res);
15767 if (_v) {
15768 void *vptr = 0;
15769 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_OpalMessagePtr, 0);
15770 _v = SWIG_CheckState(res);
15771 if (_v) {
15772 return _wrap_OpalContext_GetMessage__SWIG_1(nargs, args, self);
15773 }
15774 }
15775 }
15776 if (argc == 3) {
15777 int _v;
15778 void *vptr = 0;
15779 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpalContext, 0);
15780 _v = SWIG_CheckState(res);
15781 if (_v) {
15782 void *vptr = 0;
15783 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_OpalMessagePtr, 0);
15784 _v = SWIG_CheckState(res);
15785 if (_v) {
15786 {
15787 int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
15788 _v = SWIG_CheckState(res);
15789 }
15790 if (_v) {
15791 return _wrap_OpalContext_GetMessage__SWIG_0(nargs, args, self);
15792 }
15793 }
15794 }
15795 }
15796
15797 fail:
15798 Ruby_Format_OverloadedError( argc, 4, "OpalContext.GetMessage",
15799 " bool OpalContext.GetMessage(OpalMessagePtr &message, unsigned int timeout)\n"
15800 " bool OpalContext.GetMessage(OpalMessagePtr &message)\n");
15801
15802 return Qnil;
15803 }
15804
15805
15806
15807 /*
15808 Document-method: Opal::OpalContext.SendMessage
15809
15810 call-seq:
15811 SendMessage(OpalMessagePtr message, OpalMessagePtr response) -> bool
15812
15813 An instance method.
15814
15815 */
15816 SWIGINTERN VALUE
15817 _wrap_OpalContext_SendMessage(int argc, VALUE *argv, VALUE self) {
15818 OpalContext *arg1 = (OpalContext *) 0 ;
15819 OpalMessagePtr *arg2 = 0 ;
15820 OpalMessagePtr *arg3 = 0 ;
15821 void *argp1 = 0 ;
15822 int res1 = 0 ;
15823 void *argp2 ;
15824 int res2 = 0 ;
15825 void *argp3 = 0 ;
15826 int res3 = 0 ;
15827 bool result;
15828 VALUE vresult = Qnil;
15829
15830 if ((argc < 2) || (argc > 2)) {
15831 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
15832 }
15833 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
15834 if (!SWIG_IsOK(res1)) {
15835 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","SendMessage", 1, self ));
15836 }
15837 arg1 = reinterpret_cast< OpalContext * >(argp1);
15838 res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_OpalMessagePtr, 0 );
15839 if (!SWIG_IsOK(res2)) {
15840 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalMessagePtr const &","SendMessage", 2, argv[0] ));
15841 }
15842 if (!argp2) {
15843 SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "OpalMessagePtr const &","SendMessage", 2, argv[0]));
15844 }
15845 arg2 = reinterpret_cast< OpalMessagePtr * >(argp2);
15846 res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_OpalMessagePtr, 0 );
15847 if (!SWIG_IsOK(res3)) {
15848 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "OpalMessagePtr &","SendMessage", 3, argv[1] ));
15849 }
15850 if (!argp3) {
15851 SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "OpalMessagePtr &","SendMessage", 3, argv[1]));
15852 }
15853 arg3 = reinterpret_cast< OpalMessagePtr * >(argp3);
15854 result = (bool)(arg1)->SendMessage((OpalMessagePtr const &)*arg2,*arg3);
15855 vresult = SWIG_From_bool(static_cast< bool >(result));
15856 return vresult;
15857 fail:
15858 return Qnil;
15859 }
15860
15861
15862
15863 /*
15864 Document-method: Opal::OpalContext.SetUpCall
15865
15866 call-seq:
15867 SetUpCall(OpalMessagePtr response, char partyB, char partyA=nil,
15868 char alertingType=nil) -> bool
15869 SetUpCall(OpalMessagePtr response, char partyB, char partyA=nil) -> bool
15870 SetUpCall(OpalMessagePtr response, char partyB) -> bool
15871
15872 An instance method.
15873
15874 */
15875 SWIGINTERN VALUE
15876 _wrap_OpalContext_SetUpCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
15877 OpalContext *arg1 = (OpalContext *) 0 ;
15878 OpalMessagePtr *arg2 = 0 ;
15879 char *arg3 = (char *) 0 ;
15880 char *arg4 = (char *) 0 ;
15881 char *arg5 = (char *) 0 ;
15882 void *argp1 = 0 ;
15883 int res1 = 0 ;
15884 void *argp2 = 0 ;
15885 int res2 = 0 ;
15886 int res3 ;
15887 char *buf3 = 0 ;
15888 int alloc3 = 0 ;
15889 int res4 ;
15890 char *buf4 = 0 ;
15891 int alloc4 = 0 ;
15892 int res5 ;
15893 char *buf5 = 0 ;
15894 int alloc5 = 0 ;
15895 bool result;
15896 VALUE vresult = Qnil;
15897
15898 if ((argc < 4) || (argc > 4)) {
15899 rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
15900 }
15901 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
15902 if (!SWIG_IsOK(res1)) {
15903 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","SetUpCall", 1, self ));
15904 }
15905 arg1 = reinterpret_cast< OpalContext * >(argp1);
15906 res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_OpalMessagePtr, 0 );
15907 if (!SWIG_IsOK(res2)) {
15908 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalMessagePtr &","SetUpCall", 2, argv[0] ));
15909 }
15910 if (!argp2) {
15911 SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "OpalMessagePtr &","SetUpCall", 2, argv[0]));
15912 }
15913 arg2 = reinterpret_cast< OpalMessagePtr * >(argp2);
15914 res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
15915 if (!SWIG_IsOK(res3)) {
15916 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","SetUpCall", 3, argv[1] ));
15917 }
15918 arg3 = reinterpret_cast< char * >(buf3);
15919 res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
15920 if (!SWIG_IsOK(res4)) {
15921 SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","SetUpCall", 4, argv[2] ));
15922 }
15923 arg4 = reinterpret_cast< char * >(buf4);
15924 res5 = SWIG_AsCharPtrAndSize(argv[3], &buf5, NULL, &alloc5);
15925 if (!SWIG_IsOK(res5)) {
15926 SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","SetUpCall", 5, argv[3] ));
15927 }
15928 arg5 = reinterpret_cast< char * >(buf5);
15929 result = (bool)(arg1)->SetUpCall(*arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
15930 vresult = SWIG_From_bool(static_cast< bool >(result));
15931 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
15932 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
15933 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
15934 return vresult;
15935 fail:
15936 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
15937 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
15938 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
15939 return Qnil;
15940 }
15941
15942
15943 SWIGINTERN VALUE
15944 _wrap_OpalContext_SetUpCall__SWIG_1(int argc, VALUE *argv, VALUE self) {
15945 OpalContext *arg1 = (OpalContext *) 0 ;
15946 OpalMessagePtr *arg2 = 0 ;
15947 char *arg3 = (char *) 0 ;
15948 char *arg4 = (char *) 0 ;
15949 void *argp1 = 0 ;
15950 int res1 = 0 ;
15951 void *argp2 = 0 ;
15952 int res2 = 0 ;
15953 int res3 ;
15954 char *buf3 = 0 ;
15955 int alloc3 = 0 ;
15956 int res4 ;
15957 char *buf4 = 0 ;
15958 int alloc4 = 0 ;
15959 bool result;
15960 VALUE vresult = Qnil;
15961
15962 if ((argc < 3) || (argc > 3)) {
15963 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
15964 }
15965 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
15966 if (!SWIG_IsOK(res1)) {
15967 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","SetUpCall", 1, self ));
15968 }
15969 arg1 = reinterpret_cast< OpalContext * >(argp1);
15970 res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_OpalMessagePtr, 0 );
15971 if (!SWIG_IsOK(res2)) {
15972 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalMessagePtr &","SetUpCall", 2, argv[0] ));
15973 }
15974 if (!argp2) {
15975 SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "OpalMessagePtr &","SetUpCall", 2, argv[0]));
15976 }
15977 arg2 = reinterpret_cast< OpalMessagePtr * >(argp2);
15978 res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
15979 if (!SWIG_IsOK(res3)) {
15980 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","SetUpCall", 3, argv[1] ));
15981 }
15982 arg3 = reinterpret_cast< char * >(buf3);
15983 res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
15984 if (!SWIG_IsOK(res4)) {
15985 SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","SetUpCall", 4, argv[2] ));
15986 }
15987 arg4 = reinterpret_cast< char * >(buf4);
15988 result = (bool)(arg1)->SetUpCall(*arg2,(char const *)arg3,(char const *)arg4);
15989 vresult = SWIG_From_bool(static_cast< bool >(result));
15990 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
15991 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
15992 return vresult;
15993 fail:
15994 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
15995 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
15996 return Qnil;
15997 }
15998
15999
16000 SWIGINTERN VALUE
16001 _wrap_OpalContext_SetUpCall__SWIG_2(int argc, VALUE *argv, VALUE self) {
16002 OpalContext *arg1 = (OpalContext *) 0 ;
16003 OpalMessagePtr *arg2 = 0 ;
16004 char *arg3 = (char *) 0 ;
16005 void *argp1 = 0 ;
16006 int res1 = 0 ;
16007 void *argp2 = 0 ;
16008 int res2 = 0 ;
16009 int res3 ;
16010 char *buf3 = 0 ;
16011 int alloc3 = 0 ;
16012 bool result;
16013 VALUE vresult = Qnil;
16014
16015 if ((argc < 2) || (argc > 2)) {
16016 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
16017 }
16018 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
16019 if (!SWIG_IsOK(res1)) {
16020 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","SetUpCall", 1, self ));
16021 }
16022 arg1 = reinterpret_cast< OpalContext * >(argp1);
16023 res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_OpalMessagePtr, 0 );
16024 if (!SWIG_IsOK(res2)) {
16025 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "OpalMessagePtr &","SetUpCall", 2, argv[0] ));
16026 }
16027 if (!argp2) {
16028 SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "OpalMessagePtr &","SetUpCall", 2, argv[0]));
16029 }
16030 arg2 = reinterpret_cast< OpalMessagePtr * >(argp2);
16031 res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
16032 if (!SWIG_IsOK(res3)) {
16033 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","SetUpCall", 3, argv[1] ));
16034 }
16035 arg3 = reinterpret_cast< char * >(buf3);
16036 result = (bool)(arg1)->SetUpCall(*arg2,(char const *)arg3);
16037 vresult = SWIG_From_bool(static_cast< bool >(result));
16038 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16039 return vresult;
16040 fail:
16041 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16042 return Qnil;
16043 }
16044
16045
16046 SWIGINTERN VALUE _wrap_OpalContext_SetUpCall(int nargs, VALUE *args, VALUE self) {
16047 int argc;
16048 VALUE argv[6];
16049 int ii;
16050
16051 argc = nargs + 1;
16052 argv[0] = self;
16053 if (argc > 6) SWIG_fail;
16054 for (ii = 1; (ii < argc); ++ii) {
16055 argv[ii] = args[ii-1];
16056 }
16057 if (argc == 3) {
16058 int _v;
16059 void *vptr = 0;
16060 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpalContext, 0);
16061 _v = SWIG_CheckState(res);
16062 if (_v) {
16063 void *vptr = 0;
16064 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_OpalMessagePtr, 0);
16065 _v = SWIG_CheckState(res);
16066 if (_v) {
16067 int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
16068 _v = SWIG_CheckState(res);
16069 if (_v) {
16070 return _wrap_OpalContext_SetUpCall__SWIG_2(nargs, args, self);
16071 }
16072 }
16073 }
16074 }
16075 if (argc == 4) {
16076 int _v;
16077 void *vptr = 0;
16078 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpalContext, 0);
16079 _v = SWIG_CheckState(res);
16080 if (_v) {
16081 void *vptr = 0;
16082 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_OpalMessagePtr, 0);
16083 _v = SWIG_CheckState(res);
16084 if (_v) {
16085 int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
16086 _v = SWIG_CheckState(res);
16087 if (_v) {
16088 int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
16089 _v = SWIG_CheckState(res);
16090 if (_v) {
16091 return _wrap_OpalContext_SetUpCall__SWIG_1(nargs, args, self);
16092 }
16093 }
16094 }
16095 }
16096 }
16097 if (argc == 5) {
16098 int _v;
16099 void *vptr = 0;
16100 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpalContext, 0);
16101 _v = SWIG_CheckState(res);
16102 if (_v) {
16103 void *vptr = 0;
16104 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_OpalMessagePtr, 0);
16105 _v = SWIG_CheckState(res);
16106 if (_v) {
16107 int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
16108 _v = SWIG_CheckState(res);
16109 if (_v) {
16110 int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
16111 _v = SWIG_CheckState(res);
16112 if (_v) {
16113 int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
16114 _v = SWIG_CheckState(res);
16115 if (_v) {
16116 return _wrap_OpalContext_SetUpCall__SWIG_0(nargs, args, self);
16117 }
16118 }
16119 }
16120 }
16121 }
16122 }
16123
16124 fail:
16125 Ruby_Format_OverloadedError( argc, 6, "OpalContext.SetUpCall",
16126 " bool OpalContext.SetUpCall(OpalMessagePtr &response, char const *partyB, char const *partyA, char const *alertingType)\n"
16127 " bool OpalContext.SetUpCall(OpalMessagePtr &response, char const *partyB, char const *partyA)\n"
16128 " bool OpalContext.SetUpCall(OpalMessagePtr &response, char const *partyB)\n");
16129
16130 return Qnil;
16131 }
16132
16133
16134
16135 /*
16136 Document-method: Opal::OpalContext.AnswerCall
16137
16138 call-seq:
16139 AnswerCall(char callToken) -> bool
16140
16141 An instance method.
16142
16143 */
16144 SWIGINTERN VALUE
16145 _wrap_OpalContext_AnswerCall(int argc, VALUE *argv, VALUE self) {
16146 OpalContext *arg1 = (OpalContext *) 0 ;
16147 char *arg2 = (char *) 0 ;
16148 void *argp1 = 0 ;
16149 int res1 = 0 ;
16150 int res2 ;
16151 char *buf2 = 0 ;
16152 int alloc2 = 0 ;
16153 bool result;
16154 VALUE vresult = Qnil;
16155
16156 if ((argc < 1) || (argc > 1)) {
16157 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16158 }
16159 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
16160 if (!SWIG_IsOK(res1)) {
16161 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","AnswerCall", 1, self ));
16162 }
16163 arg1 = reinterpret_cast< OpalContext * >(argp1);
16164 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
16165 if (!SWIG_IsOK(res2)) {
16166 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","AnswerCall", 2, argv[0] ));
16167 }
16168 arg2 = reinterpret_cast< char * >(buf2);
16169 result = (bool)(arg1)->AnswerCall((char const *)arg2);
16170 vresult = SWIG_From_bool(static_cast< bool >(result));
16171 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16172 return vresult;
16173 fail:
16174 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16175 return Qnil;
16176 }
16177
16178
16179
16180 /*
16181 Document-method: Opal::OpalContext.ClearCall
16182
16183 call-seq:
16184 ClearCall(char callToken, OpalCallEndReason reason=OpalCallEndedByLocalUser) -> bool
16185 ClearCall(char callToken) -> bool
16186
16187 An instance method.
16188
16189 */
16190 SWIGINTERN VALUE
16191 _wrap_OpalContext_ClearCall__SWIG_0(int argc, VALUE *argv, VALUE self) {
16192 OpalContext *arg1 = (OpalContext *) 0 ;
16193 char *arg2 = (char *) 0 ;
16194 OpalCallEndReason arg3 ;
16195 void *argp1 = 0 ;
16196 int res1 = 0 ;
16197 int res2 ;
16198 char *buf2 = 0 ;
16199 int alloc2 = 0 ;
16200 int val3 ;
16201 int ecode3 = 0 ;
16202 bool result;
16203 VALUE vresult = Qnil;
16204
16205 if ((argc < 2) || (argc > 2)) {
16206 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
16207 }
16208 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
16209 if (!SWIG_IsOK(res1)) {
16210 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","ClearCall", 1, self ));
16211 }
16212 arg1 = reinterpret_cast< OpalContext * >(argp1);
16213 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
16214 if (!SWIG_IsOK(res2)) {
16215 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","ClearCall", 2, argv[0] ));
16216 }
16217 arg2 = reinterpret_cast< char * >(buf2);
16218 ecode3 = SWIG_AsVal_int(argv[1], &val3);
16219 if (!SWIG_IsOK(ecode3)) {
16220 SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "OpalCallEndReason","ClearCall", 3, argv[1] ));
16221 }
16222 arg3 = static_cast< OpalCallEndReason >(val3);
16223 result = (bool)(arg1)->ClearCall((char const *)arg2,arg3);
16224 vresult = SWIG_From_bool(static_cast< bool >(result));
16225 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16226 return vresult;
16227 fail:
16228 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16229 return Qnil;
16230 }
16231
16232
16233 SWIGINTERN VALUE
16234 _wrap_OpalContext_ClearCall__SWIG_1(int argc, VALUE *argv, VALUE self) {
16235 OpalContext *arg1 = (OpalContext *) 0 ;
16236 char *arg2 = (char *) 0 ;
16237 void *argp1 = 0 ;
16238 int res1 = 0 ;
16239 int res2 ;
16240 char *buf2 = 0 ;
16241 int alloc2 = 0 ;
16242 bool result;
16243 VALUE vresult = Qnil;
16244
16245 if ((argc < 1) || (argc > 1)) {
16246 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16247 }
16248 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
16249 if (!SWIG_IsOK(res1)) {
16250 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","ClearCall", 1, self ));
16251 }
16252 arg1 = reinterpret_cast< OpalContext * >(argp1);
16253 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
16254 if (!SWIG_IsOK(res2)) {
16255 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","ClearCall", 2, argv[0] ));
16256 }
16257 arg2 = reinterpret_cast< char * >(buf2);
16258 result = (bool)(arg1)->ClearCall((char const *)arg2);
16259 vresult = SWIG_From_bool(static_cast< bool >(result));
16260 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16261 return vresult;
16262 fail:
16263 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16264 return Qnil;
16265 }
16266
16267
16268 SWIGINTERN VALUE _wrap_OpalContext_ClearCall(int nargs, VALUE *args, VALUE self) {
16269 int argc;
16270 VALUE argv[4];
16271 int ii;
16272
16273 argc = nargs + 1;
16274 argv[0] = self;
16275 if (argc > 4) SWIG_fail;
16276 for (ii = 1; (ii < argc); ++ii) {
16277 argv[ii] = args[ii-1];
16278 }
16279 if (argc == 2) {
16280 int _v;
16281 void *vptr = 0;
16282 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpalContext, 0);
16283 _v = SWIG_CheckState(res);
16284 if (_v) {
16285 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16286 _v = SWIG_CheckState(res);
16287 if (_v) {
16288 return _wrap_OpalContext_ClearCall__SWIG_1(nargs, args, self);
16289 }
16290 }
16291 }
16292 if (argc == 3) {
16293 int _v;
16294 void *vptr = 0;
16295 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpalContext, 0);
16296 _v = SWIG_CheckState(res);
16297 if (_v) {
16298 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16299 _v = SWIG_CheckState(res);
16300 if (_v) {
16301 {
16302 int res = SWIG_AsVal_int(argv[2], NULL);
16303 _v = SWIG_CheckState(res);
16304 }
16305 if (_v) {
16306 return _wrap_OpalContext_ClearCall__SWIG_0(nargs, args, self);
16307 }
16308 }
16309 }
16310 }
16311
16312 fail:
16313 Ruby_Format_OverloadedError( argc, 4, "OpalContext.ClearCall",
16314 " bool OpalContext.ClearCall(char const *callToken, OpalCallEndReason reason)\n"
16315 " bool OpalContext.ClearCall(char const *callToken)\n");
16316
16317 return Qnil;
16318 }
16319
16320
16321
16322 /*
16323 Document-method: Opal::OpalContext.SendUserInput
16324
16325 call-seq:
16326 SendUserInput(char callToken, char userInput, unsigned int duration=0) -> bool
16327 SendUserInput(char callToken, char userInput) -> bool
16328
16329 An instance method.
16330
16331 */
16332 SWIGINTERN VALUE
16333 _wrap_OpalContext_SendUserInput__SWIG_0(int argc, VALUE *argv, VALUE self) {
16334 OpalContext *arg1 = (OpalContext *) 0 ;
16335 char *arg2 = (char *) 0 ;
16336 char *arg3 = (char *) 0 ;
16337 unsigned int arg4 ;
16338 void *argp1 = 0 ;
16339 int res1 = 0 ;
16340 int res2 ;
16341 char *buf2 = 0 ;
16342 int alloc2 = 0 ;
16343 int res3 ;
16344 char *buf3 = 0 ;
16345 int alloc3 = 0 ;
16346 unsigned int val4 ;
16347 int ecode4 = 0 ;
16348 bool result;
16349 VALUE vresult = Qnil;
16350
16351 if ((argc < 3) || (argc > 3)) {
16352 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
16353 }
16354 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
16355 if (!SWIG_IsOK(res1)) {
16356 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","SendUserInput", 1, self ));
16357 }
16358 arg1 = reinterpret_cast< OpalContext * >(argp1);
16359 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
16360 if (!SWIG_IsOK(res2)) {
16361 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","SendUserInput", 2, argv[0] ));
16362 }
16363 arg2 = reinterpret_cast< char * >(buf2);
16364 res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
16365 if (!SWIG_IsOK(res3)) {
16366 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","SendUserInput", 3, argv[1] ));
16367 }
16368 arg3 = reinterpret_cast< char * >(buf3);
16369 ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
16370 if (!SWIG_IsOK(ecode4)) {
16371 SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","SendUserInput", 4, argv[2] ));
16372 }
16373 arg4 = static_cast< unsigned int >(val4);
16374 result = (bool)(arg1)->SendUserInput((char const *)arg2,(char const *)arg3,arg4);
16375 vresult = SWIG_From_bool(static_cast< bool >(result));
16376 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16377 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16378 return vresult;
16379 fail:
16380 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16381 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16382 return Qnil;
16383 }
16384
16385
16386 SWIGINTERN VALUE
16387 _wrap_OpalContext_SendUserInput__SWIG_1(int argc, VALUE *argv, VALUE self) {
16388 OpalContext *arg1 = (OpalContext *) 0 ;
16389 char *arg2 = (char *) 0 ;
16390 char *arg3 = (char *) 0 ;
16391 void *argp1 = 0 ;
16392 int res1 = 0 ;
16393 int res2 ;
16394 char *buf2 = 0 ;
16395 int alloc2 = 0 ;
16396 int res3 ;
16397 char *buf3 = 0 ;
16398 int alloc3 = 0 ;
16399 bool result;
16400 VALUE vresult = Qnil;
16401
16402 if ((argc < 2) || (argc > 2)) {
16403 rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
16404 }
16405 res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OpalContext, 0 | 0 );
16406 if (!SWIG_IsOK(res1)) {
16407 SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "OpalContext *","SendUserInput", 1, self ));
16408 }
16409 arg1 = reinterpret_cast< OpalContext * >(argp1);
16410 res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
16411 if (!SWIG_IsOK(res2)) {
16412 SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","SendUserInput", 2, argv[0] ));
16413 }
16414 arg2 = reinterpret_cast< char * >(buf2);
16415 res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
16416 if (!SWIG_IsOK(res3)) {
16417 SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","SendUserInput", 3, argv[1] ));
16418 }
16419 arg3 = reinterpret_cast< char * >(buf3);
16420 result = (bool)(arg1)->SendUserInput((char const *)arg2,(char const *)arg3);
16421 vresult = SWIG_From_bool(static_cast< bool >(result));
16422 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16423 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16424 return vresult;
16425 fail:
16426 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16427 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16428 return Qnil;
16429 }
16430
16431
16432 SWIGINTERN VALUE _wrap_OpalContext_SendUserInput(int nargs, VALUE *args, VALUE self) {
16433 int argc;
16434 VALUE argv[5];
16435 int ii;
16436
16437 argc = nargs + 1;
16438 argv[0] = self;
16439 if (argc > 5) SWIG_fail;
16440 for (ii = 1; (ii < argc); ++ii) {
16441 argv[ii] = args[ii-1];
16442 }
16443 if (argc == 3) {
16444 int _v;
16445 void *vptr = 0;
16446 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpalContext, 0);
16447 _v = SWIG_CheckState(res);
16448 if (_v) {
16449 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16450 _v = SWIG_CheckState(res);
16451 if (_v) {
16452 int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
16453 _v = SWIG_CheckState(res);
16454 if (_v) {
16455 return _wrap_OpalContext_SendUserInput__SWIG_1(nargs, args, self);
16456 }
16457 }
16458 }
16459 }
16460 if (argc == 4) {
16461 int _v;
16462 void *vptr = 0;
16463 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OpalContext, 0);
16464 _v = SWIG_CheckState(res);
16465 if (_v) {
16466 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16467 _v = SWIG_CheckState(res);
16468 if (_v) {
16469 int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
16470 _v = SWIG_CheckState(res);
16471 if (_v) {
16472 {
16473 int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
16474 _v = SWIG_CheckState(res);
16475 }
16476 if (_v) {
16477 return _wrap_OpalContext_SendUserInput__SWIG_0(nargs, args, self);
16478 }
16479 }
16480 }
16481 }
16482 }
16483
16484 fail:
16485 Ruby_Format_OverloadedError( argc, 5, "OpalContext.SendUserInput",
16486 " bool OpalContext.SendUserInput(char const *callToken, char const *userInput, unsigned int duration)\n"
16487 " bool OpalContext.SendUserInput(char const *callToken, char const *userInput)\n");
16488
16489 return Qnil;
16490 }
16491
16492
16493
16494 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
16495
16496 static swig_type_info _swigt__p_OpalCallEndReason = {"_p_OpalCallEndReason", "enum OpalCallEndReason *|OpalCallEndReason *", 0, 0, (void*)0, 0};
16497 static swig_type_info _swigt__p_OpalContext = {"_p_OpalContext", "OpalContext *", 0, 0, (void*)0, 0};
16498 static swig_type_info _swigt__p_OpalEchoCancelMode = {"_p_OpalEchoCancelMode", "enum OpalEchoCancelMode *|OpalEchoCancelMode *", 0, 0, (void*)0, 0};
16499 static swig_type_info _swigt__p_OpalHandleStruct = {"_p_OpalHandleStruct", "OpalHandle|OpalHandleStruct *", 0, 0, (void*)0, 0};
16500 static swig_type_info _swigt__p_OpalLineAppearanceStates = {"_p_OpalLineAppearanceStates", "enum OpalLineAppearanceStates *|OpalLineAppearanceStates *", 0, 0, (void*)0, 0};
16501 static swig_type_info _swigt__p_OpalMediaDataType = {"_p_OpalMediaDataType", "enum OpalMediaDataType *|OpalMediaDataType *", 0, 0, (void*)0, 0};
16502 static swig_type_info _swigt__p_OpalMediaStates = {"_p_OpalMediaStates", "enum OpalMediaStates *|OpalMediaStates *", 0, 0, (void*)0, 0};
16503 static swig_type_info _swigt__p_OpalMediaTiming = {"_p_OpalMediaTiming", "enum OpalMediaTiming *|OpalMediaTiming *", 0, 0, (void*)0, 0};
16504 static swig_type_info _swigt__p_OpalMessage = {"_p_OpalMessage", "OpalMessage *", 0, 0, (void*)0, 0};
16505 static swig_type_info _swigt__p_OpalMessagePtr = {"_p_OpalMessagePtr", "OpalMessagePtr *", 0, 0, (void*)0, 0};
16506 static swig_type_info _swigt__p_OpalMessageType = {"_p_OpalMessageType", "enum OpalMessageType *|OpalMessageType *", 0, 0, (void*)0, 0};
16507 static swig_type_info _swigt__p_OpalMessage_m_param = {"_p_OpalMessage_m_param", "OpalMessage_m_param *", 0, 0, (void*)0, 0};
16508 static swig_type_info _swigt__p_OpalParamAnswerCall = {"_p_OpalParamAnswerCall", "OpalParamAnswerCall *", 0, 0, (void*)0, 0};
16509 static swig_type_info _swigt__p_OpalParamCallCleared = {"_p_OpalParamCallCleared", "OpalParamCallCleared *", 0, 0, (void*)0, 0};
16510 static swig_type_info _swigt__p_OpalParamGeneral = {"_p_OpalParamGeneral", "OpalParamGeneral *", 0, 0, (void*)0, 0};
16511 static swig_type_info _swigt__p_OpalParamProtocol = {"_p_OpalParamProtocol", "OpalParamProtocol *", 0, 0, (void*)0, 0};
16512 static swig_type_info _swigt__p_OpalParamRecording = {"_p_OpalParamRecording", "OpalParamRecording *", 0, 0, (void*)0, 0};
16513 static swig_type_info _swigt__p_OpalParamRegistration = {"_p_OpalParamRegistration", "OpalParamRegistration *", 0, 0, (void*)0, 0};
16514 static swig_type_info _swigt__p_OpalParamSetUpCall = {"_p_OpalParamSetUpCall", "OpalParamSetUpCall *", 0, 0, (void*)0, 0};
16515 static swig_type_info _swigt__p_OpalParamSetUserData = {"_p_OpalParamSetUserData", "OpalParamSetUserData *", 0, 0, (void*)0, 0};
16516 static swig_type_info _swigt__p_OpalProductDescription = {"_p_OpalProductDescription", "OpalProductDescription *", 0, 0, (void*)0, 0};
16517 static swig_type_info _swigt__p_OpalRegistrationStates = {"_p_OpalRegistrationStates", "enum OpalRegistrationStates *|OpalRegistrationStates *", 0, 0, (void*)0, 0};
16518 static swig_type_info _swigt__p_OpalSilenceDetectMode = {"_p_OpalSilenceDetectMode", "enum OpalSilenceDetectMode *|OpalSilenceDetectMode *", 0, 0, (void*)0, 0};
16519 static swig_type_info _swigt__p_OpalStatusCallCleared = {"_p_OpalStatusCallCleared", "OpalStatusCallCleared *", 0, 0, (void*)0, 0};
16520 static swig_type_info _swigt__p_OpalStatusIVR = {"_p_OpalStatusIVR", "OpalStatusIVR *", 0, 0, (void*)0, 0};
16521 static swig_type_info _swigt__p_OpalStatusIncomingCall = {"_p_OpalStatusIncomingCall", "OpalStatusIncomingCall *", 0, 0, (void*)0, 0};
16522 static swig_type_info _swigt__p_OpalStatusLineAppearance = {"_p_OpalStatusLineAppearance", "OpalStatusLineAppearance *", 0, 0, (void*)0, 0};
16523 static swig_type_info _swigt__p_OpalStatusMediaStream = {"_p_OpalStatusMediaStream", "OpalStatusMediaStream *", 0, 0, (void*)0, 0};
16524 static swig_type_info _swigt__p_OpalStatusMessageWaiting = {"_p_OpalStatusMessageWaiting", "OpalStatusMessageWaiting *", 0, 0, (void*)0, 0};
16525 static swig_type_info _swigt__p_OpalStatusRegistration = {"_p_OpalStatusRegistration", "OpalStatusRegistration *", 0, 0, (void*)0, 0};
16526 static swig_type_info _swigt__p_OpalStatusTransferCall = {"_p_OpalStatusTransferCall", "OpalStatusTransferCall *", 0, 0, (void*)0, 0};
16527 static swig_type_info _swigt__p_OpalStatusUserInput = {"_p_OpalStatusUserInput", "OpalStatusUserInput *|OpalParamUserInput *", 0, 0, (void*)0, 0};
16528 static swig_type_info _swigt__p_OpalUserInputModes = {"_p_OpalUserInputModes", "enum OpalUserInputModes *|OpalUserInputModes *", 0, 0, (void*)0, 0};
16529 static swig_type_info _swigt__p_OpalVideoRecordMixMode = {"_p_OpalVideoRecordMixMode", "enum OpalVideoRecordMixMode *|OpalVideoRecordMixMode *", 0, 0, (void*)0, 0};
16530 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
16531 static swig_type_info _swigt__p_f_p_q_const__OpalMessage__int = {"_p_f_p_q_const__OpalMessage__int", "int (*)(OpalMessage const *)|OpalMessageAvailableFunction", 0, 0, (void*)0, 0};
16532 static swig_type_info _swigt__p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_void_p_void_int__int = {"_p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_void_p_void_int__int", "OpalMediaDataFunction|int (*)(char const *,char const *,char const *,void *,void *,int)", 0, 0, (void*)0, 0};
16533 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0};
16534 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
16535
16536 static swig_type_info *swig_type_initial[] = {
16537 &_swigt__p_OpalCallEndReason,
16538 &_swigt__p_OpalContext,
16539 &_swigt__p_OpalEchoCancelMode,
16540 &_swigt__p_OpalHandleStruct,
16541 &_swigt__p_OpalLineAppearanceStates,
16542 &_swigt__p_OpalMediaDataType,
16543 &_swigt__p_OpalMediaStates,
16544 &_swigt__p_OpalMediaTiming,
16545 &_swigt__p_OpalMessage,
16546 &_swigt__p_OpalMessagePtr,
16547 &_swigt__p_OpalMessageType,
16548 &_swigt__p_OpalMessage_m_param,
16549 &_swigt__p_OpalParamAnswerCall,
16550 &_swigt__p_OpalParamCallCleared,
16551 &_swigt__p_OpalParamGeneral,
16552 &_swigt__p_OpalParamProtocol,
16553 &_swigt__p_OpalParamRecording,
16554 &_swigt__p_OpalParamRegistration,
16555 &_swigt__p_OpalParamSetUpCall,
16556 &_swigt__p_OpalParamSetUserData,
16557 &_swigt__p_OpalProductDescription,
16558 &_swigt__p_OpalRegistrationStates,
16559 &_swigt__p_OpalSilenceDetectMode,
16560 &_swigt__p_OpalStatusCallCleared,
16561 &_swigt__p_OpalStatusIVR,
16562 &_swigt__p_OpalStatusIncomingCall,
16563 &_swigt__p_OpalStatusLineAppearance,
16564 &_swigt__p_OpalStatusMediaStream,
16565 &_swigt__p_OpalStatusMessageWaiting,
16566 &_swigt__p_OpalStatusRegistration,
16567 &_swigt__p_OpalStatusTransferCall,
16568 &_swigt__p_OpalStatusUserInput,
16569 &_swigt__p_OpalUserInputModes,
16570 &_swigt__p_OpalVideoRecordMixMode,
16571 &_swigt__p_char,
16572 &_swigt__p_f_p_q_const__OpalMessage__int,
16573 &_swigt__p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_void_p_void_int__int,
16574 &_swigt__p_unsigned_int,
16575 &_swigt__p_void,
16576 };
16577
16578 static swig_cast_info _swigc__p_OpalCallEndReason[] = { {&_swigt__p_OpalCallEndReason, 0, 0, 0},{0, 0, 0, 0}};
16579 static swig_cast_info _swigc__p_OpalContext[] = { {&_swigt__p_OpalContext, 0, 0, 0},{0, 0, 0, 0}};
16580 static swig_cast_info _swigc__p_OpalEchoCancelMode[] = { {&_swigt__p_OpalEchoCancelMode, 0, 0, 0},{0, 0, 0, 0}};
16581 static swig_cast_info _swigc__p_OpalHandleStruct[] = { {&_swigt__p_OpalHandleStruct, 0, 0, 0},{0, 0, 0, 0}};
16582 static swig_cast_info _swigc__p_OpalLineAppearanceStates[] = { {&_swigt__p_OpalLineAppearanceStates, 0, 0, 0},{0, 0, 0, 0}};
16583 static swig_cast_info _swigc__p_OpalMediaDataType[] = { {&_swigt__p_OpalMediaDataType, 0, 0, 0},{0, 0, 0, 0}};
16584 static swig_cast_info _swigc__p_OpalMediaStates[] = { {&_swigt__p_OpalMediaStates, 0, 0, 0},{0, 0, 0, 0}};
16585 static swig_cast_info _swigc__p_OpalMediaTiming[] = { {&_swigt__p_OpalMediaTiming, 0, 0, 0},{0, 0, 0, 0}};
16586 static swig_cast_info _swigc__p_OpalMessage[] = { {&_swigt__p_OpalMessage, 0, 0, 0},{0, 0, 0, 0}};
16587 static swig_cast_info _swigc__p_OpalMessagePtr[] = { {&_swigt__p_OpalMessagePtr, 0, 0, 0},{0, 0, 0, 0}};
16588 static swig_cast_info _swigc__p_OpalMessageType[] = { {&_swigt__p_OpalMessageType, 0, 0, 0},{0, 0, 0, 0}};
16589 static swig_cast_info _swigc__p_OpalMessage_m_param[] = { {&_swigt__p_OpalMessage_m_param, 0, 0, 0},{0, 0, 0, 0}};
16590 static swig_cast_info _swigc__p_OpalParamAnswerCall[] = { {&_swigt__p_OpalParamAnswerCall, 0, 0, 0},{0, 0, 0, 0}};
16591 static swig_cast_info _swigc__p_OpalParamCallCleared[] = { {&_swigt__p_OpalParamCallCleared, 0, 0, 0},{0, 0, 0, 0}};
16592 static swig_cast_info _swigc__p_OpalParamGeneral[] = { {&_swigt__p_OpalParamGeneral, 0, 0, 0},{0, 0, 0, 0}};
16593 static swig_cast_info _swigc__p_OpalParamProtocol[] = { {&_swigt__p_OpalParamProtocol, 0, 0, 0},{0, 0, 0, 0}};
16594 static swig_cast_info _swigc__p_OpalParamRecording[] = { {&_swigt__p_OpalParamRecording, 0, 0, 0},{0, 0, 0, 0}};
16595 static swig_cast_info _swigc__p_OpalParamRegistration[] = { {&_swigt__p_OpalParamRegistration, 0, 0, 0},{0, 0, 0, 0}};
16596 static swig_cast_info _swigc__p_OpalParamSetUpCall[] = { {&_swigt__p_OpalParamSetUpCall, 0, 0, 0},{0, 0, 0, 0}};
16597 static swig_cast_info _swigc__p_OpalParamSetUserData[] = { {&_swigt__p_OpalParamSetUserData, 0, 0, 0},{0, 0, 0, 0}};
16598 static swig_cast_info _swigc__p_OpalProductDescription[] = { {&_swigt__p_OpalProductDescription, 0, 0, 0},{0, 0, 0, 0}};
16599 static swig_cast_info _swigc__p_OpalRegistrationStates[] = { {&_swigt__p_OpalRegistrationStates, 0, 0, 0},{0, 0, 0, 0}};
16600 static swig_cast_info _swigc__p_OpalSilenceDetectMode[] = { {&_swigt__p_OpalSilenceDetectMode, 0, 0, 0},{0, 0, 0, 0}};
16601 static swig_cast_info _swigc__p_OpalStatusCallCleared[] = { {&_swigt__p_OpalStatusCallCleared, 0, 0, 0},{0, 0, 0, 0}};
16602 static swig_cast_info _swigc__p_OpalStatusIVR[] = { {&_swigt__p_OpalStatusIVR, 0, 0, 0},{0, 0, 0, 0}};
16603 static swig_cast_info _swigc__p_OpalStatusIncomingCall[] = { {&_swigt__p_OpalStatusIncomingCall, 0, 0, 0},{0, 0, 0, 0}};
16604 static swig_cast_info _swigc__p_OpalStatusLineAppearance[] = { {&_swigt__p_OpalStatusLineAppearance, 0, 0, 0},{0, 0, 0, 0}};
16605 static swig_cast_info _swigc__p_OpalStatusMediaStream[] = { {&_swigt__p_OpalStatusMediaStream, 0, 0, 0},{0, 0, 0, 0}};
16606 static swig_cast_info _swigc__p_OpalStatusMessageWaiting[] = { {&_swigt__p_OpalStatusMessageWaiting, 0, 0, 0},{0, 0, 0, 0}};
16607 static swig_cast_info _swigc__p_OpalStatusRegistration[] = { {&_swigt__p_OpalStatusRegistration, 0, 0, 0},{0, 0, 0, 0}};
16608 static swig_cast_info _swigc__p_OpalStatusTransferCall[] = { {&_swigt__p_OpalStatusTransferCall, 0, 0, 0},{0, 0, 0, 0}};
16609 static swig_cast_info _swigc__p_OpalStatusUserInput[] = { {&_swigt__p_OpalStatusUserInput, 0, 0, 0},{0, 0, 0, 0}};
16610 static swig_cast_info _swigc__p_OpalUserInputModes[] = { {&_swigt__p_OpalUserInputModes, 0, 0, 0},{0, 0, 0, 0}};
16611 static swig_cast_info _swigc__p_OpalVideoRecordMixMode[] = { {&_swigt__p_OpalVideoRecordMixMode, 0, 0, 0},{0, 0, 0, 0}};
16612 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
16613 static swig_cast_info _swigc__p_f_p_q_const__OpalMessage__int[] = { {&_swigt__p_f_p_q_const__OpalMessage__int, 0, 0, 0},{0, 0, 0, 0}};
16614 static swig_cast_info _swigc__p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_void_p_void_int__int[] = { {&_swigt__p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_void_p_void_int__int, 0, 0, 0},{0, 0, 0, 0}};
16615 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
16616 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
16617
16618 static swig_cast_info *swig_cast_initial[] = {
16619 _swigc__p_OpalCallEndReason,
16620 _swigc__p_OpalContext,
16621 _swigc__p_OpalEchoCancelMode,
16622 _swigc__p_OpalHandleStruct,
16623 _swigc__p_OpalLineAppearanceStates,
16624 _swigc__p_OpalMediaDataType,
16625 _swigc__p_OpalMediaStates,
16626 _swigc__p_OpalMediaTiming,
16627 _swigc__p_OpalMessage,
16628 _swigc__p_OpalMessagePtr,
16629 _swigc__p_OpalMessageType,
16630 _swigc__p_OpalMessage_m_param,
16631 _swigc__p_OpalParamAnswerCall,
16632 _swigc__p_OpalParamCallCleared,
16633 _swigc__p_OpalParamGeneral,
16634 _swigc__p_OpalParamProtocol,
16635 _swigc__p_OpalParamRecording,
16636 _swigc__p_OpalParamRegistration,
16637 _swigc__p_OpalParamSetUpCall,
16638 _swigc__p_OpalParamSetUserData,
16639 _swigc__p_OpalProductDescription,
16640 _swigc__p_OpalRegistrationStates,
16641 _swigc__p_OpalSilenceDetectMode,
16642 _swigc__p_OpalStatusCallCleared,
16643 _swigc__p_OpalStatusIVR,
16644 _swigc__p_OpalStatusIncomingCall,
16645 _swigc__p_OpalStatusLineAppearance,
16646 _swigc__p_OpalStatusMediaStream,
16647 _swigc__p_OpalStatusMessageWaiting,
16648 _swigc__p_OpalStatusRegistration,
16649 _swigc__p_OpalStatusTransferCall,
16650 _swigc__p_OpalStatusUserInput,
16651 _swigc__p_OpalUserInputModes,
16652 _swigc__p_OpalVideoRecordMixMode,
16653 _swigc__p_char,
16654 _swigc__p_f_p_q_const__OpalMessage__int,
16655 _swigc__p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_void_p_void_int__int,
16656 _swigc__p_unsigned_int,
16657 _swigc__p_void,
16658 };
16659
16660
16661 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
16662
16663 /* -----------------------------------------------------------------------------
16664 * Type initialization:
16665 * This problem is tough by the requirement that no dynamic
16666 * memory is used. Also, since swig_type_info structures store pointers to
16667 * swig_cast_info structures and swig_cast_info structures store pointers back
16668 * to swig_type_info structures, we need some lookup code at initialization.
16669 * The idea is that swig generates all the structures that are needed.
16670 * The runtime then collects these partially filled structures.
16671 * The SWIG_InitializeModule function takes these initial arrays out of
16672 * swig_module, and does all the lookup, filling in the swig_module.types
16673 * array with the correct data and linking the correct swig_cast_info
16674 * structures together.
16675 *
16676 * The generated swig_type_info structures are assigned staticly to an initial
16677 * array. We just loop through that array, and handle each type individually.
16678 * First we lookup if this type has been already loaded, and if so, use the
16679 * loaded structure instead of the generated one. Then we have to fill in the
16680 * cast linked list. The cast data is initially stored in something like a
16681 * two-dimensional array. Each row corresponds to a type (there are the same
16682 * number of rows as there are in the swig_type_initial array). Each entry in
16683 * a column is one of the swig_cast_info structures for that type.
16684 * The cast_initial array is actually an array of arrays, because each row has
16685 * a variable number of columns. So to actually build the cast linked list,
16686 * we find the array of casts associated with the type, and loop through it
16687 * adding the casts to the list. The one last trick we need to do is making
16688 * sure the type pointer in the swig_cast_info struct is correct.
16689 *
16690 * First off, we lookup the cast->type name to see if it is already loaded.
16691 * There are three cases to handle:
16692 * 1) If the cast->type has already been loaded AND the type we are adding
16693 * casting info to has not been loaded (it is in this module), THEN we
16694 * replace the cast->type pointer with the type pointer that has already
16695 * been loaded.
16696 * 2) If BOTH types (the one we are adding casting info to, and the
16697 * cast->type) are loaded, THEN the cast info has already been loaded by
16698 * the previous module so we just ignore it.
16699 * 3) Finally, if cast->type has not already been loaded, then we add that
16700 * swig_cast_info to the linked list (because the cast->type) pointer will
16701 * be correct.
16702 * ----------------------------------------------------------------------------- */
16703
16704 #ifdef __cplusplus
16705 extern "C" {
16706 #if 0
16707 } /* c-mode */
16708 #endif
16709 #endif
16710
16711 #if 0
16712 #define SWIGRUNTIME_DEBUG
16713 #endif
16714
16715
16716 SWIGRUNTIME void
16717 SWIG_InitializeModule(void *clientdata) {
16718 size_t i;
16719 swig_module_info *module_head, *iter;
16720 int found, init;
16721
16722 clientdata = clientdata;
16723
16724 /* check to see if the circular list has been setup, if not, set it up */
16725 if (swig_module.next==0) {
16726 /* Initialize the swig_module */
16727 swig_module.type_initial = swig_type_initial;
16728 swig_module.cast_initial = swig_cast_initial;
16729 swig_module.next = &swig_module;
16730 init = 1;
16731 } else {
16732 init = 0;
16733 }
16734
16735 /* Try and load any already created modules */
16736 module_head = SWIG_GetModule(clientdata);
16737 if (!module_head) {
16738 /* This is the first module loaded for this interpreter */
16739 /* so set the swig module into the interpreter */
16740 SWIG_SetModule(clientdata, &swig_module);
16741 module_head = &swig_module;
16742 } else {
16743 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
16744 found=0;
16745 iter=module_head;
16746 do {
16747 if (iter==&swig_module) {
16748 found=1;
16749 break;
16750 }
16751 iter=iter->next;
16752 } while (iter!= module_head);
16753
16754 /* if the is found in the list, then all is done and we may leave */
16755 if (found) return;
16756 /* otherwise we must add out module into the list */
16757 swig_module.next = module_head->next;
16758 module_head->next = &swig_module;
16759 }
16760
16761 /* When multiple interpeters are used, a module could have already been initialized in
16762 a different interpreter, but not yet have a pointer in this interpreter.
16763 In this case, we do not want to continue adding types... everything should be
16764 set up already */
16765 if (init == 0) return;
16766
16767 /* Now work on filling in swig_module.types */
16768 #ifdef SWIGRUNTIME_DEBUG
16769 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
16770 #endif
16771 for (i = 0; i < swig_module.size; ++i) {
16772 swig_type_info *type = 0;
16773 swig_type_info *ret;
16774 swig_cast_info *cast;
16775
16776 #ifdef SWIGRUNTIME_DEBUG
16777 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
16778 #endif
16779
16780 /* if there is another module already loaded */
16781 if (swig_module.next != &swig_module) {
16782 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
16783 }
16784 if (type) {
16785 /* Overwrite clientdata field */
16786 #ifdef SWIGRUNTIME_DEBUG
16787 printf("SWIG_InitializeModule: found type %s\n", type->name);
16788 #endif
16789 if (swig_module.type_initial[i]->clientdata) {
16790 type->clientdata = swig_module.type_initial[i]->clientdata;
16791 #ifdef SWIGRUNTIME_DEBUG
16792 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
16793 #endif
16794 }
16795 } else {
16796 type = swig_module.type_initial[i];
16797 }
16798
16799 /* Insert casting types */
16800 cast = swig_module.cast_initial[i];
16801 while (cast->type) {
16802
16803 /* Don't need to add information already in the list */
16804 ret = 0;
16805 #ifdef SWIGRUNTIME_DEBUG
16806 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
16807 #endif
16808 if (swig_module.next != &swig_module) {
16809 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
16810 #ifdef SWIGRUNTIME_DEBUG
16811 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
16812 #endif
16813 }
16814 if (ret) {
16815 if (type == swig_module.type_initial[i]) {
16816 #ifdef SWIGRUNTIME_DEBUG
16817 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
16818 #endif
16819 cast->type = ret;
16820 ret = 0;
16821 } else {
16822 /* Check for casting already in the list */
16823 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
16824 #ifdef SWIGRUNTIME_DEBUG
16825 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
16826 #endif
16827 if (!ocast) ret = 0;
16828 }
16829 }
16830
16831 if (!ret) {
16832 #ifdef SWIGRUNTIME_DEBUG
16833 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
16834 #endif
16835 if (type->cast) {
16836 type->cast->prev = cast;
16837 cast->next = type->cast;
16838 }
16839 type->cast = cast;
16840 }
16841 cast++;
16842 }
16843 /* Set entry in modules->types array equal to the type */
16844 swig_module.types[i] = type;
16845 }
16846 swig_module.types[i] = 0;
16847
16848 #ifdef SWIGRUNTIME_DEBUG
16849 printf("**** SWIG_InitializeModule: Cast List ******\n");
16850 for (i = 0; i < swig_module.size; ++i) {
16851 int j = 0;
16852 swig_cast_info *cast = swig_module.cast_initial[i];
16853 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
16854 while (cast->type) {
16855 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
16856 cast++;
16857 ++j;
16858 }
16859 printf("---- Total casts: %d\n",j);
16860 }
16861 printf("**** SWIG_InitializeModule: Cast List ******\n");
16862 #endif
16863 }
16864
16865 /* This function will propagate the clientdata field of type to
16866 * any new swig_type_info structures that have been added into the list
16867 * of equivalent types. It is like calling
16868 * SWIG_TypeClientData(type, clientdata) a second time.
16869 */
16870 SWIGRUNTIME void
16871 SWIG_PropagateClientData(void) {
16872 size_t i;
16873 swig_cast_info *equiv;
16874 static int init_run = 0;
16875
16876 if (init_run) return;
16877 init_run = 1;
16878
16879 for (i = 0; i < swig_module.size; i++) {
16880 if (swig_module.types[i]->clientdata) {
16881 equiv = swig_module.types[i]->cast;
16882 while (equiv) {
16883 if (!equiv->converter) {
16884 if (equiv->type && !equiv->type->clientdata)
16885 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
16886 }
16887 equiv = equiv->next;
16888 }
16889 }
16890 }
16891 }
16892
16893 #ifdef __cplusplus
16894 #if 0
16895 { /* c-mode */
16896 #endif
16897 }
16898 #endif
16899
16900 /*
16901
16902 */
16903 #ifdef __cplusplus
16904 extern "C"
16905 #endif
16906 SWIGEXPORT void Init_opal(void) {
16907 size_t i;
16908
16909 SWIG_InitRuntime();
16910 mOpal = rb_define_module("Opal");
16911
16912 SWIG_InitializeModule(0);
16913 for (i = 0; i < swig_module.size; i++) {
16914 SWIG_define_class(swig_module.types[i]);
16915 }
16916
16917 SWIG_RubyInitializeTrackings();
16918 rb_define_const(mOpal, "OPAL_C_API_VERSION", SWIG_From_int(static_cast< int >(27)));
16919 rb_define_module_function(mOpal, "OpalInitialise", VALUEFUNC(_wrap_OpalInitialise), -1);
16920 rb_define_const(mOpal, "OPAL_INITIALISE_FUNCTION", SWIG_FromCharPtr("OpalInitialise"));
16921 rb_define_module_function(mOpal, "OpalShutDown", VALUEFUNC(_wrap_OpalShutDown), -1);
16922 rb_define_const(mOpal, "OPAL_SHUTDOWN_FUNCTION", SWIG_FromCharPtr("OpalShutDown"));
16923 rb_define_module_function(mOpal, "OpalGetMessage", VALUEFUNC(_wrap_OpalGetMessage), -1);
16924 rb_define_const(mOpal, "OPAL_GET_MESSAGE_FUNCTION", SWIG_FromCharPtr("OpalGetMessage"));
16925 rb_define_module_function(mOpal, "OpalSendMessage", VALUEFUNC(_wrap_OpalSendMessage), -1);
16926 rb_define_const(mOpal, "OPAL_SEND_MESSAGE_FUNCTION", SWIG_FromCharPtr("OpalSendMessage"));
16927 rb_define_module_function(mOpal, "OpalFreeMessage", VALUEFUNC(_wrap_OpalFreeMessage), -1);
16928 rb_define_const(mOpal, "OPAL_FREE_MESSAGE_FUNCTION", SWIG_FromCharPtr("OpalFreeMessage"));
16929 rb_define_const(mOpal, "OPAL_PREFIX_H323", SWIG_FromCharPtr("h323"));
16930 rb_define_const(mOpal, "OPAL_PREFIX_SIP", SWIG_FromCharPtr("sip"));
16931 rb_define_const(mOpal, "OPAL_PREFIX_IAX2", SWIG_FromCharPtr("iax2"));
16932 rb_define_const(mOpal, "OPAL_PREFIX_PCSS", SWIG_FromCharPtr("pc"));
16933 rb_define_const(mOpal, "OPAL_PREFIX_LOCAL", SWIG_FromCharPtr("local"));
16934 rb_define_const(mOpal, "OPAL_PREFIX_POTS", SWIG_FromCharPtr("pots"));
16935 rb_define_const(mOpal, "OPAL_PREFIX_PSTN", SWIG_FromCharPtr("pstn"));
16936 rb_define_const(mOpal, "OPAL_PREFIX_IVR", SWIG_FromCharPtr("ivr"));
16937 rb_define_const(mOpal, "OPAL_PREFIX_ALL", SWIG_FromCharPtr("h323 sip iax2 pc local pots pstn ivr"));
16938 rb_define_const(mOpal, "OpalIndCommandError", SWIG_From_int(static_cast< int >(OpalIndCommandError)));
16939 rb_define_const(mOpal, "OpalCmdSetGeneralParameters", SWIG_From_int(static_cast< int >(OpalCmdSetGeneralParameters)));
16940 rb_define_const(mOpal, "OpalCmdSetProtocolParameters", SWIG_From_int(static_cast< int >(OpalCmdSetProtocolParameters)));
16941 rb_define_const(mOpal, "OpalCmdRegistration", SWIG_From_int(static_cast< int >(OpalCmdRegistration)));
16942 rb_define_const(mOpal, "OpalIndRegistration", SWIG_From_int(static_cast< int >(OpalIndRegistration)));
16943 rb_define_const(mOpal, "OpalCmdSetUpCall", SWIG_From_int(static_cast< int >(OpalCmdSetUpCall)));
16944 rb_define_const(mOpal, "OpalIndIncomingCall", SWIG_From_int(static_cast< int >(OpalIndIncomingCall)));
16945 rb_define_const(mOpal, "OpalCmdAnswerCall", SWIG_From_int(static_cast< int >(OpalCmdAnswerCall)));
16946 rb_define_const(mOpal, "OpalCmdClearCall", SWIG_From_int(static_cast< int >(OpalCmdClearCall)));
16947 rb_define_const(mOpal, "OpalIndAlerting", SWIG_From_int(static_cast< int >(OpalIndAlerting)));
16948 rb_define_const(mOpal, "OpalIndEstablished", SWIG_From_int(static_cast< int >(OpalIndEstablished)));
16949 rb_define_const(mOpal, "OpalIndUserInput", SWIG_From_int(static_cast< int >(OpalIndUserInput)));
16950 rb_define_const(mOpal, "OpalIndCallCleared", SWIG_From_int(static_cast< int >(OpalIndCallCleared)));
16951 rb_define_const(mOpal, "OpalCmdHoldCall", SWIG_From_int(static_cast< int >(OpalCmdHoldCall)));
16952 rb_define_const(mOpal, "OpalCmdRetrieveCall", SWIG_From_int(static_cast< int >(OpalCmdRetrieveCall)));
16953 rb_define_const(mOpal, "OpalCmdTransferCall", SWIG_From_int(static_cast< int >(OpalCmdTransferCall)));
16954 rb_define_const(mOpal, "OpalCmdUserInput", SWIG_From_int(static_cast< int >(OpalCmdUserInput)));
16955 rb_define_const(mOpal, "OpalIndMessageWaiting", SWIG_From_int(static_cast< int >(OpalIndMessageWaiting)));
16956 rb_define_const(mOpal, "OpalIndMediaStream", SWIG_From_int(static_cast< int >(OpalIndMediaStream)));
16957 rb_define_const(mOpal, "OpalCmdMediaStream", SWIG_From_int(static_cast< int >(OpalCmdMediaStream)));
16958 rb_define_const(mOpal, "OpalCmdSetUserData", SWIG_From_int(static_cast< int >(OpalCmdSetUserData)));
16959 rb_define_const(mOpal, "OpalIndLineAppearance", SWIG_From_int(static_cast< int >(OpalIndLineAppearance)));
16960 rb_define_const(mOpal, "OpalCmdStartRecording", SWIG_From_int(static_cast< int >(OpalCmdStartRecording)));
16961 rb_define_const(mOpal, "OpalCmdStopRecording", SWIG_From_int(static_cast< int >(OpalCmdStopRecording)));
16962 rb_define_const(mOpal, "OpalIndProceeding", SWIG_From_int(static_cast< int >(OpalIndProceeding)));
16963 rb_define_const(mOpal, "OpalCmdAlerting", SWIG_From_int(static_cast< int >(OpalCmdAlerting)));
16964 rb_define_const(mOpal, "OpalIndOnHold", SWIG_From_int(static_cast< int >(OpalIndOnHold)));
16965 rb_define_const(mOpal, "OpalIndOffHold", SWIG_From_int(static_cast< int >(OpalIndOffHold)));
16966 rb_define_const(mOpal, "OpalIndTransferCall", SWIG_From_int(static_cast< int >(OpalIndTransferCall)));
16967 rb_define_const(mOpal, "OpalIndCompletedIVR", SWIG_From_int(static_cast< int >(OpalIndCompletedIVR)));
16968 rb_define_const(mOpal, "OpalMessageTypeCount", SWIG_From_int(static_cast< int >(OpalMessageTypeCount)));
16969 rb_define_const(mOpal, "OpalSilenceDetectNoChange", SWIG_From_int(static_cast< int >(OpalSilenceDetectNoChange)));
16970 rb_define_const(mOpal, "OpalSilenceDetectDisabled", SWIG_From_int(static_cast< int >(OpalSilenceDetectDisabled)));
16971 rb_define_const(mOpal, "OpalSilenceDetectFixed", SWIG_From_int(static_cast< int >(OpalSilenceDetectFixed)));
16972 rb_define_const(mOpal, "OpalSilenceDetectAdaptive", SWIG_From_int(static_cast< int >(OpalSilenceDetectAdaptive)));
16973 rb_define_const(mOpal, "OpalEchoCancelNoChange", SWIG_From_int(static_cast< int >(OpalEchoCancelNoChange)));
16974 rb_define_const(mOpal, "OpalEchoCancelDisabled", SWIG_From_int(static_cast< int >(OpalEchoCancelDisabled)));
16975 rb_define_const(mOpal, "OpalEchoCancelEnabled", SWIG_From_int(static_cast< int >(OpalEchoCancelEnabled)));
16976 rb_define_const(mOpal, "OpalMediaDataNoChange", SWIG_From_int(static_cast< int >(OpalMediaDataNoChange)));
16977 rb_define_const(mOpal, "OpalMediaDataPayloadOnly", SWIG_From_int(static_cast< int >(OpalMediaDataPayloadOnly)));
16978 rb_define_const(mOpal, "OpalMediaDataWithHeader", SWIG_From_int(static_cast< int >(OpalMediaDataWithHeader)));
16979 rb_define_const(mOpal, "OpalMediaTimingNoChange", SWIG_From_int(static_cast< int >(OpalMediaTimingNoChange)));
16980 rb_define_const(mOpal, "OpalMediaTimingSynchronous", SWIG_From_int(static_cast< int >(OpalMediaTimingSynchronous)));
16981 rb_define_const(mOpal, "OpalMediaTimingAsynchronous", SWIG_From_int(static_cast< int >(OpalMediaTimingAsynchronous)));
16982 rb_define_const(mOpal, "OpalMediaTimingSimulated", SWIG_From_int(static_cast< int >(OpalMediaTimingSimulated)));
16983
16984 SwigClassOpalParamGeneral.klass = rb_define_class_under(mOpal, "OpalParamGeneral", rb_cObject);
16985 SWIG_TypeClientData(SWIGTYPE_p_OpalParamGeneral, (void *) &SwigClassOpalParamGeneral);
16986 rb_define_alloc_func(SwigClassOpalParamGeneral.klass, _wrap_OpalParamGeneral_allocate);
16987 rb_define_method(SwigClassOpalParamGeneral.klass, "initialize", VALUEFUNC(_wrap_new_OpalParamGeneral), -1);
16988 rb_define_method(SwigClassOpalParamGeneral.klass, "m_audioRecordDevice=", VALUEFUNC(_wrap_OpalParamGeneral_m_audioRecordDevice_set), -1);
16989 rb_define_method(SwigClassOpalParamGeneral.klass, "m_audioRecordDevice", VALUEFUNC(_wrap_OpalParamGeneral_m_audioRecordDevice_get), -1);
16990 rb_define_method(SwigClassOpalParamGeneral.klass, "m_audioPlayerDevice=", VALUEFUNC(_wrap_OpalParamGeneral_m_audioPlayerDevice_set), -1);
16991 rb_define_method(SwigClassOpalParamGeneral.klass, "m_audioPlayerDevice", VALUEFUNC(_wrap_OpalParamGeneral_m_audioPlayerDevice_get), -1);
16992 rb_define_method(SwigClassOpalParamGeneral.klass, "m_videoInputDevice=", VALUEFUNC(_wrap_OpalParamGeneral_m_videoInputDevice_set), -1);
16993 rb_define_method(SwigClassOpalParamGeneral.klass, "m_videoInputDevice", VALUEFUNC(_wrap_OpalParamGeneral_m_videoInputDevice_get), -1);
16994 rb_define_method(SwigClassOpalParamGeneral.klass, "m_videoOutputDevice=", VALUEFUNC(_wrap_OpalParamGeneral_m_videoOutputDevice_set), -1);
16995 rb_define_method(SwigClassOpalParamGeneral.klass, "m_videoOutputDevice", VALUEFUNC(_wrap_OpalParamGeneral_m_videoOutputDevice_get), -1);
16996 rb_define_method(SwigClassOpalParamGeneral.klass, "m_videoPreviewDevice=", VALUEFUNC(_wrap_OpalParamGeneral_m_videoPreviewDevice_set), -1);
16997 rb_define_method(SwigClassOpalParamGeneral.klass, "m_videoPreviewDevice", VALUEFUNC(_wrap_OpalParamGeneral_m_videoPreviewDevice_get), -1);
16998 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaOrder=", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaOrder_set), -1);
16999 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaOrder", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaOrder_get), -1);
17000 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaMask=", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaMask_set), -1);
17001 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaMask", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaMask_get), -1);
17002 rb_define_method(SwigClassOpalParamGeneral.klass, "m_autoRxMedia=", VALUEFUNC(_wrap_OpalParamGeneral_m_autoRxMedia_set), -1);
17003 rb_define_method(SwigClassOpalParamGeneral.klass, "m_autoRxMedia", VALUEFUNC(_wrap_OpalParamGeneral_m_autoRxMedia_get), -1);
17004 rb_define_method(SwigClassOpalParamGeneral.klass, "m_autoTxMedia=", VALUEFUNC(_wrap_OpalParamGeneral_m_autoTxMedia_set), -1);
17005 rb_define_method(SwigClassOpalParamGeneral.klass, "m_autoTxMedia", VALUEFUNC(_wrap_OpalParamGeneral_m_autoTxMedia_get), -1);
17006 rb_define_method(SwigClassOpalParamGeneral.klass, "m_natRouter=", VALUEFUNC(_wrap_OpalParamGeneral_m_natRouter_set), -1);
17007 rb_define_method(SwigClassOpalParamGeneral.klass, "m_natRouter", VALUEFUNC(_wrap_OpalParamGeneral_m_natRouter_get), -1);
17008 rb_define_method(SwigClassOpalParamGeneral.klass, "m_stunServer=", VALUEFUNC(_wrap_OpalParamGeneral_m_stunServer_set), -1);
17009 rb_define_method(SwigClassOpalParamGeneral.klass, "m_stunServer", VALUEFUNC(_wrap_OpalParamGeneral_m_stunServer_get), -1);
17010 rb_define_method(SwigClassOpalParamGeneral.klass, "m_tcpPortBase=", VALUEFUNC(_wrap_OpalParamGeneral_m_tcpPortBase_set), -1);
17011 rb_define_method(SwigClassOpalParamGeneral.klass, "m_tcpPortBase", VALUEFUNC(_wrap_OpalParamGeneral_m_tcpPortBase_get), -1);
17012 rb_define_method(SwigClassOpalParamGeneral.klass, "m_tcpPortMax=", VALUEFUNC(_wrap_OpalParamGeneral_m_tcpPortMax_set), -1);
17013 rb_define_method(SwigClassOpalParamGeneral.klass, "m_tcpPortMax", VALUEFUNC(_wrap_OpalParamGeneral_m_tcpPortMax_get), -1);
17014 rb_define_method(SwigClassOpalParamGeneral.klass, "m_udpPortBase=", VALUEFUNC(_wrap_OpalParamGeneral_m_udpPortBase_set), -1);
17015 rb_define_method(SwigClassOpalParamGeneral.klass, "m_udpPortBase", VALUEFUNC(_wrap_OpalParamGeneral_m_udpPortBase_get), -1);
17016 rb_define_method(SwigClassOpalParamGeneral.klass, "m_udpPortMax=", VALUEFUNC(_wrap_OpalParamGeneral_m_udpPortMax_set), -1);
17017 rb_define_method(SwigClassOpalParamGeneral.klass, "m_udpPortMax", VALUEFUNC(_wrap_OpalParamGeneral_m_udpPortMax_get), -1);
17018 rb_define_method(SwigClassOpalParamGeneral.klass, "m_rtpPortBase=", VALUEFUNC(_wrap_OpalParamGeneral_m_rtpPortBase_set), -1);
17019 rb_define_method(SwigClassOpalParamGeneral.klass, "m_rtpPortBase", VALUEFUNC(_wrap_OpalParamGeneral_m_rtpPortBase_get), -1);
17020 rb_define_method(SwigClassOpalParamGeneral.klass, "m_rtpPortMax=", VALUEFUNC(_wrap_OpalParamGeneral_m_rtpPortMax_set), -1);
17021 rb_define_method(SwigClassOpalParamGeneral.klass, "m_rtpPortMax", VALUEFUNC(_wrap_OpalParamGeneral_m_rtpPortMax_get), -1);
17022 rb_define_method(SwigClassOpalParamGeneral.klass, "m_rtpTypeOfService=", VALUEFUNC(_wrap_OpalParamGeneral_m_rtpTypeOfService_set), -1);
17023 rb_define_method(SwigClassOpalParamGeneral.klass, "m_rtpTypeOfService", VALUEFUNC(_wrap_OpalParamGeneral_m_rtpTypeOfService_get), -1);
17024 rb_define_method(SwigClassOpalParamGeneral.klass, "m_rtpMaxPayloadSize=", VALUEFUNC(_wrap_OpalParamGeneral_m_rtpMaxPayloadSize_set), -1);
17025 rb_define_method(SwigClassOpalParamGeneral.klass, "m_rtpMaxPayloadSize", VALUEFUNC(_wrap_OpalParamGeneral_m_rtpMaxPayloadSize_get), -1);
17026 rb_define_method(SwigClassOpalParamGeneral.klass, "m_minAudioJitter=", VALUEFUNC(_wrap_OpalParamGeneral_m_minAudioJitter_set), -1);
17027 rb_define_method(SwigClassOpalParamGeneral.klass, "m_minAudioJitter", VALUEFUNC(_wrap_OpalParamGeneral_m_minAudioJitter_get), -1);
17028 rb_define_method(SwigClassOpalParamGeneral.klass, "m_maxAudioJitter=", VALUEFUNC(_wrap_OpalParamGeneral_m_maxAudioJitter_set), -1);
17029 rb_define_method(SwigClassOpalParamGeneral.klass, "m_maxAudioJitter", VALUEFUNC(_wrap_OpalParamGeneral_m_maxAudioJitter_get), -1);
17030 rb_define_method(SwigClassOpalParamGeneral.klass, "m_silenceDetectMode=", VALUEFUNC(_wrap_OpalParamGeneral_m_silenceDetectMode_set), -1);
17031 rb_define_method(SwigClassOpalParamGeneral.klass, "m_silenceDetectMode", VALUEFUNC(_wrap_OpalParamGeneral_m_silenceDetectMode_get), -1);
17032 rb_define_method(SwigClassOpalParamGeneral.klass, "m_silenceThreshold=", VALUEFUNC(_wrap_OpalParamGeneral_m_silenceThreshold_set), -1);
17033 rb_define_method(SwigClassOpalParamGeneral.klass, "m_silenceThreshold", VALUEFUNC(_wrap_OpalParamGeneral_m_silenceThreshold_get), -1);
17034 rb_define_method(SwigClassOpalParamGeneral.klass, "m_signalDeadband=", VALUEFUNC(_wrap_OpalParamGeneral_m_signalDeadband_set), -1);
17035 rb_define_method(SwigClassOpalParamGeneral.klass, "m_signalDeadband", VALUEFUNC(_wrap_OpalParamGeneral_m_signalDeadband_get), -1);
17036 rb_define_method(SwigClassOpalParamGeneral.klass, "m_silenceDeadband=", VALUEFUNC(_wrap_OpalParamGeneral_m_silenceDeadband_set), -1);
17037 rb_define_method(SwigClassOpalParamGeneral.klass, "m_silenceDeadband", VALUEFUNC(_wrap_OpalParamGeneral_m_silenceDeadband_get), -1);
17038 rb_define_method(SwigClassOpalParamGeneral.klass, "m_silenceAdaptPeriod=", VALUEFUNC(_wrap_OpalParamGeneral_m_silenceAdaptPeriod_set), -1);
17039 rb_define_method(SwigClassOpalParamGeneral.klass, "m_silenceAdaptPeriod", VALUEFUNC(_wrap_OpalParamGeneral_m_silenceAdaptPeriod_get), -1);
17040 rb_define_method(SwigClassOpalParamGeneral.klass, "m_echoCancellation=", VALUEFUNC(_wrap_OpalParamGeneral_m_echoCancellation_set), -1);
17041 rb_define_method(SwigClassOpalParamGeneral.klass, "m_echoCancellation", VALUEFUNC(_wrap_OpalParamGeneral_m_echoCancellation_get), -1);
17042 rb_define_method(SwigClassOpalParamGeneral.klass, "m_audioBuffers=", VALUEFUNC(_wrap_OpalParamGeneral_m_audioBuffers_set), -1);
17043 rb_define_method(SwigClassOpalParamGeneral.klass, "m_audioBuffers", VALUEFUNC(_wrap_OpalParamGeneral_m_audioBuffers_get), -1);
17044 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaReadData=", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaReadData_set), -1);
17045 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaReadData", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaReadData_get), -1);
17046 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaWriteData=", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaWriteData_set), -1);
17047 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaWriteData", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaWriteData_get), -1);
17048 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaDataHeader=", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaDataHeader_set), -1);
17049 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaDataHeader", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaDataHeader_get), -1);
17050 rb_define_method(SwigClassOpalParamGeneral.klass, "m_messageAvailable=", VALUEFUNC(_wrap_OpalParamGeneral_m_messageAvailable_set), -1);
17051 rb_define_method(SwigClassOpalParamGeneral.klass, "m_messageAvailable", VALUEFUNC(_wrap_OpalParamGeneral_m_messageAvailable_get), -1);
17052 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaOptions=", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaOptions_set), -1);
17053 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaOptions", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaOptions_get), -1);
17054 rb_define_method(SwigClassOpalParamGeneral.klass, "m_audioBufferTime=", VALUEFUNC(_wrap_OpalParamGeneral_m_audioBufferTime_set), -1);
17055 rb_define_method(SwigClassOpalParamGeneral.klass, "m_audioBufferTime", VALUEFUNC(_wrap_OpalParamGeneral_m_audioBufferTime_get), -1);
17056 rb_define_method(SwigClassOpalParamGeneral.klass, "m_manualAlerting=", VALUEFUNC(_wrap_OpalParamGeneral_m_manualAlerting_set), -1);
17057 rb_define_method(SwigClassOpalParamGeneral.klass, "m_manualAlerting", VALUEFUNC(_wrap_OpalParamGeneral_m_manualAlerting_get), -1);
17058 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaTiming=", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaTiming_set), -1);
17059 rb_define_method(SwigClassOpalParamGeneral.klass, "m_mediaTiming", VALUEFUNC(_wrap_OpalParamGeneral_m_mediaTiming_get), -1);
17060 rb_define_method(SwigClassOpalParamGeneral.klass, "m_videoSourceTiming=", VALUEFUNC(_wrap_OpalParamGeneral_m_videoSourceTiming_set), -1);
17061 rb_define_method(SwigClassOpalParamGeneral.klass, "m_videoSourceTiming", VALUEFUNC(_wrap_OpalParamGeneral_m_videoSourceTiming_get), -1);
17062 SwigClassOpalParamGeneral.mark = 0;
17063 SwigClassOpalParamGeneral.destroy = (void (*)(void *)) free_OpalParamGeneral;
17064 SwigClassOpalParamGeneral.trackObjects = 0;
17065
17066 SwigClassOpalProductDescription.klass = rb_define_class_under(mOpal, "OpalProductDescription", rb_cObject);
17067 SWIG_TypeClientData(SWIGTYPE_p_OpalProductDescription, (void *) &SwigClassOpalProductDescription);
17068 rb_define_alloc_func(SwigClassOpalProductDescription.klass, _wrap_OpalProductDescription_allocate);
17069 rb_define_method(SwigClassOpalProductDescription.klass, "initialize", VALUEFUNC(_wrap_new_OpalProductDescription), -1);
17070 rb_define_method(SwigClassOpalProductDescription.klass, "m_vendor=", VALUEFUNC(_wrap_OpalProductDescription_m_vendor_set), -1);
17071 rb_define_method(SwigClassOpalProductDescription.klass, "m_vendor", VALUEFUNC(_wrap_OpalProductDescription_m_vendor_get), -1);
17072 rb_define_method(SwigClassOpalProductDescription.klass, "m_name=", VALUEFUNC(_wrap_OpalProductDescription_m_name_set), -1);
17073 rb_define_method(SwigClassOpalProductDescription.klass, "m_name", VALUEFUNC(_wrap_OpalProductDescription_m_name_get), -1);
17074 rb_define_method(SwigClassOpalProductDescription.klass, "m_version=", VALUEFUNC(_wrap_OpalProductDescription_m_version_set), -1);
17075 rb_define_method(SwigClassOpalProductDescription.klass, "m_version", VALUEFUNC(_wrap_OpalProductDescription_m_version_get), -1);
17076 rb_define_method(SwigClassOpalProductDescription.klass, "m_t35CountryCode=", VALUEFUNC(_wrap_OpalProductDescription_m_t35CountryCode_set), -1);
17077 rb_define_method(SwigClassOpalProductDescription.klass, "m_t35CountryCode", VALUEFUNC(_wrap_OpalProductDescription_m_t35CountryCode_get), -1);
17078 rb_define_method(SwigClassOpalProductDescription.klass, "m_t35Extension=", VALUEFUNC(_wrap_OpalProductDescription_m_t35Extension_set), -1);
17079 rb_define_method(SwigClassOpalProductDescription.klass, "m_t35Extension", VALUEFUNC(_wrap_OpalProductDescription_m_t35Extension_get), -1);
17080 rb_define_method(SwigClassOpalProductDescription.klass, "m_manufacturerCode=", VALUEFUNC(_wrap_OpalProductDescription_m_manufacturerCode_set), -1);
17081 rb_define_method(SwigClassOpalProductDescription.klass, "m_manufacturerCode", VALUEFUNC(_wrap_OpalProductDescription_m_manufacturerCode_get), -1);
17082 SwigClassOpalProductDescription.mark = 0;
17083 SwigClassOpalProductDescription.destroy = (void (*)(void *)) free_OpalProductDescription;
17084 SwigClassOpalProductDescription.trackObjects = 0;
17085 rb_define_const(mOpal, "OpalUserInputDefault", SWIG_From_int(static_cast< int >(OpalUserInputDefault)));
17086 rb_define_const(mOpal, "OpalUserInputAsQ931", SWIG_From_int(static_cast< int >(OpalUserInputAsQ931)));
17087 rb_define_const(mOpal, "OpalUserInputAsString", SWIG_From_int(static_cast< int >(OpalUserInputAsString)));
17088 rb_define_const(mOpal, "OpalUserInputAsTone", SWIG_From_int(static_cast< int >(OpalUserInputAsTone)));
17089 rb_define_const(mOpal, "OpalUserInputAsRFC2833", SWIG_From_int(static_cast< int >(OpalUserInputAsRFC2833)));
17090 rb_define_const(mOpal, "OpalUserInputInBand", SWIG_From_int(static_cast< int >(OpalUserInputInBand)));
17091
17092 SwigClassOpalParamProtocol.klass = rb_define_class_under(mOpal, "OpalParamProtocol", rb_cObject);
17093 SWIG_TypeClientData(SWIGTYPE_p_OpalParamProtocol, (void *) &SwigClassOpalParamProtocol);
17094 rb_define_alloc_func(SwigClassOpalParamProtocol.klass, _wrap_OpalParamProtocol_allocate);
17095 rb_define_method(SwigClassOpalParamProtocol.klass, "initialize", VALUEFUNC(_wrap_new_OpalParamProtocol), -1);
17096 rb_define_method(SwigClassOpalParamProtocol.klass, "m_prefix=", VALUEFUNC(_wrap_OpalParamProtocol_m_prefix_set), -1);
17097 rb_define_method(SwigClassOpalParamProtocol.klass, "m_prefix", VALUEFUNC(_wrap_OpalParamProtocol_m_prefix_get), -1);
17098 rb_define_method(SwigClassOpalParamProtocol.klass, "m_userName=", VALUEFUNC(_wrap_OpalParamProtocol_m_userName_set), -1);
17099 rb_define_method(SwigClassOpalParamProtocol.klass, "m_userName", VALUEFUNC(_wrap_OpalParamProtocol_m_userName_get), -1);
17100 rb_define_method(SwigClassOpalParamProtocol.klass, "m_displayName=", VALUEFUNC(_wrap_OpalParamProtocol_m_displayName_set), -1);
17101 rb_define_method(SwigClassOpalParamProtocol.klass, "m_displayName", VALUEFUNC(_wrap_OpalParamProtocol_m_displayName_get), -1);
17102 rb_define_method(SwigClassOpalParamProtocol.klass, "m_product=", VALUEFUNC(_wrap_OpalParamProtocol_m_product_set), -1);
17103 rb_define_method(SwigClassOpalParamProtocol.klass, "m_product", VALUEFUNC(_wrap_OpalParamProtocol_m_product_get), -1);
17104 rb_define_method(SwigClassOpalParamProtocol.klass, "m_interfaceAddresses=", VALUEFUNC(_wrap_OpalParamProtocol_m_interfaceAddresses_set), -1);
17105 rb_define_method(SwigClassOpalParamProtocol.klass, "m_interfaceAddresses", VALUEFUNC(_wrap_OpalParamProtocol_m_interfaceAddresses_get), -1);
17106 rb_define_method(SwigClassOpalParamProtocol.klass, "m_userInputMode=", VALUEFUNC(_wrap_OpalParamProtocol_m_userInputMode_set), -1);
17107 rb_define_method(SwigClassOpalParamProtocol.klass, "m_userInputMode", VALUEFUNC(_wrap_OpalParamProtocol_m_userInputMode_get), -1);
17108 rb_define_method(SwigClassOpalParamProtocol.klass, "m_defaultOptions=", VALUEFUNC(_wrap_OpalParamProtocol_m_defaultOptions_set), -1);
17109 rb_define_method(SwigClassOpalParamProtocol.klass, "m_defaultOptions", VALUEFUNC(_wrap_OpalParamProtocol_m_defaultOptions_get), -1);
17110 SwigClassOpalParamProtocol.mark = 0;
17111 SwigClassOpalParamProtocol.destroy = (void (*)(void *)) free_OpalParamProtocol;
17112 SwigClassOpalParamProtocol.trackObjects = 0;
17113 rb_define_const(mOpal, "OPAL_MWI_EVENT_PACKAGE", SWIG_FromCharPtr("message-summary"));
17114 rb_define_const(mOpal, "OPAL_LINE_APPEARANCE_EVENT_PACKAGE", SWIG_FromCharPtr("dialog;sla;ma"));
17115
17116 SwigClassOpalParamRegistration.klass = rb_define_class_under(mOpal, "OpalParamRegistration", rb_cObject);
17117 SWIG_TypeClientData(SWIGTYPE_p_OpalParamRegistration, (void *) &SwigClassOpalParamRegistration);
17118 rb_define_alloc_func(SwigClassOpalParamRegistration.klass, _wrap_OpalParamRegistration_allocate);
17119 rb_define_method(SwigClassOpalParamRegistration.klass, "initialize", VALUEFUNC(_wrap_new_OpalParamRegistration), -1);
17120 rb_define_method(SwigClassOpalParamRegistration.klass, "m_protocol=", VALUEFUNC(_wrap_OpalParamRegistration_m_protocol_set), -1);
17121 rb_define_method(SwigClassOpalParamRegistration.klass, "m_protocol", VALUEFUNC(_wrap_OpalParamRegistration_m_protocol_get), -1);
17122 rb_define_method(SwigClassOpalParamRegistration.klass, "m_identifier=", VALUEFUNC(_wrap_OpalParamRegistration_m_identifier_set), -1);
17123 rb_define_method(SwigClassOpalParamRegistration.klass, "m_identifier", VALUEFUNC(_wrap_OpalParamRegistration_m_identifier_get), -1);
17124 rb_define_method(SwigClassOpalParamRegistration.klass, "m_hostName=", VALUEFUNC(_wrap_OpalParamRegistration_m_hostName_set), -1);
17125 rb_define_method(SwigClassOpalParamRegistration.klass, "m_hostName", VALUEFUNC(_wrap_OpalParamRegistration_m_hostName_get), -1);
17126 rb_define_method(SwigClassOpalParamRegistration.klass, "m_authUserName=", VALUEFUNC(_wrap_OpalParamRegistration_m_authUserName_set), -1);
17127 rb_define_method(SwigClassOpalParamRegistration.klass, "m_authUserName", VALUEFUNC(_wrap_OpalParamRegistration_m_authUserName_get), -1);
17128 rb_define_method(SwigClassOpalParamRegistration.klass, "m_password=", VALUEFUNC(_wrap_OpalParamRegistration_m_password_set), -1);
17129 rb_define_method(SwigClassOpalParamRegistration.klass, "m_password", VALUEFUNC(_wrap_OpalParamRegistration_m_password_get), -1);
17130 rb_define_method(SwigClassOpalParamRegistration.klass, "m_adminEntity=", VALUEFUNC(_wrap_OpalParamRegistration_m_adminEntity_set), -1);
17131 rb_define_method(SwigClassOpalParamRegistration.klass, "m_adminEntity", VALUEFUNC(_wrap_OpalParamRegistration_m_adminEntity_get), -1);
17132 rb_define_method(SwigClassOpalParamRegistration.klass, "m_timeToLive=", VALUEFUNC(_wrap_OpalParamRegistration_m_timeToLive_set), -1);
17133 rb_define_method(SwigClassOpalParamRegistration.klass, "m_timeToLive", VALUEFUNC(_wrap_OpalParamRegistration_m_timeToLive_get), -1);
17134 rb_define_method(SwigClassOpalParamRegistration.klass, "m_restoreTime=", VALUEFUNC(_wrap_OpalParamRegistration_m_restoreTime_set), -1);
17135 rb_define_method(SwigClassOpalParamRegistration.klass, "m_restoreTime", VALUEFUNC(_wrap_OpalParamRegistration_m_restoreTime_get), -1);
17136 rb_define_method(SwigClassOpalParamRegistration.klass, "m_eventPackage=", VALUEFUNC(_wrap_OpalParamRegistration_m_eventPackage_set), -1);
17137 rb_define_method(SwigClassOpalParamRegistration.klass, "m_eventPackage", VALUEFUNC(_wrap_OpalParamRegistration_m_eventPackage_get), -1);
17138 SwigClassOpalParamRegistration.mark = 0;
17139 SwigClassOpalParamRegistration.destroy = (void (*)(void *)) free_OpalParamRegistration;
17140 SwigClassOpalParamRegistration.trackObjects = 0;
17141 rb_define_const(mOpal, "OpalRegisterSuccessful", SWIG_From_int(static_cast< int >(OpalRegisterSuccessful)));
17142 rb_define_const(mOpal, "OpalRegisterRemoved", SWIG_From_int(static_cast< int >(OpalRegisterRemoved)));
17143 rb_define_const(mOpal, "OpalRegisterFailed", SWIG_From_int(static_cast< int >(OpalRegisterFailed)));
17144 rb_define_const(mOpal, "OpalRegisterRetrying", SWIG_From_int(static_cast< int >(OpalRegisterRetrying)));
17145 rb_define_const(mOpal, "OpalRegisterRestored", SWIG_From_int(static_cast< int >(OpalRegisterRestored)));
17146
17147 SwigClassOpalStatusRegistration.klass = rb_define_class_under(mOpal, "OpalStatusRegistration", rb_cObject);
17148 SWIG_TypeClientData(SWIGTYPE_p_OpalStatusRegistration, (void *) &SwigClassOpalStatusRegistration);
17149 rb_define_alloc_func(SwigClassOpalStatusRegistration.klass, _wrap_OpalStatusRegistration_allocate);
17150 rb_define_method(SwigClassOpalStatusRegistration.klass, "initialize", VALUEFUNC(_wrap_new_OpalStatusRegistration), -1);
17151 rb_define_method(SwigClassOpalStatusRegistration.klass, "m_protocol=", VALUEFUNC(_wrap_OpalStatusRegistration_m_protocol_set), -1);
17152 rb_define_method(SwigClassOpalStatusRegistration.klass, "m_protocol", VALUEFUNC(_wrap_OpalStatusRegistration_m_protocol_get), -1);
17153 rb_define_method(SwigClassOpalStatusRegistration.klass, "m_serverName=", VALUEFUNC(_wrap_OpalStatusRegistration_m_serverName_set), -1);
17154 rb_define_method(SwigClassOpalStatusRegistration.klass, "m_serverName", VALUEFUNC(_wrap_OpalStatusRegistration_m_serverName_get), -1);
17155 rb_define_method(SwigClassOpalStatusRegistration.klass, "m_error=", VALUEFUNC(_wrap_OpalStatusRegistration_m_error_set), -1);
17156 rb_define_method(SwigClassOpalStatusRegistration.klass, "m_error", VALUEFUNC(_wrap_OpalStatusRegistration_m_error_get), -1);
17157 rb_define_method(SwigClassOpalStatusRegistration.klass, "m_status=", VALUEFUNC(_wrap_OpalStatusRegistration_m_status_set), -1);
17158 rb_define_method(SwigClassOpalStatusRegistration.klass, "m_status", VALUEFUNC(_wrap_OpalStatusRegistration_m_status_get), -1);
17159 rb_define_method(SwigClassOpalStatusRegistration.klass, "m_product=", VALUEFUNC(_wrap_OpalStatusRegistration_m_product_set), -1);
17160 rb_define_method(SwigClassOpalStatusRegistration.klass, "m_product", VALUEFUNC(_wrap_OpalStatusRegistration_m_product_get), -1);
17161 SwigClassOpalStatusRegistration.mark = 0;
17162 SwigClassOpalStatusRegistration.destroy = (void (*)(void *)) free_OpalStatusRegistration;
17163 SwigClassOpalStatusRegistration.trackObjects = 0;
17164
17165 SwigClassOpalParamSetUpCall.klass = rb_define_class_under(mOpal, "OpalParamSetUpCall", rb_cObject);
17166 SWIG_TypeClientData(SWIGTYPE_p_OpalParamSetUpCall, (void *) &SwigClassOpalParamSetUpCall);
17167 rb_define_alloc_func(SwigClassOpalParamSetUpCall.klass, _wrap_OpalParamSetUpCall_allocate);
17168 rb_define_method(SwigClassOpalParamSetUpCall.klass, "initialize", VALUEFUNC(_wrap_new_OpalParamSetUpCall), -1);
17169 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_partyA=", VALUEFUNC(_wrap_OpalParamSetUpCall_m_partyA_set), -1);
17170 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_partyA", VALUEFUNC(_wrap_OpalParamSetUpCall_m_partyA_get), -1);
17171 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_partyB=", VALUEFUNC(_wrap_OpalParamSetUpCall_m_partyB_set), -1);
17172 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_partyB", VALUEFUNC(_wrap_OpalParamSetUpCall_m_partyB_get), -1);
17173 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_callToken=", VALUEFUNC(_wrap_OpalParamSetUpCall_m_callToken_set), -1);
17174 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_callToken", VALUEFUNC(_wrap_OpalParamSetUpCall_m_callToken_get), -1);
17175 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_alertingType=", VALUEFUNC(_wrap_OpalParamSetUpCall_m_alertingType_set), -1);
17176 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_alertingType", VALUEFUNC(_wrap_OpalParamSetUpCall_m_alertingType_get), -1);
17177 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_protocolCallId=", VALUEFUNC(_wrap_OpalParamSetUpCall_m_protocolCallId_set), -1);
17178 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_protocolCallId", VALUEFUNC(_wrap_OpalParamSetUpCall_m_protocolCallId_get), -1);
17179 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_overrides=", VALUEFUNC(_wrap_OpalParamSetUpCall_m_overrides_set), -1);
17180 rb_define_method(SwigClassOpalParamSetUpCall.klass, "m_overrides", VALUEFUNC(_wrap_OpalParamSetUpCall_m_overrides_get), -1);
17181 SwigClassOpalParamSetUpCall.mark = 0;
17182 SwigClassOpalParamSetUpCall.destroy = (void (*)(void *)) free_OpalParamSetUpCall;
17183 SwigClassOpalParamSetUpCall.trackObjects = 0;
17184
17185 SwigClassOpalStatusIncomingCall.klass = rb_define_class_under(mOpal, "OpalStatusIncomingCall", rb_cObject);
17186 SWIG_TypeClientData(SWIGTYPE_p_OpalStatusIncomingCall, (void *) &SwigClassOpalStatusIncomingCall);
17187 rb_define_alloc_func(SwigClassOpalStatusIncomingCall.klass, _wrap_OpalStatusIncomingCall_allocate);
17188 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "initialize", VALUEFUNC(_wrap_new_OpalStatusIncomingCall), -1);
17189 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_callToken=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_callToken_set), -1);
17190 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_callToken", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_callToken_get), -1);
17191 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_localAddress=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_localAddress_set), -1);
17192 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_localAddress", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_localAddress_get), -1);
17193 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_remoteAddress=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_remoteAddress_set), -1);
17194 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_remoteAddress", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_remoteAddress_get), -1);
17195 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_remotePartyNumber=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_remotePartyNumber_set), -1);
17196 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_remotePartyNumber", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_remotePartyNumber_get), -1);
17197 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_remoteDisplayName=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_remoteDisplayName_set), -1);
17198 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_remoteDisplayName", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_remoteDisplayName_get), -1);
17199 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_calledAddress=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_calledAddress_set), -1);
17200 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_calledAddress", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_calledAddress_get), -1);
17201 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_calledPartyNumber=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_calledPartyNumber_set), -1);
17202 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_calledPartyNumber", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_calledPartyNumber_get), -1);
17203 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_product=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_product_set), -1);
17204 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_product", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_product_get), -1);
17205 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_alertingType=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_alertingType_set), -1);
17206 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_alertingType", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_alertingType_get), -1);
17207 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_protocolCallId=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_protocolCallId_set), -1);
17208 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_protocolCallId", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_protocolCallId_get), -1);
17209 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_referredByAddress=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_referredByAddress_set), -1);
17210 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_referredByAddress", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_referredByAddress_get), -1);
17211 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_redirectingNumber=", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_redirectingNumber_set), -1);
17212 rb_define_method(SwigClassOpalStatusIncomingCall.klass, "m_redirectingNumber", VALUEFUNC(_wrap_OpalStatusIncomingCall_m_redirectingNumber_get), -1);
17213 SwigClassOpalStatusIncomingCall.mark = 0;
17214 SwigClassOpalStatusIncomingCall.destroy = (void (*)(void *)) free_OpalStatusIncomingCall;
17215 SwigClassOpalStatusIncomingCall.trackObjects = 0;
17216
17217 SwigClassOpalParamAnswerCall.klass = rb_define_class_under(mOpal, "OpalParamAnswerCall", rb_cObject);
17218 SWIG_TypeClientData(SWIGTYPE_p_OpalParamAnswerCall, (void *) &SwigClassOpalParamAnswerCall);
17219 rb_define_alloc_func(SwigClassOpalParamAnswerCall.klass, _wrap_OpalParamAnswerCall_allocate);
17220 rb_define_method(SwigClassOpalParamAnswerCall.klass, "initialize", VALUEFUNC(_wrap_new_OpalParamAnswerCall), -1);
17221 rb_define_method(SwigClassOpalParamAnswerCall.klass, "m_callToken=", VALUEFUNC(_wrap_OpalParamAnswerCall_m_callToken_set), -1);
17222 rb_define_method(SwigClassOpalParamAnswerCall.klass, "m_callToken", VALUEFUNC(_wrap_OpalParamAnswerCall_m_callToken_get), -1);
17223 rb_define_method(SwigClassOpalParamAnswerCall.klass, "m_overrides=", VALUEFUNC(_wrap_OpalParamAnswerCall_m_overrides_set), -1);
17224 rb_define_method(SwigClassOpalParamAnswerCall.klass, "m_overrides", VALUEFUNC(_wrap_OpalParamAnswerCall_m_overrides_get), -1);
17225 SwigClassOpalParamAnswerCall.mark = 0;
17226 SwigClassOpalParamAnswerCall.destroy = (void (*)(void *)) free_OpalParamAnswerCall;
17227 SwigClassOpalParamAnswerCall.trackObjects = 0;
17228 rb_define_const(mOpal, "OpalMediaStateNoChange", SWIG_From_int(static_cast< int >(OpalMediaStateNoChange)));
17229 rb_define_const(mOpal, "OpalMediaStateOpen", SWIG_From_int(static_cast< int >(OpalMediaStateOpen)));
17230 rb_define_const(mOpal, "OpalMediaStateClose", SWIG_From_int(static_cast< int >(OpalMediaStateClose)));
17231 rb_define_const(mOpal, "OpalMediaStatePause", SWIG_From_int(static_cast< int >(OpalMediaStatePause)));
17232 rb_define_const(mOpal, "OpalMediaStateResume", SWIG_From_int(static_cast< int >(OpalMediaStateResume)));
17233
17234 SwigClassOpalStatusMediaStream.klass = rb_define_class_under(mOpal, "OpalStatusMediaStream", rb_cObject);
17235 SWIG_TypeClientData(SWIGTYPE_p_OpalStatusMediaStream, (void *) &SwigClassOpalStatusMediaStream);
17236 rb_define_alloc_func(SwigClassOpalStatusMediaStream.klass, _wrap_OpalStatusMediaStream_allocate);
17237 rb_define_method(SwigClassOpalStatusMediaStream.klass, "initialize", VALUEFUNC(_wrap_new_OpalStatusMediaStream), -1);
17238 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_callToken=", VALUEFUNC(_wrap_OpalStatusMediaStream_m_callToken_set), -1);
17239 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_callToken", VALUEFUNC(_wrap_OpalStatusMediaStream_m_callToken_get), -1);
17240 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_identifier=", VALUEFUNC(_wrap_OpalStatusMediaStream_m_identifier_set), -1);
17241 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_identifier", VALUEFUNC(_wrap_OpalStatusMediaStream_m_identifier_get), -1);
17242 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_type=", VALUEFUNC(_wrap_OpalStatusMediaStream_m_type_set), -1);
17243 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_type", VALUEFUNC(_wrap_OpalStatusMediaStream_m_type_get), -1);
17244 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_format=", VALUEFUNC(_wrap_OpalStatusMediaStream_m_format_set), -1);
17245 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_format", VALUEFUNC(_wrap_OpalStatusMediaStream_m_format_get), -1);
17246 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_state=", VALUEFUNC(_wrap_OpalStatusMediaStream_m_state_set), -1);
17247 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_state", VALUEFUNC(_wrap_OpalStatusMediaStream_m_state_get), -1);
17248 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_volume=", VALUEFUNC(_wrap_OpalStatusMediaStream_m_volume_set), -1);
17249 rb_define_method(SwigClassOpalStatusMediaStream.klass, "m_volume", VALUEFUNC(_wrap_OpalStatusMediaStream_m_volume_get), -1);
17250 SwigClassOpalStatusMediaStream.mark = 0;
17251 SwigClassOpalStatusMediaStream.destroy = (void (*)(void *)) free_OpalStatusMediaStream;
17252 SwigClassOpalStatusMediaStream.trackObjects = 0;
17253
17254 SwigClassOpalParamSetUserData.klass = rb_define_class_under(mOpal, "OpalParamSetUserData", rb_cObject);
17255 SWIG_TypeClientData(SWIGTYPE_p_OpalParamSetUserData, (void *) &SwigClassOpalParamSetUserData);
17256 rb_define_alloc_func(SwigClassOpalParamSetUserData.klass, _wrap_OpalParamSetUserData_allocate);
17257 rb_define_method(SwigClassOpalParamSetUserData.klass, "initialize", VALUEFUNC(_wrap_new_OpalParamSetUserData), -1);
17258 rb_define_method(SwigClassOpalParamSetUserData.klass, "m_callToken=", VALUEFUNC(_wrap_OpalParamSetUserData_m_callToken_set), -1);
17259 rb_define_method(SwigClassOpalParamSetUserData.klass, "m_callToken", VALUEFUNC(_wrap_OpalParamSetUserData_m_callToken_get), -1);
17260 rb_define_method(SwigClassOpalParamSetUserData.klass, "m_userData=", VALUEFUNC(_wrap_OpalParamSetUserData_m_userData_set), -1);
17261 rb_define_method(SwigClassOpalParamSetUserData.klass, "m_userData", VALUEFUNC(_wrap_OpalParamSetUserData_m_userData_get), -1);
17262 SwigClassOpalParamSetUserData.mark = 0;
17263 SwigClassOpalParamSetUserData.destroy = (void (*)(void *)) free_OpalParamSetUserData;
17264 SwigClassOpalParamSetUserData.trackObjects = 0;
17265
17266 SwigClassOpalStatusUserInput.klass = rb_define_class_under(mOpal, "OpalStatusUserInput", rb_cObject);
17267 SWIG_TypeClientData(SWIGTYPE_p_OpalStatusUserInput, (void *) &SwigClassOpalStatusUserInput);
17268 rb_define_alloc_func(SwigClassOpalStatusUserInput.klass, _wrap_OpalStatusUserInput_allocate);
17269 rb_define_method(SwigClassOpalStatusUserInput.klass, "initialize", VALUEFUNC(_wrap_new_OpalStatusUserInput), -1);
17270 rb_define_method(SwigClassOpalStatusUserInput.klass, "m_callToken=", VALUEFUNC(_wrap_OpalStatusUserInput_m_callToken_set), -1);
17271 rb_define_method(SwigClassOpalStatusUserInput.klass, "m_callToken", VALUEFUNC(_wrap_OpalStatusUserInput_m_callToken_get), -1);
17272 rb_define_method(SwigClassOpalStatusUserInput.klass, "m_userInput=", VALUEFUNC(_wrap_OpalStatusUserInput_m_userInput_set), -1);
17273 rb_define_method(SwigClassOpalStatusUserInput.klass, "m_userInput", VALUEFUNC(_wrap_OpalStatusUserInput_m_userInput_get), -1);
17274 rb_define_method(SwigClassOpalStatusUserInput.klass, "m_duration=", VALUEFUNC(_wrap_OpalStatusUserInput_m_duration_set), -1);
17275 rb_define_method(SwigClassOpalStatusUserInput.klass, "m_duration", VALUEFUNC(_wrap_OpalStatusUserInput_m_duration_get), -1);
17276 SwigClassOpalStatusUserInput.mark = 0;
17277 SwigClassOpalStatusUserInput.destroy = (void (*)(void *)) free_OpalStatusUserInput;
17278 SwigClassOpalStatusUserInput.trackObjects = 0;
17279
17280 SwigClassOpalStatusMessageWaiting.klass = rb_define_class_under(mOpal, "OpalStatusMessageWaiting", rb_cObject);
17281 SWIG_TypeClientData(SWIGTYPE_p_OpalStatusMessageWaiting, (void *) &SwigClassOpalStatusMessageWaiting);
17282 rb_define_alloc_func(SwigClassOpalStatusMessageWaiting.klass, _wrap_OpalStatusMessageWaiting_allocate);
17283 rb_define_method(SwigClassOpalStatusMessageWaiting.klass, "initialize", VALUEFUNC(_wrap_new_OpalStatusMessageWaiting), -1);
17284 rb_define_method(SwigClassOpalStatusMessageWaiting.klass, "m_party=", VALUEFUNC(_wrap_OpalStatusMessageWaiting_m_party_set), -1);
17285 rb_define_method(SwigClassOpalStatusMessageWaiting.klass, "m_party", VALUEFUNC(_wrap_OpalStatusMessageWaiting_m_party_get), -1);
17286 rb_define_method(SwigClassOpalStatusMessageWaiting.klass, "m_type=", VALUEFUNC(_wrap_OpalStatusMessageWaiting_m_type_set), -1);
17287 rb_define_method(SwigClassOpalStatusMessageWaiting.klass, "m_type", VALUEFUNC(_wrap_OpalStatusMessageWaiting_m_type_get), -1);
17288 rb_define_method(SwigClassOpalStatusMessageWaiting.klass, "m_extraInfo=", VALUEFUNC(_wrap_OpalStatusMessageWaiting_m_extraInfo_set), -1);
17289 rb_define_method(SwigClassOpalStatusMessageWaiting.klass, "m_extraInfo", VALUEFUNC(_wrap_OpalStatusMessageWaiting_m_extraInfo_get), -1);
17290 SwigClassOpalStatusMessageWaiting.mark = 0;
17291 SwigClassOpalStatusMessageWaiting.destroy = (void (*)(void *)) free_OpalStatusMessageWaiting;
17292 SwigClassOpalStatusMessageWaiting.trackObjects = 0;
17293 rb_define_const(mOpal, "OpalLineTerminated", SWIG_From_int(static_cast< int >(OpalLineTerminated)));
17294 rb_define_const(mOpal, "OpalLineTrying", SWIG_From_int(static_cast< int >(OpalLineTrying)));
17295 rb_define_const(mOpal, "OpalLineProceeding", SWIG_From_int(static_cast< int >(OpalLineProceeding)));
17296 rb_define_const(mOpal, "OpalLineRinging", SWIG_From_int(static_cast< int >(OpalLineRinging)));
17297 rb_define_const(mOpal, "OpalLineConnected", SWIG_From_int(static_cast< int >(OpalLineConnected)));
17298 rb_define_const(mOpal, "OpalLineSubcribed", SWIG_From_int(static_cast< int >(OpalLineSubcribed)));
17299 rb_define_const(mOpal, "OpalLineUnsubcribed", SWIG_From_int(static_cast< int >(OpalLineUnsubcribed)));
17300 rb_define_const(mOpal, "OpalLineIdle", SWIG_From_int(static_cast< int >(OpalLineIdle)));
17301
17302 SwigClassOpalStatusLineAppearance.klass = rb_define_class_under(mOpal, "OpalStatusLineAppearance", rb_cObject);
17303 SWIG_TypeClientData(SWIGTYPE_p_OpalStatusLineAppearance, (void *) &SwigClassOpalStatusLineAppearance);
17304 rb_define_alloc_func(SwigClassOpalStatusLineAppearance.klass, _wrap_OpalStatusLineAppearance_allocate);
17305 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "initialize", VALUEFUNC(_wrap_new_OpalStatusLineAppearance), -1);
17306 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_line=", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_line_set), -1);
17307 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_line", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_line_get), -1);
17308 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_state=", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_state_set), -1);
17309 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_state", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_state_get), -1);
17310 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_appearance=", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_appearance_set), -1);
17311 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_appearance", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_appearance_get), -1);
17312 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_callId=", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_callId_set), -1);
17313 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_callId", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_callId_get), -1);
17314 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_partyA=", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_partyA_set), -1);
17315 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_partyA", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_partyA_get), -1);
17316 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_partyB=", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_partyB_set), -1);
17317 rb_define_method(SwigClassOpalStatusLineAppearance.klass, "m_partyB", VALUEFUNC(_wrap_OpalStatusLineAppearance_m_partyB_get), -1);
17318 SwigClassOpalStatusLineAppearance.mark = 0;
17319 SwigClassOpalStatusLineAppearance.destroy = (void (*)(void *)) free_OpalStatusLineAppearance;
17320 SwigClassOpalStatusLineAppearance.trackObjects = 0;
17321 rb_define_const(mOpal, "OpalSideBySideLetterbox", SWIG_From_int(static_cast< int >(OpalSideBySideLetterbox)));
17322 rb_define_const(mOpal, "OpalSideBySideScaled", SWIG_From_int(static_cast< int >(OpalSideBySideScaled)));
17323 rb_define_const(mOpal, "OpalStackedPillarbox", SWIG_From_int(static_cast< int >(OpalStackedPillarbox)));
17324 rb_define_const(mOpal, "OpalStackedScaled", SWIG_From_int(static_cast< int >(OpalStackedScaled)));
17325
17326 SwigClassOpalParamRecording.klass = rb_define_class_under(mOpal, "OpalParamRecording", rb_cObject);
17327 SWIG_TypeClientData(SWIGTYPE_p_OpalParamRecording, (void *) &SwigClassOpalParamRecording);
17328 rb_define_alloc_func(SwigClassOpalParamRecording.klass, _wrap_OpalParamRecording_allocate);
17329 rb_define_method(SwigClassOpalParamRecording.klass, "initialize", VALUEFUNC(_wrap_new_OpalParamRecording), -1);
17330 rb_define_method(SwigClassOpalParamRecording.klass, "m_callToken=", VALUEFUNC(_wrap_OpalParamRecording_m_callToken_set), -1);
17331 rb_define_method(SwigClassOpalParamRecording.klass, "m_callToken", VALUEFUNC(_wrap_OpalParamRecording_m_callToken_get), -1);
17332 rb_define_method(SwigClassOpalParamRecording.klass, "m_file=", VALUEFUNC(_wrap_OpalParamRecording_m_file_set), -1);
17333 rb_define_method(SwigClassOpalParamRecording.klass, "m_file", VALUEFUNC(_wrap_OpalParamRecording_m_file_get), -1);
17334 rb_define_method(SwigClassOpalParamRecording.klass, "m_channels=", VALUEFUNC(_wrap_OpalParamRecording_m_channels_set), -1);
17335 rb_define_method(SwigClassOpalParamRecording.klass, "m_channels", VALUEFUNC(_wrap_OpalParamRecording_m_channels_get), -1);
17336 rb_define_method(SwigClassOpalParamRecording.klass, "m_audioFormat=", VALUEFUNC(_wrap_OpalParamRecording_m_audioFormat_set), -1);
17337 rb_define_method(SwigClassOpalParamRecording.klass, "m_audioFormat", VALUEFUNC(_wrap_OpalParamRecording_m_audioFormat_get), -1);
17338 rb_define_method(SwigClassOpalParamRecording.klass, "m_videoFormat=", VALUEFUNC(_wrap_OpalParamRecording_m_videoFormat_set), -1);
17339 rb_define_method(SwigClassOpalParamRecording.klass, "m_videoFormat", VALUEFUNC(_wrap_OpalParamRecording_m_videoFormat_get), -1);
17340 rb_define_method(SwigClassOpalParamRecording.klass, "m_videoWidth=", VALUEFUNC(_wrap_OpalParamRecording_m_videoWidth_set), -1);
17341 rb_define_method(SwigClassOpalParamRecording.klass, "m_videoWidth", VALUEFUNC(_wrap_OpalParamRecording_m_videoWidth_get), -1);
17342 rb_define_method(SwigClassOpalParamRecording.klass, "m_videoHeight=", VALUEFUNC(_wrap_OpalParamRecording_m_videoHeight_set), -1);
17343 rb_define_method(SwigClassOpalParamRecording.klass, "m_videoHeight", VALUEFUNC(_wrap_OpalParamRecording_m_videoHeight_get), -1);
17344 rb_define_method(SwigClassOpalParamRecording.klass, "m_videoRate=", VALUEFUNC(_wrap_OpalParamRecording_m_videoRate_set), -1);
17345 rb_define_method(SwigClassOpalParamRecording.klass, "m_videoRate", VALUEFUNC(_wrap_OpalParamRecording_m_videoRate_get), -1);
17346 rb_define_method(SwigClassOpalParamRecording.klass, "m_videoMixing=", VALUEFUNC(_wrap_OpalParamRecording_m_videoMixing_set), -1);
17347 rb_define_method(SwigClassOpalParamRecording.klass, "m_videoMixing", VALUEFUNC(_wrap_OpalParamRecording_m_videoMixing_get), -1);
17348 SwigClassOpalParamRecording.mark = 0;
17349 SwigClassOpalParamRecording.destroy = (void (*)(void *)) free_OpalParamRecording;
17350 SwigClassOpalParamRecording.trackObjects = 0;
17351
17352 SwigClassOpalStatusTransferCall.klass = rb_define_class_under(mOpal, "OpalStatusTransferCall", rb_cObject);
17353 SWIG_TypeClientData(SWIGTYPE_p_OpalStatusTransferCall, (void *) &SwigClassOpalStatusTransferCall);
17354 rb_define_alloc_func(SwigClassOpalStatusTransferCall.klass, _wrap_OpalStatusTransferCall_allocate);
17355 rb_define_method(SwigClassOpalStatusTransferCall.klass, "initialize", VALUEFUNC(_wrap_new_OpalStatusTransferCall), -1);
17356 rb_define_method(SwigClassOpalStatusTransferCall.klass, "m_callToken=", VALUEFUNC(_wrap_OpalStatusTransferCall_m_callToken_set), -1);
17357 rb_define_method(SwigClassOpalStatusTransferCall.klass, "m_callToken", VALUEFUNC(_wrap_OpalStatusTransferCall_m_callToken_get), -1);
17358 rb_define_method(SwigClassOpalStatusTransferCall.klass, "m_protocolCallId=", VALUEFUNC(_wrap_OpalStatusTransferCall_m_protocolCallId_set), -1);
17359 rb_define_method(SwigClassOpalStatusTransferCall.klass, "m_protocolCallId", VALUEFUNC(_wrap_OpalStatusTransferCall_m_protocolCallId_get), -1);
17360 rb_define_method(SwigClassOpalStatusTransferCall.klass, "m_result=", VALUEFUNC(_wrap_OpalStatusTransferCall_m_result_set), -1);
17361 rb_define_method(SwigClassOpalStatusTransferCall.klass, "m_result", VALUEFUNC(_wrap_OpalStatusTransferCall_m_result_get), -1);
17362 rb_define_method(SwigClassOpalStatusTransferCall.klass, "m_info=", VALUEFUNC(_wrap_OpalStatusTransferCall_m_info_set), -1);
17363 rb_define_method(SwigClassOpalStatusTransferCall.klass, "m_info", VALUEFUNC(_wrap_OpalStatusTransferCall_m_info_get), -1);
17364 SwigClassOpalStatusTransferCall.mark = 0;
17365 SwigClassOpalStatusTransferCall.destroy = (void (*)(void *)) free_OpalStatusTransferCall;
17366 SwigClassOpalStatusTransferCall.trackObjects = 0;
17367
17368 SwigClassOpalStatusIVR.klass = rb_define_class_under(mOpal, "OpalStatusIVR", rb_cObject);
17369 SWIG_TypeClientData(SWIGTYPE_p_OpalStatusIVR, (void *) &SwigClassOpalStatusIVR);
17370 rb_define_alloc_func(SwigClassOpalStatusIVR.klass, _wrap_OpalStatusIVR_allocate);
17371 rb_define_method(SwigClassOpalStatusIVR.klass, "initialize", VALUEFUNC(_wrap_new_OpalStatusIVR), -1);
17372 rb_define_method(SwigClassOpalStatusIVR.klass, "m_callToken=", VALUEFUNC(_wrap_OpalStatusIVR_m_callToken_set), -1);
17373 rb_define_method(SwigClassOpalStatusIVR.klass, "m_callToken", VALUEFUNC(_wrap_OpalStatusIVR_m_callToken_get), -1);
17374 rb_define_method(SwigClassOpalStatusIVR.klass, "m_variables=", VALUEFUNC(_wrap_OpalStatusIVR_m_variables_set), -1);
17375 rb_define_method(SwigClassOpalStatusIVR.klass, "m_variables", VALUEFUNC(_wrap_OpalStatusIVR_m_variables_get), -1);
17376 SwigClassOpalStatusIVR.mark = 0;
17377 SwigClassOpalStatusIVR.destroy = (void (*)(void *)) free_OpalStatusIVR;
17378 SwigClassOpalStatusIVR.trackObjects = 0;
17379
17380 SwigClassOpalStatusCallCleared.klass = rb_define_class_under(mOpal, "OpalStatusCallCleared", rb_cObject);
17381 SWIG_TypeClientData(SWIGTYPE_p_OpalStatusCallCleared, (void *) &SwigClassOpalStatusCallCleared);
17382 rb_define_alloc_func(SwigClassOpalStatusCallCleared.klass, _wrap_OpalStatusCallCleared_allocate);
17383 rb_define_method(SwigClassOpalStatusCallCleared.klass, "initialize", VALUEFUNC(_wrap_new_OpalStatusCallCleared), -1);
17384 rb_define_method(SwigClassOpalStatusCallCleared.klass, "m_callToken=", VALUEFUNC(_wrap_OpalStatusCallCleared_m_callToken_set), -1);
17385 rb_define_method(SwigClassOpalStatusCallCleared.klass, "m_callToken", VALUEFUNC(_wrap_OpalStatusCallCleared_m_callToken_get), -1);
17386 rb_define_method(SwigClassOpalStatusCallCleared.klass, "m_reason=", VALUEFUNC(_wrap_OpalStatusCallCleared_m_reason_set), -1);
17387 rb_define_method(SwigClassOpalStatusCallCleared.klass, "m_reason", VALUEFUNC(_wrap_OpalStatusCallCleared_m_reason_get), -1);
17388 SwigClassOpalStatusCallCleared.mark = 0;
17389 SwigClassOpalStatusCallCleared.destroy = (void (*)(void *)) free_OpalStatusCallCleared;
17390 SwigClassOpalStatusCallCleared.trackObjects = 0;
17391 rb_define_const(mOpal, "OpalCallEndedByLocalUser", SWIG_From_int(static_cast< int >(OpalCallEndedByLocalUser)));
17392 rb_define_const(mOpal, "OpalCallEndedByNoAccept", SWIG_From_int(static_cast< int >(OpalCallEndedByNoAccept)));
17393 rb_define_const(mOpal, "OpalCallEndedByAnswerDenied", SWIG_From_int(static_cast< int >(OpalCallEndedByAnswerDenied)));
17394 rb_define_const(mOpal, "OpalCallEndedByRemoteUser", SWIG_From_int(static_cast< int >(OpalCallEndedByRemoteUser)));
17395 rb_define_const(mOpal, "OpalCallEndedByRefusal", SWIG_From_int(static_cast< int >(OpalCallEndedByRefusal)));
17396 rb_define_const(mOpal, "OpalCallEndedByNoAnswer", SWIG_From_int(static_cast< int >(OpalCallEndedByNoAnswer)));
17397 rb_define_const(mOpal, "OpalCallEndedByCallerAbort", SWIG_From_int(static_cast< int >(OpalCallEndedByCallerAbort)));
17398 rb_define_const(mOpal, "OpalCallEndedByTransportFail", SWIG_From_int(static_cast< int >(OpalCallEndedByTransportFail)));
17399 rb_define_const(mOpal, "OpalCallEndedByConnectFail", SWIG_From_int(static_cast< int >(OpalCallEndedByConnectFail)));
17400 rb_define_const(mOpal, "OpalCallEndedByGatekeeper", SWIG_From_int(static_cast< int >(OpalCallEndedByGatekeeper)));
17401 rb_define_const(mOpal, "OpalCallEndedByNoUser", SWIG_From_int(static_cast< int >(OpalCallEndedByNoUser)));
17402 rb_define_const(mOpal, "OpalCallEndedByNoBandwidth", SWIG_From_int(static_cast< int >(OpalCallEndedByNoBandwidth)));
17403 rb_define_const(mOpal, "OpalCallEndedByCapabilityExchange", SWIG_From_int(static_cast< int >(OpalCallEndedByCapabilityExchange)));
17404 rb_define_const(mOpal, "OpalCallEndedByCallForwarded", SWIG_From_int(static_cast< int >(OpalCallEndedByCallForwarded)));
17405 rb_define_const(mOpal, "OpalCallEndedBySecurityDenial", SWIG_From_int(static_cast< int >(OpalCallEndedBySecurityDenial)));
17406 rb_define_const(mOpal, "OpalCallEndedByLocalBusy", SWIG_From_int(static_cast< int >(OpalCallEndedByLocalBusy)));
17407 rb_define_const(mOpal, "OpalCallEndedByLocalCongestion", SWIG_From_int(static_cast< int >(OpalCallEndedByLocalCongestion)));
17408 rb_define_const(mOpal, "OpalCallEndedByRemoteBusy", SWIG_From_int(static_cast< int >(OpalCallEndedByRemoteBusy)));
17409 rb_define_const(mOpal, "OpalCallEndedByRemoteCongestion", SWIG_From_int(static_cast< int >(OpalCallEndedByRemoteCongestion)));
17410 rb_define_const(mOpal, "OpalCallEndedByUnreachable", SWIG_From_int(static_cast< int >(OpalCallEndedByUnreachable)));
17411 rb_define_const(mOpal, "OpalCallEndedByNoEndPoint", SWIG_From_int(static_cast< int >(OpalCallEndedByNoEndPoint)));
17412 rb_define_const(mOpal, "OpalCallEndedByHostOffline", SWIG_From_int(static_cast< int >(OpalCallEndedByHostOffline)));
17413 rb_define_const(mOpal, "OpalCallEndedByTemporaryFailure", SWIG_From_int(static_cast< int >(OpalCallEndedByTemporaryFailure)));
17414 rb_define_const(mOpal, "OpalCallEndedByQ931Cause", SWIG_From_int(static_cast< int >(OpalCallEndedByQ931Cause)));
17415 rb_define_const(mOpal, "OpalCallEndedByDurationLimit", SWIG_From_int(static_cast< int >(OpalCallEndedByDurationLimit)));
17416 rb_define_const(mOpal, "OpalCallEndedByInvalidConferenceID", SWIG_From_int(static_cast< int >(OpalCallEndedByInvalidConferenceID)));
17417 rb_define_const(mOpal, "OpalCallEndedByNoDialTone", SWIG_From_int(static_cast< int >(OpalCallEndedByNoDialTone)));
17418 rb_define_const(mOpal, "OpalCallEndedByNoRingBackTone", SWIG_From_int(static_cast< int >(OpalCallEndedByNoRingBackTone)));
17419 rb_define_const(mOpal, "OpalCallEndedByOutOfService", SWIG_From_int(static_cast< int >(OpalCallEndedByOutOfService)));
17420 rb_define_const(mOpal, "OpalCallEndedByAcceptingCallWaiting", SWIG_From_int(static_cast< int >(OpalCallEndedByAcceptingCallWaiting)));
17421 rb_define_const(mOpal, "OpalCallEndedWithQ931Code", SWIG_From_int(static_cast< int >(OpalCallEndedWithQ931Code)));
17422
17423 SwigClassOpalParamCallCleared.klass = rb_define_class_under(mOpal, "OpalParamCallCleared", rb_cObject);
17424 SWIG_TypeClientData(SWIGTYPE_p_OpalParamCallCleared, (void *) &SwigClassOpalParamCallCleared);
17425 rb_define_alloc_func(SwigClassOpalParamCallCleared.klass, _wrap_OpalParamCallCleared_allocate);
17426 rb_define_method(SwigClassOpalParamCallCleared.klass, "initialize", VALUEFUNC(_wrap_new_OpalParamCallCleared), -1);
17427 rb_define_method(SwigClassOpalParamCallCleared.klass, "m_callToken=", VALUEFUNC(_wrap_OpalParamCallCleared_m_callToken_set), -1);
17428 rb_define_method(SwigClassOpalParamCallCleared.klass, "m_callToken", VALUEFUNC(_wrap_OpalParamCallCleared_m_callToken_get), -1);
17429 rb_define_method(SwigClassOpalParamCallCleared.klass, "m_reason=", VALUEFUNC(_wrap_OpalParamCallCleared_m_reason_set), -1);
17430 rb_define_method(SwigClassOpalParamCallCleared.klass, "m_reason", VALUEFUNC(_wrap_OpalParamCallCleared_m_reason_get), -1);
17431 SwigClassOpalParamCallCleared.mark = 0;
17432 SwigClassOpalParamCallCleared.destroy = (void (*)(void *)) free_OpalParamCallCleared;
17433 SwigClassOpalParamCallCleared.trackObjects = 0;
17434
17435 SwigClassOpalMessage.klass = rb_define_class_under(mOpal, "OpalMessage", rb_cObject);
17436 SWIG_TypeClientData(SWIGTYPE_p_OpalMessage, (void *) &SwigClassOpalMessage);
17437 rb_define_alloc_func(SwigClassOpalMessage.klass, _wrap_OpalMessage_allocate);
17438 rb_define_method(SwigClassOpalMessage.klass, "initialize", VALUEFUNC(_wrap_new_OpalMessage), -1);
17439 rb_define_method(SwigClassOpalMessage.klass, "m_type=", VALUEFUNC(_wrap_OpalMessage_m_type_set), -1);
17440 rb_define_method(SwigClassOpalMessage.klass, "m_type", VALUEFUNC(_wrap_OpalMessage_m_type_get), -1);
17441 rb_define_method(SwigClassOpalMessage.klass, "m_param", VALUEFUNC(_wrap_OpalMessage_m_param_get), -1);
17442 SwigClassOpalMessage.mark = 0;
17443 SwigClassOpalMessage.destroy = (void (*)(void *)) free_OpalMessage;
17444 SwigClassOpalMessage.trackObjects = 0;
17445
17446 SwigClassOpalMessage_m_param.klass = rb_define_class_under(mOpal, "OpalMessage_m_param", rb_cObject);
17447 SWIG_TypeClientData(SWIGTYPE_p_OpalMessage_m_param, (void *) &SwigClassOpalMessage_m_param);
17448 rb_define_alloc_func(SwigClassOpalMessage_m_param.klass, _wrap_OpalMessage_m_param_allocate);
17449 rb_define_method(SwigClassOpalMessage_m_param.klass, "initialize", VALUEFUNC(_wrap_new_OpalMessage_m_param), -1);
17450 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_commandError=", VALUEFUNC(_wrap_OpalMessage_m_param_m_commandError_set), -1);
17451 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_commandError", VALUEFUNC(_wrap_OpalMessage_m_param_m_commandError_get), -1);
17452 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_general=", VALUEFUNC(_wrap_OpalMessage_m_param_m_general_set), -1);
17453 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_general", VALUEFUNC(_wrap_OpalMessage_m_param_m_general_get), -1);
17454 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_protocol=", VALUEFUNC(_wrap_OpalMessage_m_param_m_protocol_set), -1);
17455 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_protocol", VALUEFUNC(_wrap_OpalMessage_m_param_m_protocol_get), -1);
17456 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_registrationInfo=", VALUEFUNC(_wrap_OpalMessage_m_param_m_registrationInfo_set), -1);
17457 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_registrationInfo", VALUEFUNC(_wrap_OpalMessage_m_param_m_registrationInfo_get), -1);
17458 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_registrationStatus=", VALUEFUNC(_wrap_OpalMessage_m_param_m_registrationStatus_set), -1);
17459 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_registrationStatus", VALUEFUNC(_wrap_OpalMessage_m_param_m_registrationStatus_get), -1);
17460 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_callSetUp=", VALUEFUNC(_wrap_OpalMessage_m_param_m_callSetUp_set), -1);
17461 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_callSetUp", VALUEFUNC(_wrap_OpalMessage_m_param_m_callSetUp_get), -1);
17462 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_callToken=", VALUEFUNC(_wrap_OpalMessage_m_param_m_callToken_set), -1);
17463 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_callToken", VALUEFUNC(_wrap_OpalMessage_m_param_m_callToken_get), -1);
17464 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_incomingCall=", VALUEFUNC(_wrap_OpalMessage_m_param_m_incomingCall_set), -1);
17465 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_incomingCall", VALUEFUNC(_wrap_OpalMessage_m_param_m_incomingCall_get), -1);
17466 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_answerCall=", VALUEFUNC(_wrap_OpalMessage_m_param_m_answerCall_set), -1);
17467 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_answerCall", VALUEFUNC(_wrap_OpalMessage_m_param_m_answerCall_get), -1);
17468 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_userInput=", VALUEFUNC(_wrap_OpalMessage_m_param_m_userInput_set), -1);
17469 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_userInput", VALUEFUNC(_wrap_OpalMessage_m_param_m_userInput_get), -1);
17470 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_messageWaiting=", VALUEFUNC(_wrap_OpalMessage_m_param_m_messageWaiting_set), -1);
17471 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_messageWaiting", VALUEFUNC(_wrap_OpalMessage_m_param_m_messageWaiting_get), -1);
17472 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_lineAppearance=", VALUEFUNC(_wrap_OpalMessage_m_param_m_lineAppearance_set), -1);
17473 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_lineAppearance", VALUEFUNC(_wrap_OpalMessage_m_param_m_lineAppearance_get), -1);
17474 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_callCleared=", VALUEFUNC(_wrap_OpalMessage_m_param_m_callCleared_set), -1);
17475 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_callCleared", VALUEFUNC(_wrap_OpalMessage_m_param_m_callCleared_get), -1);
17476 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_clearCall=", VALUEFUNC(_wrap_OpalMessage_m_param_m_clearCall_set), -1);
17477 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_clearCall", VALUEFUNC(_wrap_OpalMessage_m_param_m_clearCall_get), -1);
17478 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_mediaStream=", VALUEFUNC(_wrap_OpalMessage_m_param_m_mediaStream_set), -1);
17479 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_mediaStream", VALUEFUNC(_wrap_OpalMessage_m_param_m_mediaStream_get), -1);
17480 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_setUserData=", VALUEFUNC(_wrap_OpalMessage_m_param_m_setUserData_set), -1);
17481 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_setUserData", VALUEFUNC(_wrap_OpalMessage_m_param_m_setUserData_get), -1);
17482 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_recording=", VALUEFUNC(_wrap_OpalMessage_m_param_m_recording_set), -1);
17483 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_recording", VALUEFUNC(_wrap_OpalMessage_m_param_m_recording_get), -1);
17484 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_transferStatus=", VALUEFUNC(_wrap_OpalMessage_m_param_m_transferStatus_set), -1);
17485 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_transferStatus", VALUEFUNC(_wrap_OpalMessage_m_param_m_transferStatus_get), -1);
17486 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_ivrStatus=", VALUEFUNC(_wrap_OpalMessage_m_param_m_ivrStatus_set), -1);
17487 rb_define_method(SwigClassOpalMessage_m_param.klass, "m_ivrStatus", VALUEFUNC(_wrap_OpalMessage_m_param_m_ivrStatus_get), -1);
17488 SwigClassOpalMessage_m_param.mark = 0;
17489 SwigClassOpalMessage_m_param.destroy = (void (*)(void *)) free_OpalMessage_m_param;
17490 SwigClassOpalMessage_m_param.trackObjects = 0;
17491
17492 SwigClassOpalMessagePtr.klass = rb_define_class_under(mOpal, "OpalMessagePtr", rb_cObject);
17493 SWIG_TypeClientData(SWIGTYPE_p_OpalMessagePtr, (void *) &SwigClassOpalMessagePtr);
17494 rb_define_alloc_func(SwigClassOpalMessagePtr.klass, _wrap_OpalMessagePtr_allocate);
17495 rb_define_method(SwigClassOpalMessagePtr.klass, "initialize", VALUEFUNC(_wrap_new_OpalMessagePtr), -1);
17496 rb_define_method(SwigClassOpalMessagePtr.klass, "GetType", VALUEFUNC(_wrap_OpalMessagePtr_GetType), -1);
17497 rb_define_method(SwigClassOpalMessagePtr.klass, "SetType", VALUEFUNC(_wrap_OpalMessagePtr_SetType), -1);
17498 rb_define_method(SwigClassOpalMessagePtr.klass, "GetCallToken", VALUEFUNC(_wrap_OpalMessagePtr_GetCallToken), -1);
17499 rb_define_method(SwigClassOpalMessagePtr.klass, "SetCallToken", VALUEFUNC(_wrap_OpalMessagePtr_SetCallToken), -1);
17500 rb_define_method(SwigClassOpalMessagePtr.klass, "GetCommandError", VALUEFUNC(_wrap_OpalMessagePtr_GetCommandError), -1);
17501 rb_define_method(SwigClassOpalMessagePtr.klass, "GetGeneralParams", VALUEFUNC(_wrap_OpalMessagePtr_GetGeneralParams), -1);
17502 rb_define_method(SwigClassOpalMessagePtr.klass, "GetProtocolParams", VALUEFUNC(_wrap_OpalMessagePtr_GetProtocolParams), -1);
17503 rb_define_method(SwigClassOpalMessagePtr.klass, "GetRegistrationInfo", VALUEFUNC(_wrap_OpalMessagePtr_GetRegistrationInfo), -1);
17504 rb_define_method(SwigClassOpalMessagePtr.klass, "GetRegistrationStatus", VALUEFUNC(_wrap_OpalMessagePtr_GetRegistrationStatus), -1);
17505 rb_define_method(SwigClassOpalMessagePtr.klass, "GetCallSetUp", VALUEFUNC(_wrap_OpalMessagePtr_GetCallSetUp), -1);
17506 rb_define_method(SwigClassOpalMessagePtr.klass, "GetIncomingCall", VALUEFUNC(_wrap_OpalMessagePtr_GetIncomingCall), -1);
17507 rb_define_method(SwigClassOpalMessagePtr.klass, "GetAnswerCall", VALUEFUNC(_wrap_OpalMessagePtr_GetAnswerCall), -1);
17508 rb_define_method(SwigClassOpalMessagePtr.klass, "GetUserInput", VALUEFUNC(_wrap_OpalMessagePtr_GetUserInput), -1);
17509 rb_define_method(SwigClassOpalMessagePtr.klass, "GetMessageWaiting", VALUEFUNC(_wrap_OpalMessagePtr_GetMessageWaiting), -1);
17510 rb_define_method(SwigClassOpalMessagePtr.klass, "GetLineAppearance", VALUEFUNC(_wrap_OpalMessagePtr_GetLineAppearance), -1);
17511 rb_define_method(SwigClassOpalMessagePtr.klass, "GetCallCleared", VALUEFUNC(_wrap_OpalMessagePtr_GetCallCleared), -1);
17512 rb_define_method(SwigClassOpalMessagePtr.klass, "GetClearCall", VALUEFUNC(_wrap_OpalMessagePtr_GetClearCall), -1);
17513 rb_define_method(SwigClassOpalMessagePtr.klass, "GetMediaStream", VALUEFUNC(_wrap_OpalMessagePtr_GetMediaStream), -1);
17514 rb_define_method(SwigClassOpalMessagePtr.klass, "GetSetUserData", VALUEFUNC(_wrap_OpalMessagePtr_GetSetUserData), -1);
17515 rb_define_method(SwigClassOpalMessagePtr.klass, "GetRecording", VALUEFUNC(_wrap_OpalMessagePtr_GetRecording), -1);
17516 rb_define_method(SwigClassOpalMessagePtr.klass, "GetTransferStatus", VALUEFUNC(_wrap_OpalMessagePtr_GetTransferStatus), -1);
17517 SwigClassOpalMessagePtr.mark = 0;
17518 SwigClassOpalMessagePtr.destroy = (void (*)(void *)) free_OpalMessagePtr;
17519 SwigClassOpalMessagePtr.trackObjects = 0;
17520
17521 SwigClassOpalContext.klass = rb_define_class_under(mOpal, "OpalContext", rb_cObject);
17522 SWIG_TypeClientData(SWIGTYPE_p_OpalContext, (void *) &SwigClassOpalContext);
17523 rb_define_alloc_func(SwigClassOpalContext.klass, _wrap_OpalContext_allocate);
17524 rb_define_method(SwigClassOpalContext.klass, "initialize", VALUEFUNC(_wrap_new_OpalContext), -1);
17525 rb_define_method(SwigClassOpalContext.klass, "Initialise", VALUEFUNC(_wrap_OpalContext_Initialise), -1);
17526 rb_define_method(SwigClassOpalContext.klass, "IsInitialised", VALUEFUNC(_wrap_OpalContext_IsInitialised), -1);
17527 rb_define_method(SwigClassOpalContext.klass, "ShutDown", VALUEFUNC(_wrap_OpalContext_ShutDown), -1);
17528 rb_define_method(SwigClassOpalContext.klass, "GetMessage", VALUEFUNC(_wrap_OpalContext_GetMessage), -1);
17529 rb_define_method(SwigClassOpalContext.klass, "SendMessage", VALUEFUNC(_wrap_OpalContext_SendMessage), -1);
17530 rb_define_method(SwigClassOpalContext.klass, "SetUpCall", VALUEFUNC(_wrap_OpalContext_SetUpCall), -1);
17531 rb_define_method(SwigClassOpalContext.klass, "AnswerCall", VALUEFUNC(_wrap_OpalContext_AnswerCall), -1);
17532 rb_define_method(SwigClassOpalContext.klass, "ClearCall", VALUEFUNC(_wrap_OpalContext_ClearCall), -1);
17533 rb_define_method(SwigClassOpalContext.klass, "SendUserInput", VALUEFUNC(_wrap_OpalContext_SendUserInput), -1);
17534 SwigClassOpalContext.mark = 0;
17535 SwigClassOpalContext.destroy = (void (*)(void *)) free_OpalContext;
17536 SwigClassOpalContext.trackObjects = 0;
17537 }
17538
17539