1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.39
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 SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14
15 #ifdef __cplusplus
16 /* SwigValueWrapper is described in swig.swg */
17 template<typename T> class SwigValueWrapper {
18 struct SwigMovePointer {
19 T *ptr;
SwigMovePointerSwigValueWrapper::SwigMovePointer20 SwigMovePointer(T *p) : ptr(p) { }
~SwigMovePointerSwigValueWrapper::SwigMovePointer21 ~SwigMovePointer() { delete ptr; }
operator =SwigValueWrapper::SwigMovePointer22 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
23 } pointer;
24 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
26 public:
SwigValueWrapper()27 SwigValueWrapper() : pointer(0) { }
operator =(const T & t)28 SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
operator T&() const29 operator T&() const { return *pointer.ptr; }
operator &()30 T *operator&() { return pointer.ptr; }
31 };
32
SwigValueInit()33 template <typename T> T SwigValueInit() {
34 return T();
35 }
36 #endif
37
38 /* -----------------------------------------------------------------------------
39 * This section contains generic SWIG labels for method/variable
40 * declarations/attributes, and other compiler dependent labels.
41 * ----------------------------------------------------------------------------- */
42
43 /* template workaround for compilers that cannot correctly implement the C++ standard */
44 #ifndef SWIGTEMPLATEDISAMBIGUATOR
45 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
46 # define SWIGTEMPLATEDISAMBIGUATOR template
47 # elif defined(__HP_aCC)
48 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
49 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
50 # define SWIGTEMPLATEDISAMBIGUATOR template
51 # else
52 # define SWIGTEMPLATEDISAMBIGUATOR
53 # endif
54 #endif
55
56 /* inline attribute */
57 #ifndef SWIGINLINE
58 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
59 # define SWIGINLINE inline
60 # else
61 # define SWIGINLINE
62 # endif
63 #endif
64
65 /* attribute recognised by some compilers to avoid 'unused' warnings */
66 #ifndef SWIGUNUSED
67 # if defined(__GNUC__)
68 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
69 # define SWIGUNUSED __attribute__ ((__unused__))
70 # else
71 # define SWIGUNUSED
72 # endif
73 # elif defined(__ICC)
74 # define SWIGUNUSED __attribute__ ((__unused__))
75 # else
76 # define SWIGUNUSED
77 # endif
78 #endif
79
80 #ifndef SWIG_MSC_UNSUPPRESS_4505
81 # if defined(_MSC_VER)
82 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
83 # endif
84 #endif
85
86 #ifndef SWIGUNUSEDPARM
87 # ifdef __cplusplus
88 # define SWIGUNUSEDPARM(p)
89 # else
90 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
91 # endif
92 #endif
93
94 /* internal SWIG method */
95 #ifndef SWIGINTERN
96 # define SWIGINTERN static SWIGUNUSED
97 #endif
98
99 /* internal inline SWIG method */
100 #ifndef SWIGINTERNINLINE
101 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
102 #endif
103
104 /* exporting methods */
105 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
106 # ifndef GCC_HASCLASSVISIBILITY
107 # define GCC_HASCLASSVISIBILITY
108 # endif
109 #endif
110
111 #ifndef SWIGEXPORT
112 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
113 # if defined(STATIC_LINKED)
114 # define SWIGEXPORT
115 # else
116 # define SWIGEXPORT __declspec(dllexport)
117 # endif
118 # else
119 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
120 # define SWIGEXPORT __attribute__ ((visibility("default")))
121 # else
122 # define SWIGEXPORT
123 # endif
124 # endif
125 #endif
126
127 /* calling conventions for Windows */
128 #ifndef SWIGSTDCALL
129 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
130 # define SWIGSTDCALL __stdcall
131 # else
132 # define SWIGSTDCALL
133 # endif
134 #endif
135
136 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
137 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
138 # define _CRT_SECURE_NO_DEPRECATE
139 #endif
140
141 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
142 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
143 # define _SCL_SECURE_NO_DEPRECATE
144 #endif
145
146
147
148 /* Python.h has to appear first */
149 #include <Python.h>
150
151 /* -----------------------------------------------------------------------------
152 * swigrun.swg
153 *
154 * This file contains generic C API SWIG runtime support for pointer
155 * type checking.
156 * ----------------------------------------------------------------------------- */
157
158 /* This should only be incremented when either the layout of swig_type_info changes,
159 or for whatever reason, the runtime changes incompatibly */
160 #define SWIG_RUNTIME_VERSION "4"
161
162 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
163 #ifdef SWIG_TYPE_TABLE
164 # define SWIG_QUOTE_STRING(x) #x
165 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
166 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
167 #else
168 # define SWIG_TYPE_TABLE_NAME
169 #endif
170
171 /*
172 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
173 creating a static or dynamic library from the SWIG runtime code.
174 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
175
176 But only do this if strictly necessary, ie, if you have problems
177 with your compiler or suchlike.
178 */
179
180 #ifndef SWIGRUNTIME
181 # define SWIGRUNTIME SWIGINTERN
182 #endif
183
184 #ifndef SWIGRUNTIMEINLINE
185 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
186 #endif
187
188 /* Generic buffer size */
189 #ifndef SWIG_BUFFER_SIZE
190 # define SWIG_BUFFER_SIZE 1024
191 #endif
192
193 /* Flags for pointer conversions */
194 #define SWIG_POINTER_DISOWN 0x1
195 #define SWIG_CAST_NEW_MEMORY 0x2
196
197 /* Flags for new pointer objects */
198 #define SWIG_POINTER_OWN 0x1
199
200
201 /*
202 Flags/methods for returning states.
203
204 The SWIG conversion methods, as ConvertPtr, return and integer
205 that tells if the conversion was successful or not. And if not,
206 an error code can be returned (see swigerrors.swg for the codes).
207
208 Use the following macros/flags to set or process the returning
209 states.
210
211 In old versions of SWIG, code such as the following was usually written:
212
213 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
214 // success code
215 } else {
216 //fail code
217 }
218
219 Now you can be more explicit:
220
221 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
222 if (SWIG_IsOK(res)) {
223 // success code
224 } else {
225 // fail code
226 }
227
228 which is the same really, but now you can also do
229
230 Type *ptr;
231 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
232 if (SWIG_IsOK(res)) {
233 // success code
234 if (SWIG_IsNewObj(res) {
235 ...
236 delete *ptr;
237 } else {
238 ...
239 }
240 } else {
241 // fail code
242 }
243
244 I.e., now SWIG_ConvertPtr can return new objects and you can
245 identify the case and take care of the deallocation. Of course that
246 also requires SWIG_ConvertPtr to return new result values, such as
247
248 int SWIG_ConvertPtr(obj, ptr,...) {
249 if (<obj is ok>) {
250 if (<need new object>) {
251 *ptr = <ptr to new allocated object>;
252 return SWIG_NEWOBJ;
253 } else {
254 *ptr = <ptr to old object>;
255 return SWIG_OLDOBJ;
256 }
257 } else {
258 return SWIG_BADOBJ;
259 }
260 }
261
262 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
263 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
264 SWIG errors code.
265
266 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
267 allows to return the 'cast rank', for example, if you have this
268
269 int food(double)
270 int fooi(int);
271
272 and you call
273
274 food(1) // cast rank '1' (1 -> 1.0)
275 fooi(1) // cast rank '0'
276
277 just use the SWIG_AddCast()/SWIG_CheckState()
278 */
279
280 #define SWIG_OK (0)
281 #define SWIG_ERROR (-1)
282 #define SWIG_IsOK(r) (r >= 0)
283 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
284
285 /* The CastRankLimit says how many bits are used for the cast rank */
286 #define SWIG_CASTRANKLIMIT (1 << 8)
287 /* The NewMask denotes the object was created (using new/malloc) */
288 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
289 /* The TmpMask is for in/out typemaps that use temporal objects */
290 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
291 /* Simple returning values */
292 #define SWIG_BADOBJ (SWIG_ERROR)
293 #define SWIG_OLDOBJ (SWIG_OK)
294 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
295 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
296 /* Check, add and del mask methods */
297 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
298 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
299 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
300 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
301 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
302 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
303
304 /* Cast-Rank Mode */
305 #if defined(SWIG_CASTRANK_MODE)
306 # ifndef SWIG_TypeRank
307 # define SWIG_TypeRank unsigned long
308 # endif
309 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
310 # define SWIG_MAXCASTRANK (2)
311 # endif
312 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
313 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIG_AddCast(int r)314 SWIGINTERNINLINE int SWIG_AddCast(int r) {
315 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
316 }
SWIG_CheckState(int r)317 SWIGINTERNINLINE int SWIG_CheckState(int r) {
318 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
319 }
320 #else /* no cast-rank mode */
321 # define SWIG_AddCast
322 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
323 #endif
324
325
326 #include <string.h>
327
328 #ifdef __cplusplus
329 extern "C" {
330 #endif
331
332 typedef void *(*swig_converter_func)(void *, int *);
333 typedef struct swig_type_info *(*swig_dycast_func)(void **);
334
335 /* Structure to store information on one type */
336 typedef struct swig_type_info {
337 const char *name; /* mangled name of this type */
338 const char *str; /* human readable name of this type */
339 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
340 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
341 void *clientdata; /* language specific type data */
342 int owndata; /* flag if the structure owns the clientdata */
343 } swig_type_info;
344
345 /* Structure to store a type and conversion function used for casting */
346 typedef struct swig_cast_info {
347 swig_type_info *type; /* pointer to type that is equivalent to this type */
348 swig_converter_func converter; /* function to cast the void pointers */
349 struct swig_cast_info *next; /* pointer to next cast in linked list */
350 struct swig_cast_info *prev; /* pointer to the previous cast */
351 } swig_cast_info;
352
353 /* Structure used to store module information
354 * Each module generates one structure like this, and the runtime collects
355 * all of these structures and stores them in a circularly linked list.*/
356 typedef struct swig_module_info {
357 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
358 size_t size; /* Number of types in this module */
359 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
360 swig_type_info **type_initial; /* Array of initially generated type structures */
361 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
362 void *clientdata; /* Language specific module data */
363 } swig_module_info;
364
365 /*
366 Compare two type names skipping the space characters, therefore
367 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
368
369 Return 0 when the two name types are equivalent, as in
370 strncmp, but skipping ' '.
371 */
372 SWIGRUNTIME int
SWIG_TypeNameComp(const char * f1,const char * l1,const char * f2,const char * l2)373 SWIG_TypeNameComp(const char *f1, const char *l1,
374 const char *f2, const char *l2) {
375 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
376 while ((*f1 == ' ') && (f1 != l1)) ++f1;
377 while ((*f2 == ' ') && (f2 != l2)) ++f2;
378 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
379 }
380 return (int)((l1 - f1) - (l2 - f2));
381 }
382
383 /*
384 Check type equivalence in a name list like <name1>|<name2>|...
385 Return 0 if not equal, 1 if equal
386 */
387 SWIGRUNTIME int
SWIG_TypeEquiv(const char * nb,const char * tb)388 SWIG_TypeEquiv(const char *nb, const char *tb) {
389 int equiv = 0;
390 const char* te = tb + strlen(tb);
391 const char* ne = nb;
392 while (!equiv && *ne) {
393 for (nb = ne; *ne; ++ne) {
394 if (*ne == '|') break;
395 }
396 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
397 if (*ne) ++ne;
398 }
399 return equiv;
400 }
401
402 /*
403 Check type equivalence in a name list like <name1>|<name2>|...
404 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
405 */
406 SWIGRUNTIME int
SWIG_TypeCompare(const char * nb,const char * tb)407 SWIG_TypeCompare(const char *nb, const char *tb) {
408 int equiv = 0;
409 const char* te = tb + strlen(tb);
410 const char* ne = nb;
411 while (!equiv && *ne) {
412 for (nb = ne; *ne; ++ne) {
413 if (*ne == '|') break;
414 }
415 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
416 if (*ne) ++ne;
417 }
418 return equiv;
419 }
420
421
422 /*
423 Check the typename
424 */
425 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char * c,swig_type_info * ty)426 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
427 if (ty) {
428 swig_cast_info *iter = ty->cast;
429 while (iter) {
430 if (strcmp(iter->type->name, c) == 0) {
431 if (iter == ty->cast)
432 return iter;
433 /* Move iter to the top of the linked list */
434 iter->prev->next = iter->next;
435 if (iter->next)
436 iter->next->prev = iter->prev;
437 iter->next = ty->cast;
438 iter->prev = 0;
439 if (ty->cast) ty->cast->prev = iter;
440 ty->cast = iter;
441 return iter;
442 }
443 iter = iter->next;
444 }
445 }
446 return 0;
447 }
448
449 /*
450 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
451 */
452 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info * from,swig_type_info * ty)453 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
454 if (ty) {
455 swig_cast_info *iter = ty->cast;
456 while (iter) {
457 if (iter->type == from) {
458 if (iter == ty->cast)
459 return iter;
460 /* Move iter to the top of the linked list */
461 iter->prev->next = iter->next;
462 if (iter->next)
463 iter->next->prev = iter->prev;
464 iter->next = ty->cast;
465 iter->prev = 0;
466 if (ty->cast) ty->cast->prev = iter;
467 ty->cast = iter;
468 return iter;
469 }
470 iter = iter->next;
471 }
472 }
473 return 0;
474 }
475
476 /*
477 Cast a pointer up an inheritance hierarchy
478 */
479 SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info * ty,void * ptr,int * newmemory)480 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
481 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
482 }
483
484 /*
485 Dynamic pointer casting. Down an inheritance hierarchy
486 */
487 SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info * ty,void ** ptr)488 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
489 swig_type_info *lastty = ty;
490 if (!ty || !ty->dcast) return ty;
491 while (ty && (ty->dcast)) {
492 ty = (*ty->dcast)(ptr);
493 if (ty) lastty = ty;
494 }
495 return lastty;
496 }
497
498 /*
499 Return the name associated with this type
500 */
501 SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info * ty)502 SWIG_TypeName(const swig_type_info *ty) {
503 return ty->name;
504 }
505
506 /*
507 Return the pretty name associated with this type,
508 that is an unmangled type name in a form presentable to the user.
509 */
510 SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info * type)511 SWIG_TypePrettyName(const swig_type_info *type) {
512 /* The "str" field contains the equivalent pretty names of the
513 type, separated by vertical-bar characters. We choose
514 to print the last name, as it is often (?) the most
515 specific. */
516 if (!type) return NULL;
517 if (type->str != NULL) {
518 const char *last_name = type->str;
519 const char *s;
520 for (s = type->str; *s; s++)
521 if (*s == '|') last_name = s+1;
522 return last_name;
523 }
524 else
525 return type->name;
526 }
527
528 /*
529 Set the clientdata field for a type
530 */
531 SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info * ti,void * clientdata)532 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
533 swig_cast_info *cast = ti->cast;
534 /* if (ti->clientdata == clientdata) return; */
535 ti->clientdata = clientdata;
536
537 while (cast) {
538 if (!cast->converter) {
539 swig_type_info *tc = cast->type;
540 if (!tc->clientdata) {
541 SWIG_TypeClientData(tc, clientdata);
542 }
543 }
544 cast = cast->next;
545 }
546 }
547 SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info * ti,void * clientdata)548 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
549 SWIG_TypeClientData(ti, clientdata);
550 ti->owndata = 1;
551 }
552
553 /*
554 Search for a swig_type_info structure only by mangled name
555 Search is a O(log #types)
556
557 We start searching at module start, and finish searching when start == end.
558 Note: if start == end at the beginning of the function, we go all the way around
559 the circular list.
560 */
561 SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)562 SWIG_MangledTypeQueryModule(swig_module_info *start,
563 swig_module_info *end,
564 const char *name) {
565 swig_module_info *iter = start;
566 do {
567 if (iter->size) {
568 register size_t l = 0;
569 register size_t r = iter->size - 1;
570 do {
571 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
572 register size_t i = (l + r) >> 1;
573 const char *iname = iter->types[i]->name;
574 if (iname) {
575 register int compare = strcmp(name, iname);
576 if (compare == 0) {
577 return iter->types[i];
578 } else if (compare < 0) {
579 if (i) {
580 r = i - 1;
581 } else {
582 break;
583 }
584 } else if (compare > 0) {
585 l = i + 1;
586 }
587 } else {
588 break; /* should never happen */
589 }
590 } while (l <= r);
591 }
592 iter = iter->next;
593 } while (iter != end);
594 return 0;
595 }
596
597 /*
598 Search for a swig_type_info structure for either a mangled name or a human readable name.
599 It first searches the mangled names of the types, which is a O(log #types)
600 If a type is not found it then searches the human readable names, which is O(#types).
601
602 We start searching at module start, and finish searching when start == end.
603 Note: if start == end at the beginning of the function, we go all the way around
604 the circular list.
605 */
606 SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)607 SWIG_TypeQueryModule(swig_module_info *start,
608 swig_module_info *end,
609 const char *name) {
610 /* STEP 1: Search the name field using binary search */
611 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
612 if (ret) {
613 return ret;
614 } else {
615 /* STEP 2: If the type hasn't been found, do a complete search
616 of the str field (the human readable name) */
617 swig_module_info *iter = start;
618 do {
619 register size_t i = 0;
620 for (; i < iter->size; ++i) {
621 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
622 return iter->types[i];
623 }
624 iter = iter->next;
625 } while (iter != end);
626 }
627
628 /* neither found a match */
629 return 0;
630 }
631
632 /*
633 Pack binary data into a string
634 */
635 SWIGRUNTIME char *
SWIG_PackData(char * c,void * ptr,size_t sz)636 SWIG_PackData(char *c, void *ptr, size_t sz) {
637 static const char hex[17] = "0123456789abcdef";
638 register const unsigned char *u = (unsigned char *) ptr;
639 register const unsigned char *eu = u + sz;
640 for (; u != eu; ++u) {
641 register unsigned char uu = *u;
642 *(c++) = hex[(uu & 0xf0) >> 4];
643 *(c++) = hex[uu & 0xf];
644 }
645 return c;
646 }
647
648 /*
649 Unpack binary data from a string
650 */
651 SWIGRUNTIME const char *
SWIG_UnpackData(const char * c,void * ptr,size_t sz)652 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
653 register unsigned char *u = (unsigned char *) ptr;
654 register const unsigned char *eu = u + sz;
655 for (; u != eu; ++u) {
656 register char d = *(c++);
657 register unsigned char uu;
658 if ((d >= '0') && (d <= '9'))
659 uu = ((d - '0') << 4);
660 else if ((d >= 'a') && (d <= 'f'))
661 uu = ((d - ('a'-10)) << 4);
662 else
663 return (char *) 0;
664 d = *(c++);
665 if ((d >= '0') && (d <= '9'))
666 uu |= (d - '0');
667 else if ((d >= 'a') && (d <= 'f'))
668 uu |= (d - ('a'-10));
669 else
670 return (char *) 0;
671 *u = uu;
672 }
673 return c;
674 }
675
676 /*
677 Pack 'void *' into a string buffer.
678 */
679 SWIGRUNTIME char *
SWIG_PackVoidPtr(char * buff,void * ptr,const char * name,size_t bsz)680 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
681 char *r = buff;
682 if ((2*sizeof(void *) + 2) > bsz) return 0;
683 *(r++) = '_';
684 r = SWIG_PackData(r,&ptr,sizeof(void *));
685 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
686 strcpy(r,name);
687 return buff;
688 }
689
690 SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char * c,void ** ptr,const char * name)691 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
692 if (*c != '_') {
693 if (strcmp(c,"NULL") == 0) {
694 *ptr = (void *) 0;
695 return name;
696 } else {
697 return 0;
698 }
699 }
700 return SWIG_UnpackData(++c,ptr,sizeof(void *));
701 }
702
703 SWIGRUNTIME char *
SWIG_PackDataName(char * buff,void * ptr,size_t sz,const char * name,size_t bsz)704 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
705 char *r = buff;
706 size_t lname = (name ? strlen(name) : 0);
707 if ((2*sz + 2 + lname) > bsz) return 0;
708 *(r++) = '_';
709 r = SWIG_PackData(r,ptr,sz);
710 if (lname) {
711 strncpy(r,name,lname+1);
712 } else {
713 *r = 0;
714 }
715 return buff;
716 }
717
718 SWIGRUNTIME const char *
SWIG_UnpackDataName(const char * c,void * ptr,size_t sz,const char * name)719 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
720 if (*c != '_') {
721 if (strcmp(c,"NULL") == 0) {
722 memset(ptr,0,sz);
723 return name;
724 } else {
725 return 0;
726 }
727 }
728 return SWIG_UnpackData(++c,ptr,sz);
729 }
730
731 #ifdef __cplusplus
732 }
733 #endif
734
735 /* Errors in SWIG */
736 #define SWIG_UnknownError -1
737 #define SWIG_IOError -2
738 #define SWIG_RuntimeError -3
739 #define SWIG_IndexError -4
740 #define SWIG_TypeError -5
741 #define SWIG_DivisionByZero -6
742 #define SWIG_OverflowError -7
743 #define SWIG_SyntaxError -8
744 #define SWIG_ValueError -9
745 #define SWIG_SystemError -10
746 #define SWIG_AttributeError -11
747 #define SWIG_MemoryError -12
748 #define SWIG_NullReferenceError -13
749
750
751
752 /* Compatibility marcos for Python 3 */
753 #if PY_VERSION_HEX >= 0x03000000
754
755 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
756 #define PyInt_Check(x) PyLong_Check(x)
757 #define PyInt_AsLong(x) PyLong_AsLong(x)
758 #define PyInt_FromLong(x) PyLong_FromLong(x)
759 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
760
761 #endif
762
763 #ifndef Py_TYPE
764 # define Py_TYPE(op) ((op)->ob_type)
765 #endif
766
767 /* SWIG APIs for compatibility of both Python 2 & 3 */
768
769 #if PY_VERSION_HEX >= 0x03000000
770 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
771 #else
772 # define SWIG_Python_str_FromFormat PyString_FromFormat
773 #endif
774
775
776 /* Warning: This function will allocate a new string in Python 3,
777 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
778 */
779 SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject * str)780 SWIG_Python_str_AsChar(PyObject *str)
781 {
782 #if PY_VERSION_HEX >= 0x03000000
783 char *cstr;
784 char *newstr;
785 int len;
786 str = PyUnicode_AsUTF8String(str);
787 PyBytes_AsStringAndSize(str, &cstr, &len);
788 newstr = (char *) malloc(len+1);
789 memcpy(newstr, cstr, len+1);
790 Py_XDECREF(str);
791 return newstr;
792 #else
793 return PyString_AsString(str);
794 #endif
795 }
796
797 #if PY_VERSION_HEX >= 0x03000000
798 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
799 #else
800 # define SWIG_Python_str_DelForPy3(x)
801 #endif
802
803
804 SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char * c)805 SWIG_Python_str_FromChar(const char *c)
806 {
807 #if PY_VERSION_HEX >= 0x03000000
808 return PyUnicode_FromString(c);
809 #else
810 return PyString_FromString(c);
811 #endif
812 }
813
814 /* Add PyOS_snprintf for old Pythons */
815 #if PY_VERSION_HEX < 0x02020000
816 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
817 # define PyOS_snprintf _snprintf
818 # else
819 # define PyOS_snprintf snprintf
820 # endif
821 #endif
822
823 /* A crude PyString_FromFormat implementation for old Pythons */
824 #if PY_VERSION_HEX < 0x02020000
825
826 #ifndef SWIG_PYBUFFER_SIZE
827 # define SWIG_PYBUFFER_SIZE 1024
828 #endif
829
830 static PyObject *
PyString_FromFormat(const char * fmt,...)831 PyString_FromFormat(const char *fmt, ...) {
832 va_list ap;
833 char buf[SWIG_PYBUFFER_SIZE * 2];
834 int res;
835 va_start(ap, fmt);
836 res = vsnprintf(buf, sizeof(buf), fmt, ap);
837 va_end(ap);
838 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
839 }
840 #endif
841
842 /* Add PyObject_Del for old Pythons */
843 #if PY_VERSION_HEX < 0x01060000
844 # define PyObject_Del(op) PyMem_DEL((op))
845 #endif
846 #ifndef PyObject_DEL
847 # define PyObject_DEL PyObject_Del
848 #endif
849
850 /* A crude PyExc_StopIteration exception for old Pythons */
851 #if PY_VERSION_HEX < 0x02020000
852 # ifndef PyExc_StopIteration
853 # define PyExc_StopIteration PyExc_RuntimeError
854 # endif
855 # ifndef PyObject_GenericGetAttr
856 # define PyObject_GenericGetAttr 0
857 # endif
858 #endif
859
860 /* Py_NotImplemented is defined in 2.1 and up. */
861 #if PY_VERSION_HEX < 0x02010000
862 # ifndef Py_NotImplemented
863 # define Py_NotImplemented PyExc_RuntimeError
864 # endif
865 #endif
866
867 /* A crude PyString_AsStringAndSize implementation for old Pythons */
868 #if PY_VERSION_HEX < 0x02010000
869 # ifndef PyString_AsStringAndSize
870 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
871 # endif
872 #endif
873
874 /* PySequence_Size for old Pythons */
875 #if PY_VERSION_HEX < 0x02000000
876 # ifndef PySequence_Size
877 # define PySequence_Size PySequence_Length
878 # endif
879 #endif
880
881 /* PyBool_FromLong for old Pythons */
882 #if PY_VERSION_HEX < 0x02030000
883 static
PyBool_FromLong(long ok)884 PyObject *PyBool_FromLong(long ok)
885 {
886 PyObject *result = ok ? Py_True : Py_False;
887 Py_INCREF(result);
888 return result;
889 }
890 #endif
891
892 /* Py_ssize_t for old Pythons */
893 /* This code is as recommended by: */
894 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
895 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
896 typedef int Py_ssize_t;
897 # define PY_SSIZE_T_MAX INT_MAX
898 # define PY_SSIZE_T_MIN INT_MIN
899 #endif
900
901 /* -----------------------------------------------------------------------------
902 * error manipulation
903 * ----------------------------------------------------------------------------- */
904
905 SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code)906 SWIG_Python_ErrorType(int code) {
907 PyObject* type = 0;
908 switch(code) {
909 case SWIG_MemoryError:
910 type = PyExc_MemoryError;
911 break;
912 case SWIG_IOError:
913 type = PyExc_IOError;
914 break;
915 case SWIG_RuntimeError:
916 type = PyExc_RuntimeError;
917 break;
918 case SWIG_IndexError:
919 type = PyExc_IndexError;
920 break;
921 case SWIG_TypeError:
922 type = PyExc_TypeError;
923 break;
924 case SWIG_DivisionByZero:
925 type = PyExc_ZeroDivisionError;
926 break;
927 case SWIG_OverflowError:
928 type = PyExc_OverflowError;
929 break;
930 case SWIG_SyntaxError:
931 type = PyExc_SyntaxError;
932 break;
933 case SWIG_ValueError:
934 type = PyExc_ValueError;
935 break;
936 case SWIG_SystemError:
937 type = PyExc_SystemError;
938 break;
939 case SWIG_AttributeError:
940 type = PyExc_AttributeError;
941 break;
942 default:
943 type = PyExc_RuntimeError;
944 }
945 return type;
946 }
947
948
949 SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char * mesg)950 SWIG_Python_AddErrorMsg(const char* mesg)
951 {
952 PyObject *type = 0;
953 PyObject *value = 0;
954 PyObject *traceback = 0;
955
956 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
957 if (value) {
958 char *tmp;
959 PyObject *old_str = PyObject_Str(value);
960 PyErr_Clear();
961 Py_XINCREF(type);
962
963 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
964 SWIG_Python_str_DelForPy3(tmp);
965 Py_DECREF(old_str);
966 Py_DECREF(value);
967 } else {
968 PyErr_SetString(PyExc_RuntimeError, mesg);
969 }
970 }
971
972 #if defined(SWIG_PYTHON_NO_THREADS)
973 # if defined(SWIG_PYTHON_THREADS)
974 # undef SWIG_PYTHON_THREADS
975 # endif
976 #endif
977 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
978 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
979 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
980 # define SWIG_PYTHON_USE_GIL
981 # endif
982 # endif
983 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
984 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
985 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
986 # endif
987 # ifdef __cplusplus /* C++ code */
988 class SWIG_Python_Thread_Block {
989 bool status;
990 PyGILState_STATE state;
991 public:
end()992 void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block()993 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block()994 ~SWIG_Python_Thread_Block() { end(); }
995 };
996 class SWIG_Python_Thread_Allow {
997 bool status;
998 PyThreadState *save;
999 public:
end()1000 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow()1001 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow()1002 ~SWIG_Python_Thread_Allow() { end(); }
1003 };
1004 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1005 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1006 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1007 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1008 # else /* C code */
1009 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1010 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1011 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1012 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1013 # endif
1014 # else /* Old thread way, not implemented, user must provide it */
1015 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1016 # define SWIG_PYTHON_INITIALIZE_THREADS
1017 # endif
1018 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1019 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1020 # endif
1021 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1022 # define SWIG_PYTHON_THREAD_END_BLOCK
1023 # endif
1024 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1025 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1026 # endif
1027 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1028 # define SWIG_PYTHON_THREAD_END_ALLOW
1029 # endif
1030 # endif
1031 #else /* No thread support */
1032 # define SWIG_PYTHON_INITIALIZE_THREADS
1033 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1034 # define SWIG_PYTHON_THREAD_END_BLOCK
1035 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1036 # define SWIG_PYTHON_THREAD_END_ALLOW
1037 #endif
1038
1039 /* -----------------------------------------------------------------------------
1040 * Python API portion that goes into the runtime
1041 * ----------------------------------------------------------------------------- */
1042
1043 #ifdef __cplusplus
1044 extern "C" {
1045 #if 0
1046 } /* cc-mode */
1047 #endif
1048 #endif
1049
1050 /* -----------------------------------------------------------------------------
1051 * Constant declarations
1052 * ----------------------------------------------------------------------------- */
1053
1054 /* Constant Types */
1055 #define SWIG_PY_POINTER 4
1056 #define SWIG_PY_BINARY 5
1057
1058 /* Constant information structure */
1059 typedef struct swig_const_info {
1060 int type;
1061 char *name;
1062 long lvalue;
1063 double dvalue;
1064 void *pvalue;
1065 swig_type_info **ptype;
1066 } swig_const_info;
1067
1068
1069 /* -----------------------------------------------------------------------------
1070 * Wrapper of PyInstanceMethod_New() used in Python 3
1071 * It is exported to the generated module, used for -fastproxy
1072 * ----------------------------------------------------------------------------- */
SWIG_PyInstanceMethod_New(PyObject * self,PyObject * func)1073 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
1074 {
1075 #if PY_VERSION_HEX >= 0x03000000
1076 return PyInstanceMethod_New(func);
1077 #else
1078 return NULL;
1079 #endif
1080 }
1081
1082 #ifdef __cplusplus
1083 #if 0
1084 { /* cc-mode */
1085 #endif
1086 }
1087 #endif
1088
1089
1090 /* -----------------------------------------------------------------------------
1091 * See the LICENSE file for information on copyright, usage and redistribution
1092 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1093 *
1094 * pyrun.swg
1095 *
1096 * This file contains the runtime support for Python modules
1097 * and includes code for managing global variables and pointer
1098 * type checking.
1099 *
1100 * ----------------------------------------------------------------------------- */
1101
1102 /* Common SWIG API */
1103
1104 /* for raw pointers */
1105 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1106 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1107 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1108 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
1109 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1110 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1111 #define swig_owntype int
1112
1113 /* for raw packed data */
1114 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1115 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1116
1117 /* for class or struct pointers */
1118 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1119 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1120
1121 /* for C or C++ function pointers */
1122 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1123 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1124
1125 /* for C++ member pointers, ie, member methods */
1126 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1127 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1128
1129
1130 /* Runtime API */
1131
1132 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1133 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1134 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1135
1136 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1137 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1138 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1139 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1140 #define SWIG_fail goto fail
1141
1142
1143 /* Runtime API implementation */
1144
1145 /* Error manipulation */
1146
1147 SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject * errtype,PyObject * obj)1148 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1149 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1150 PyErr_SetObject(errtype, obj);
1151 Py_DECREF(obj);
1152 SWIG_PYTHON_THREAD_END_BLOCK;
1153 }
1154
1155 SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject * errtype,const char * msg)1156 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1157 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1158 PyErr_SetString(errtype, (char *) msg);
1159 SWIG_PYTHON_THREAD_END_BLOCK;
1160 }
1161
1162 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1163
1164 /* Set a constant value */
1165
1166 SWIGINTERN void
SWIG_Python_SetConstant(PyObject * d,const char * name,PyObject * obj)1167 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1168 PyDict_SetItemString(d, (char*) name, obj);
1169 Py_DECREF(obj);
1170 }
1171
1172 /* Append a value to the result obj */
1173
1174 SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject * result,PyObject * obj)1175 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1176 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1177 if (!result) {
1178 result = obj;
1179 } else if (result == Py_None) {
1180 Py_DECREF(result);
1181 result = obj;
1182 } else {
1183 if (!PyList_Check(result)) {
1184 PyObject *o2 = result;
1185 result = PyList_New(1);
1186 PyList_SetItem(result, 0, o2);
1187 }
1188 PyList_Append(result,obj);
1189 Py_DECREF(obj);
1190 }
1191 return result;
1192 #else
1193 PyObject* o2;
1194 PyObject* o3;
1195 if (!result) {
1196 result = obj;
1197 } else if (result == Py_None) {
1198 Py_DECREF(result);
1199 result = obj;
1200 } else {
1201 if (!PyTuple_Check(result)) {
1202 o2 = result;
1203 result = PyTuple_New(1);
1204 PyTuple_SET_ITEM(result, 0, o2);
1205 }
1206 o3 = PyTuple_New(1);
1207 PyTuple_SET_ITEM(o3, 0, obj);
1208 o2 = result;
1209 result = PySequence_Concat(o2, o3);
1210 Py_DECREF(o2);
1211 Py_DECREF(o3);
1212 }
1213 return result;
1214 #endif
1215 }
1216
1217 /* Unpack the argument tuple */
1218
1219 SWIGINTERN int
SWIG_Python_UnpackTuple(PyObject * args,const char * name,Py_ssize_t min,Py_ssize_t max,PyObject ** objs)1220 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1221 {
1222 if (!args) {
1223 if (!min && !max) {
1224 return 1;
1225 } else {
1226 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1227 name, (min == max ? "" : "at least "), (int)min);
1228 return 0;
1229 }
1230 }
1231 if (!PyTuple_Check(args)) {
1232 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1233 return 0;
1234 } else {
1235 register Py_ssize_t l = PyTuple_GET_SIZE(args);
1236 if (l < min) {
1237 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1238 name, (min == max ? "" : "at least "), (int)min, (int)l);
1239 return 0;
1240 } else if (l > max) {
1241 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1242 name, (min == max ? "" : "at most "), (int)max, (int)l);
1243 return 0;
1244 } else {
1245 register int i;
1246 for (i = 0; i < l; ++i) {
1247 objs[i] = PyTuple_GET_ITEM(args, i);
1248 }
1249 for (; l < max; ++l) {
1250 objs[l] = 0;
1251 }
1252 return i + 1;
1253 }
1254 }
1255 }
1256
1257 /* A functor is a function object with one single object argument */
1258 #if PY_VERSION_HEX >= 0x02020000
1259 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1260 #else
1261 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1262 #endif
1263
1264 /*
1265 Helper for static pointer initialization for both C and C++ code, for example
1266 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1267 */
1268 #ifdef __cplusplus
1269 #define SWIG_STATIC_POINTER(var) var
1270 #else
1271 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1272 #endif
1273
1274 /* -----------------------------------------------------------------------------
1275 * Pointer declarations
1276 * ----------------------------------------------------------------------------- */
1277
1278 /* Flags for new pointer objects */
1279 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1280 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1281
1282 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1283
1284 #ifdef __cplusplus
1285 extern "C" {
1286 #if 0
1287 } /* cc-mode */
1288 #endif
1289 #endif
1290
1291 /* How to access Py_None */
1292 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1293 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1294 # ifndef SWIG_PYTHON_BUILD_NONE
1295 # define SWIG_PYTHON_BUILD_NONE
1296 # endif
1297 # endif
1298 #endif
1299
1300 #ifdef SWIG_PYTHON_BUILD_NONE
1301 # ifdef Py_None
1302 # undef Py_None
1303 # define Py_None SWIG_Py_None()
1304 # endif
1305 SWIGRUNTIMEINLINE PyObject *
_SWIG_Py_None(void)1306 _SWIG_Py_None(void)
1307 {
1308 PyObject *none = Py_BuildValue((char*)"");
1309 Py_DECREF(none);
1310 return none;
1311 }
1312 SWIGRUNTIME PyObject *
SWIG_Py_None(void)1313 SWIG_Py_None(void)
1314 {
1315 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1316 return none;
1317 }
1318 #endif
1319
1320 /* The python void return value */
1321
1322 SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)1323 SWIG_Py_Void(void)
1324 {
1325 PyObject *none = Py_None;
1326 Py_INCREF(none);
1327 return none;
1328 }
1329
1330 /* SwigPyClientData */
1331
1332 typedef struct {
1333 PyObject *klass;
1334 PyObject *newraw;
1335 PyObject *newargs;
1336 PyObject *destroy;
1337 int delargs;
1338 int implicitconv;
1339 } SwigPyClientData;
1340
1341 SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info * ty)1342 SWIG_Python_CheckImplicit(swig_type_info *ty)
1343 {
1344 SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1345 return data ? data->implicitconv : 0;
1346 }
1347
1348 SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info * desc)1349 SWIG_Python_ExceptionType(swig_type_info *desc) {
1350 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1351 PyObject *klass = data ? data->klass : 0;
1352 return (klass ? klass : PyExc_RuntimeError);
1353 }
1354
1355
1356 SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject * obj)1357 SwigPyClientData_New(PyObject* obj)
1358 {
1359 if (!obj) {
1360 return 0;
1361 } else {
1362 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1363 /* the klass element */
1364 data->klass = obj;
1365 Py_INCREF(data->klass);
1366 /* the newraw method and newargs arguments used to create a new raw instance */
1367 if (PyClass_Check(obj)) {
1368 data->newraw = 0;
1369 data->newargs = obj;
1370 Py_INCREF(obj);
1371 } else {
1372 #if (PY_VERSION_HEX < 0x02020000)
1373 data->newraw = 0;
1374 #else
1375 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1376 #endif
1377 if (data->newraw) {
1378 Py_INCREF(data->newraw);
1379 data->newargs = PyTuple_New(1);
1380 PyTuple_SetItem(data->newargs, 0, obj);
1381 } else {
1382 data->newargs = obj;
1383 }
1384 Py_INCREF(data->newargs);
1385 }
1386 /* the destroy method, aka as the C++ delete method */
1387 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1388 if (PyErr_Occurred()) {
1389 PyErr_Clear();
1390 data->destroy = 0;
1391 }
1392 if (data->destroy) {
1393 int flags;
1394 Py_INCREF(data->destroy);
1395 flags = PyCFunction_GET_FLAGS(data->destroy);
1396 #ifdef METH_O
1397 data->delargs = !(flags & (METH_O));
1398 #else
1399 data->delargs = 0;
1400 #endif
1401 } else {
1402 data->delargs = 0;
1403 }
1404 data->implicitconv = 0;
1405 return data;
1406 }
1407 }
1408
1409 SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData * data)1410 SwigPyClientData_Del(SwigPyClientData* data)
1411 {
1412 Py_XDECREF(data->newraw);
1413 Py_XDECREF(data->newargs);
1414 Py_XDECREF(data->destroy);
1415 }
1416
1417 /* =============== SwigPyObject =====================*/
1418
1419 typedef struct {
1420 PyObject_HEAD
1421 void *ptr;
1422 swig_type_info *ty;
1423 int own;
1424 PyObject *next;
1425 } SwigPyObject;
1426
1427 SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject * v)1428 SwigPyObject_long(SwigPyObject *v)
1429 {
1430 return PyLong_FromVoidPtr(v->ptr);
1431 }
1432
1433 SWIGRUNTIME PyObject *
SwigPyObject_format(const char * fmt,SwigPyObject * v)1434 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1435 {
1436 PyObject *res = NULL;
1437 PyObject *args = PyTuple_New(1);
1438 if (args) {
1439 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1440 PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1441 if (ofmt) {
1442 #if PY_VERSION_HEX >= 0x03000000
1443 res = PyUnicode_Format(ofmt,args);
1444 #else
1445 res = PyString_Format(ofmt,args);
1446 #endif
1447 Py_DECREF(ofmt);
1448 }
1449 Py_DECREF(args);
1450 }
1451 }
1452 return res;
1453 }
1454
1455 SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject * v)1456 SwigPyObject_oct(SwigPyObject *v)
1457 {
1458 return SwigPyObject_format("%o",v);
1459 }
1460
1461 SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject * v)1462 SwigPyObject_hex(SwigPyObject *v)
1463 {
1464 return SwigPyObject_format("%x",v);
1465 }
1466
1467 SWIGRUNTIME PyObject *
1468 #ifdef METH_NOARGS
SwigPyObject_repr(SwigPyObject * v)1469 SwigPyObject_repr(SwigPyObject *v)
1470 #else
1471 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1472 #endif
1473 {
1474 const char *name = SWIG_TypePrettyName(v->ty);
1475 PyObject *hex = SwigPyObject_hex(v);
1476 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, hex);
1477 Py_DECREF(hex);
1478 if (v->next) {
1479 #ifdef METH_NOARGS
1480 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1481 #else
1482 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1483 #endif
1484 #if PY_VERSION_HEX >= 0x03000000
1485 PyObject *joined = PyUnicode_Concat(repr, nrep);
1486 Py_DecRef(repr);
1487 Py_DecRef(nrep);
1488 repr = joined;
1489 #else
1490 PyString_ConcatAndDel(&repr,nrep);
1491 #endif
1492 }
1493 return repr;
1494 }
1495
1496 SWIGRUNTIME int
SwigPyObject_print(SwigPyObject * v,FILE * fp,int SWIGUNUSEDPARM (flags))1497 SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1498 {
1499 char *str;
1500 #ifdef METH_NOARGS
1501 PyObject *repr = SwigPyObject_repr(v);
1502 #else
1503 PyObject *repr = SwigPyObject_repr(v, NULL);
1504 #endif
1505 if (repr) {
1506 str = SWIG_Python_str_AsChar(repr);
1507 fputs(str, fp);
1508 SWIG_Python_str_DelForPy3(str);
1509 Py_DECREF(repr);
1510 return 0;
1511 } else {
1512 return 1;
1513 }
1514 }
1515
1516 SWIGRUNTIME PyObject *
SwigPyObject_str(SwigPyObject * v)1517 SwigPyObject_str(SwigPyObject *v)
1518 {
1519 char result[SWIG_BUFFER_SIZE];
1520 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1521 SWIG_Python_str_FromChar(result) : 0;
1522 }
1523
1524 SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject * v,SwigPyObject * w)1525 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1526 {
1527 void *i = v->ptr;
1528 void *j = w->ptr;
1529 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1530 }
1531
1532 /* Added for Python 3.x, whould it also useful for Python 2.x? */
1533 SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject * v,SwigPyObject * w,int op)1534 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1535 {
1536 PyObject* res;
1537 if( op != Py_EQ && op != Py_NE ) {
1538 Py_INCREF(Py_NotImplemented);
1539 return Py_NotImplemented;
1540 }
1541 if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
1542 res = Py_True;
1543 else
1544 res = Py_False;
1545 Py_INCREF(res);
1546 return res;
1547 }
1548
1549
1550 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1551
1552 SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void)1553 SwigPyObject_type(void) {
1554 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1555 return type;
1556 }
1557
1558 SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject * op)1559 SwigPyObject_Check(PyObject *op) {
1560 return (Py_TYPE(op) == SwigPyObject_type())
1561 || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1562 }
1563
1564 SWIGRUNTIME PyObject *
1565 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1566
1567 SWIGRUNTIME void
SwigPyObject_dealloc(PyObject * v)1568 SwigPyObject_dealloc(PyObject *v)
1569 {
1570 SwigPyObject *sobj = (SwigPyObject *) v;
1571 PyObject *next = sobj->next;
1572 if (sobj->own == SWIG_POINTER_OWN) {
1573 swig_type_info *ty = sobj->ty;
1574 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1575 PyObject *destroy = data ? data->destroy : 0;
1576 if (destroy) {
1577 /* destroy is always a VARARGS method */
1578 PyObject *res;
1579 if (data->delargs) {
1580 /* we need to create a temporal object to carry the destroy operation */
1581 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1582 res = SWIG_Python_CallFunctor(destroy, tmp);
1583 Py_DECREF(tmp);
1584 } else {
1585 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1586 PyObject *mself = PyCFunction_GET_SELF(destroy);
1587 res = ((*meth)(mself, v));
1588 }
1589 Py_XDECREF(res);
1590 }
1591 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1592 else {
1593 const char *name = SWIG_TypePrettyName(ty);
1594 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1595 }
1596 #endif
1597 }
1598 Py_XDECREF(next);
1599 PyObject_DEL(v);
1600 }
1601
1602 SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject * v,PyObject * next)1603 SwigPyObject_append(PyObject* v, PyObject* next)
1604 {
1605 SwigPyObject *sobj = (SwigPyObject *) v;
1606 #ifndef METH_O
1607 PyObject *tmp = 0;
1608 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1609 next = tmp;
1610 #endif
1611 if (!SwigPyObject_Check(next)) {
1612 return NULL;
1613 }
1614 sobj->next = next;
1615 Py_INCREF(next);
1616 return SWIG_Py_Void();
1617 }
1618
1619 SWIGRUNTIME PyObject*
1620 #ifdef METH_NOARGS
SwigPyObject_next(PyObject * v)1621 SwigPyObject_next(PyObject* v)
1622 #else
1623 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1624 #endif
1625 {
1626 SwigPyObject *sobj = (SwigPyObject *) v;
1627 if (sobj->next) {
1628 Py_INCREF(sobj->next);
1629 return sobj->next;
1630 } else {
1631 return SWIG_Py_Void();
1632 }
1633 }
1634
1635 SWIGINTERN PyObject*
1636 #ifdef METH_NOARGS
SwigPyObject_disown(PyObject * v)1637 SwigPyObject_disown(PyObject *v)
1638 #else
1639 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1640 #endif
1641 {
1642 SwigPyObject *sobj = (SwigPyObject *)v;
1643 sobj->own = 0;
1644 return SWIG_Py_Void();
1645 }
1646
1647 SWIGINTERN PyObject*
1648 #ifdef METH_NOARGS
SwigPyObject_acquire(PyObject * v)1649 SwigPyObject_acquire(PyObject *v)
1650 #else
1651 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1652 #endif
1653 {
1654 SwigPyObject *sobj = (SwigPyObject *)v;
1655 sobj->own = SWIG_POINTER_OWN;
1656 return SWIG_Py_Void();
1657 }
1658
1659 SWIGINTERN PyObject*
SwigPyObject_own(PyObject * v,PyObject * args)1660 SwigPyObject_own(PyObject *v, PyObject *args)
1661 {
1662 PyObject *val = 0;
1663 #if (PY_VERSION_HEX < 0x02020000)
1664 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1665 #else
1666 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1667 #endif
1668 {
1669 return NULL;
1670 }
1671 else
1672 {
1673 SwigPyObject *sobj = (SwigPyObject *)v;
1674 PyObject *obj = PyBool_FromLong(sobj->own);
1675 if (val) {
1676 #ifdef METH_NOARGS
1677 if (PyObject_IsTrue(val)) {
1678 SwigPyObject_acquire(v);
1679 } else {
1680 SwigPyObject_disown(v);
1681 }
1682 #else
1683 if (PyObject_IsTrue(val)) {
1684 SwigPyObject_acquire(v,args);
1685 } else {
1686 SwigPyObject_disown(v,args);
1687 }
1688 #endif
1689 }
1690 return obj;
1691 }
1692 }
1693
1694 #ifdef METH_O
1695 static PyMethodDef
1696 swigobject_methods[] = {
1697 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1698 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1699 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1700 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1701 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1702 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1703 {0, 0, 0, 0}
1704 };
1705 #else
1706 static PyMethodDef
1707 swigobject_methods[] = {
1708 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1709 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1710 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1711 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1712 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1713 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1714 {0, 0, 0, 0}
1715 };
1716 #endif
1717
1718 #if PY_VERSION_HEX < 0x02020000
1719 SWIGINTERN PyObject *
SwigPyObject_getattr(SwigPyObject * sobj,char * name)1720 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1721 {
1722 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1723 }
1724 #endif
1725
1726 SWIGRUNTIME PyTypeObject*
_PySwigObject_type(void)1727 _PySwigObject_type(void) {
1728 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1729
1730 static PyNumberMethods SwigPyObject_as_number = {
1731 (binaryfunc)0, /*nb_add*/
1732 (binaryfunc)0, /*nb_subtract*/
1733 (binaryfunc)0, /*nb_multiply*/
1734 /* nb_divide removed in Python 3 */
1735 #if PY_VERSION_HEX < 0x03000000
1736 (binaryfunc)0, /*nb_divide*/
1737 #endif
1738 (binaryfunc)0, /*nb_remainder*/
1739 (binaryfunc)0, /*nb_divmod*/
1740 (ternaryfunc)0,/*nb_power*/
1741 (unaryfunc)0, /*nb_negative*/
1742 (unaryfunc)0, /*nb_positive*/
1743 (unaryfunc)0, /*nb_absolute*/
1744 (inquiry)0, /*nb_nonzero*/
1745 0, /*nb_invert*/
1746 0, /*nb_lshift*/
1747 0, /*nb_rshift*/
1748 0, /*nb_and*/
1749 0, /*nb_xor*/
1750 0, /*nb_or*/
1751 #if PY_VERSION_HEX < 0x03000000
1752 0, /*nb_coerce*/
1753 #endif
1754 (unaryfunc)SwigPyObject_long, /*nb_int*/
1755 #if PY_VERSION_HEX < 0x03000000
1756 (unaryfunc)SwigPyObject_long, /*nb_long*/
1757 #else
1758 0, /*nb_reserved*/
1759 #endif
1760 (unaryfunc)0, /*nb_float*/
1761 #if PY_VERSION_HEX < 0x03000000
1762 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1763 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1764 #endif
1765 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1766 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1767 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1768 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1769 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1770 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1771 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1772 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1773 #endif
1774 };
1775
1776 static PyTypeObject swigpyobject_type;
1777 static int type_init = 0;
1778 if (!type_init) {
1779 const PyTypeObject tmp
1780 = {
1781 /* PyOjbect header changed in Python 3 */
1782 #if PY_VERSION_HEX >= 0x03000000
1783 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1784 #else
1785 PyObject_HEAD_INIT(NULL)
1786 0, /* ob_size */
1787 #endif
1788 (char *)"SwigPyObject", /* tp_name */
1789 sizeof(SwigPyObject), /* tp_basicsize */
1790 0, /* tp_itemsize */
1791 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1792 (printfunc)SwigPyObject_print, /* tp_print */
1793 #if PY_VERSION_HEX < 0x02020000
1794 (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1795 #else
1796 (getattrfunc)0, /* tp_getattr */
1797 #endif
1798 (setattrfunc)0, /* tp_setattr */
1799 #if PY_VERSION_HEX >= 0x03000000
1800 0, /* tp_reserved in 3.0.1 */
1801 #else
1802 (cmpfunc)SwigPyObject_compare, /* tp_compare */
1803 #endif
1804 (reprfunc)SwigPyObject_repr, /* tp_repr */
1805 &SwigPyObject_as_number, /* tp_as_number */
1806 0, /* tp_as_sequence */
1807 0, /* tp_as_mapping */
1808 (hashfunc)0, /* tp_hash */
1809 (ternaryfunc)0, /* tp_call */
1810 (reprfunc)SwigPyObject_str, /* tp_str */
1811 PyObject_GenericGetAttr, /* tp_getattro */
1812 0, /* tp_setattro */
1813 0, /* tp_as_buffer */
1814 Py_TPFLAGS_DEFAULT, /* tp_flags */
1815 swigobject_doc, /* tp_doc */
1816 0, /* tp_traverse */
1817 0, /* tp_clear */
1818 (richcmpfunc)SwigPyObject_richcompare, /* tp_richcompare */
1819 0, /* tp_weaklistoffset */
1820 #if PY_VERSION_HEX >= 0x02020000
1821 0, /* tp_iter */
1822 0, /* tp_iternext */
1823 swigobject_methods, /* tp_methods */
1824 0, /* tp_members */
1825 0, /* tp_getset */
1826 0, /* tp_base */
1827 0, /* tp_dict */
1828 0, /* tp_descr_get */
1829 0, /* tp_descr_set */
1830 0, /* tp_dictoffset */
1831 0, /* tp_init */
1832 0, /* tp_alloc */
1833 0, /* tp_new */
1834 0, /* tp_free */
1835 0, /* tp_is_gc */
1836 0, /* tp_bases */
1837 0, /* tp_mro */
1838 0, /* tp_cache */
1839 0, /* tp_subclasses */
1840 0, /* tp_weaklist */
1841 #endif
1842 #if PY_VERSION_HEX >= 0x02030000
1843 0, /* tp_del */
1844 #endif
1845 #ifdef COUNT_ALLOCS
1846 0,0,0,0 /* tp_alloc -> tp_next */
1847 #endif
1848 };
1849 swigpyobject_type = tmp;
1850 /* for Python 3 we already assigned the ob_type in PyVarObject_HEAD_INIT() */
1851 #if PY_VERSION_HEX < 0x03000000
1852 swigpyobject_type.ob_type = &PyType_Type;
1853 #endif
1854 type_init = 1;
1855 }
1856 return &swigpyobject_type;
1857 }
1858
1859 SWIGRUNTIME PyObject *
SwigPyObject_New(void * ptr,swig_type_info * ty,int own)1860 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1861 {
1862 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1863 if (sobj) {
1864 sobj->ptr = ptr;
1865 sobj->ty = ty;
1866 sobj->own = own;
1867 sobj->next = 0;
1868 }
1869 return (PyObject *)sobj;
1870 }
1871
1872 /* -----------------------------------------------------------------------------
1873 * Implements a simple Swig Packed type, and use it instead of string
1874 * ----------------------------------------------------------------------------- */
1875
1876 typedef struct {
1877 PyObject_HEAD
1878 void *pack;
1879 swig_type_info *ty;
1880 size_t size;
1881 } SwigPyPacked;
1882
1883 SWIGRUNTIME int
SwigPyPacked_print(SwigPyPacked * v,FILE * fp,int SWIGUNUSEDPARM (flags))1884 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1885 {
1886 char result[SWIG_BUFFER_SIZE];
1887 fputs("<Swig Packed ", fp);
1888 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1889 fputs("at ", fp);
1890 fputs(result, fp);
1891 }
1892 fputs(v->ty->name,fp);
1893 fputs(">", fp);
1894 return 0;
1895 }
1896
1897 SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked * v)1898 SwigPyPacked_repr(SwigPyPacked *v)
1899 {
1900 char result[SWIG_BUFFER_SIZE];
1901 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1902 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1903 } else {
1904 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1905 }
1906 }
1907
1908 SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked * v)1909 SwigPyPacked_str(SwigPyPacked *v)
1910 {
1911 char result[SWIG_BUFFER_SIZE];
1912 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1913 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1914 } else {
1915 return SWIG_Python_str_FromChar(v->ty->name);
1916 }
1917 }
1918
1919 SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked * v,SwigPyPacked * w)1920 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
1921 {
1922 size_t i = v->size;
1923 size_t j = w->size;
1924 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1925 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1926 }
1927
1928 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1929
1930 SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void)1931 SwigPyPacked_type(void) {
1932 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1933 return type;
1934 }
1935
1936 SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject * op)1937 SwigPyPacked_Check(PyObject *op) {
1938 return ((op)->ob_type == _PySwigPacked_type())
1939 || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1940 }
1941
1942 SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject * v)1943 SwigPyPacked_dealloc(PyObject *v)
1944 {
1945 if (SwigPyPacked_Check(v)) {
1946 SwigPyPacked *sobj = (SwigPyPacked *) v;
1947 free(sobj->pack);
1948 }
1949 PyObject_DEL(v);
1950 }
1951
1952 SWIGRUNTIME PyTypeObject*
_PySwigPacked_type(void)1953 _PySwigPacked_type(void) {
1954 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1955 static PyTypeObject swigpypacked_type;
1956 static int type_init = 0;
1957 if (!type_init) {
1958 const PyTypeObject tmp
1959 = {
1960 /* PyObject header changed in Python 3 */
1961 #if PY_VERSION_HEX>=0x03000000
1962 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1963 #else
1964 PyObject_HEAD_INIT(NULL)
1965 0, /* ob_size */
1966 #endif
1967 (char *)"SwigPyPacked", /* tp_name */
1968 sizeof(SwigPyPacked), /* tp_basicsize */
1969 0, /* tp_itemsize */
1970 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
1971 (printfunc)SwigPyPacked_print, /* tp_print */
1972 (getattrfunc)0, /* tp_getattr */
1973 (setattrfunc)0, /* tp_setattr */
1974 #if PY_VERSION_HEX>=0x03000000
1975 0, /* tp_reserved in 3.0.1 */
1976 #else
1977 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
1978 #endif
1979 (reprfunc)SwigPyPacked_repr, /* tp_repr */
1980 0, /* tp_as_number */
1981 0, /* tp_as_sequence */
1982 0, /* tp_as_mapping */
1983 (hashfunc)0, /* tp_hash */
1984 (ternaryfunc)0, /* tp_call */
1985 (reprfunc)SwigPyPacked_str, /* tp_str */
1986 PyObject_GenericGetAttr, /* tp_getattro */
1987 0, /* tp_setattro */
1988 0, /* tp_as_buffer */
1989 Py_TPFLAGS_DEFAULT, /* tp_flags */
1990 swigpacked_doc, /* tp_doc */
1991 0, /* tp_traverse */
1992 0, /* tp_clear */
1993 0, /* tp_richcompare */
1994 0, /* tp_weaklistoffset */
1995 #if PY_VERSION_HEX >= 0x02020000
1996 0, /* tp_iter */
1997 0, /* tp_iternext */
1998 0, /* tp_methods */
1999 0, /* tp_members */
2000 0, /* tp_getset */
2001 0, /* tp_base */
2002 0, /* tp_dict */
2003 0, /* tp_descr_get */
2004 0, /* tp_descr_set */
2005 0, /* tp_dictoffset */
2006 0, /* tp_init */
2007 0, /* tp_alloc */
2008 0, /* tp_new */
2009 0, /* tp_free */
2010 0, /* tp_is_gc */
2011 0, /* tp_bases */
2012 0, /* tp_mro */
2013 0, /* tp_cache */
2014 0, /* tp_subclasses */
2015 0, /* tp_weaklist */
2016 #endif
2017 #if PY_VERSION_HEX >= 0x02030000
2018 0, /* tp_del */
2019 #endif
2020 #ifdef COUNT_ALLOCS
2021 0,0,0,0 /* tp_alloc -> tp_next */
2022 #endif
2023 };
2024 swigpypacked_type = tmp;
2025 /* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
2026 #if PY_VERSION_HEX < 0x03000000
2027 swigpypacked_type.ob_type = &PyType_Type;
2028 #endif
2029 type_init = 1;
2030 }
2031 return &swigpypacked_type;
2032 }
2033
2034 SWIGRUNTIME PyObject *
SwigPyPacked_New(void * ptr,size_t size,swig_type_info * ty)2035 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2036 {
2037 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2038 if (sobj) {
2039 void *pack = malloc(size);
2040 if (pack) {
2041 memcpy(pack, ptr, size);
2042 sobj->pack = pack;
2043 sobj->ty = ty;
2044 sobj->size = size;
2045 } else {
2046 PyObject_DEL((PyObject *) sobj);
2047 sobj = 0;
2048 }
2049 }
2050 return (PyObject *) sobj;
2051 }
2052
2053 SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject * obj,void * ptr,size_t size)2054 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2055 {
2056 if (SwigPyPacked_Check(obj)) {
2057 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2058 if (sobj->size != size) return 0;
2059 memcpy(ptr, sobj->pack, size);
2060 return sobj->ty;
2061 } else {
2062 return 0;
2063 }
2064 }
2065
2066 /* -----------------------------------------------------------------------------
2067 * pointers/data manipulation
2068 * ----------------------------------------------------------------------------- */
2069
2070 SWIGRUNTIMEINLINE PyObject *
_SWIG_This(void)2071 _SWIG_This(void)
2072 {
2073 return SWIG_Python_str_FromChar("this");
2074 }
2075
2076 SWIGRUNTIME PyObject *
SWIG_This(void)2077 SWIG_This(void)
2078 {
2079 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
2080 return swig_this;
2081 }
2082
2083 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2084
2085 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2086 #if PY_VERSION_HEX>=0x03000000
2087 #define SWIG_PYTHON_SLOW_GETSET_THIS
2088 #endif
2089
2090 SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject * pyobj)2091 SWIG_Python_GetSwigThis(PyObject *pyobj)
2092 {
2093 if (SwigPyObject_Check(pyobj)) {
2094 return (SwigPyObject *) pyobj;
2095 } else {
2096 PyObject *obj = 0;
2097 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2098 if (PyInstance_Check(pyobj)) {
2099 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2100 } else {
2101 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2102 if (dictptr != NULL) {
2103 PyObject *dict = *dictptr;
2104 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2105 } else {
2106 #ifdef PyWeakref_CheckProxy
2107 if (PyWeakref_CheckProxy(pyobj)) {
2108 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2109 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2110 }
2111 #endif
2112 obj = PyObject_GetAttr(pyobj,SWIG_This());
2113 if (obj) {
2114 Py_DECREF(obj);
2115 } else {
2116 if (PyErr_Occurred()) PyErr_Clear();
2117 return 0;
2118 }
2119 }
2120 }
2121 #else
2122 obj = PyObject_GetAttr(pyobj,SWIG_This());
2123 if (obj) {
2124 Py_DECREF(obj);
2125 } else {
2126 if (PyErr_Occurred()) PyErr_Clear();
2127 return 0;
2128 }
2129 #endif
2130 if (obj && !SwigPyObject_Check(obj)) {
2131 /* a PyObject is called 'this', try to get the 'real this'
2132 SwigPyObject from it */
2133 return SWIG_Python_GetSwigThis(obj);
2134 }
2135 return (SwigPyObject *)obj;
2136 }
2137 }
2138
2139 /* Acquire a pointer value */
2140
2141 SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject * obj,int own)2142 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2143 if (own == SWIG_POINTER_OWN) {
2144 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2145 if (sobj) {
2146 int oldown = sobj->own;
2147 sobj->own = own;
2148 return oldown;
2149 }
2150 }
2151 return 0;
2152 }
2153
2154 /* Convert a pointer value */
2155
2156 SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject * obj,void ** ptr,swig_type_info * ty,int flags,int * own)2157 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2158 if (!obj) return SWIG_ERROR;
2159 if (obj == Py_None) {
2160 if (ptr) *ptr = 0;
2161 return SWIG_OK;
2162 } else {
2163 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2164 if (own)
2165 *own = 0;
2166 while (sobj) {
2167 void *vptr = sobj->ptr;
2168 if (ty) {
2169 swig_type_info *to = sobj->ty;
2170 if (to == ty) {
2171 /* no type cast needed */
2172 if (ptr) *ptr = vptr;
2173 break;
2174 } else {
2175 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2176 if (!tc) {
2177 sobj = (SwigPyObject *)sobj->next;
2178 } else {
2179 if (ptr) {
2180 int newmemory = 0;
2181 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2182 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2183 assert(own);
2184 if (own)
2185 *own = *own | SWIG_CAST_NEW_MEMORY;
2186 }
2187 }
2188 break;
2189 }
2190 }
2191 } else {
2192 if (ptr) *ptr = vptr;
2193 break;
2194 }
2195 }
2196 if (sobj) {
2197 if (own)
2198 *own = *own | sobj->own;
2199 if (flags & SWIG_POINTER_DISOWN) {
2200 sobj->own = 0;
2201 }
2202 return SWIG_OK;
2203 } else {
2204 int res = SWIG_ERROR;
2205 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2206 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2207 if (data && !data->implicitconv) {
2208 PyObject *klass = data->klass;
2209 if (klass) {
2210 PyObject *impconv;
2211 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2212 impconv = SWIG_Python_CallFunctor(klass, obj);
2213 data->implicitconv = 0;
2214 if (PyErr_Occurred()) {
2215 PyErr_Clear();
2216 impconv = 0;
2217 }
2218 if (impconv) {
2219 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2220 if (iobj) {
2221 void *vptr;
2222 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2223 if (SWIG_IsOK(res)) {
2224 if (ptr) {
2225 *ptr = vptr;
2226 /* transfer the ownership to 'ptr' */
2227 iobj->own = 0;
2228 res = SWIG_AddCast(res);
2229 res = SWIG_AddNewMask(res);
2230 } else {
2231 res = SWIG_AddCast(res);
2232 }
2233 }
2234 }
2235 Py_DECREF(impconv);
2236 }
2237 }
2238 }
2239 }
2240 return res;
2241 }
2242 }
2243 }
2244
2245 /* Convert a function ptr value */
2246
2247 SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject * obj,void ** ptr,swig_type_info * ty)2248 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2249 if (!PyCFunction_Check(obj)) {
2250 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2251 } else {
2252 void *vptr = 0;
2253
2254 /* here we get the method pointer for callbacks */
2255 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2256 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2257 if (desc) {
2258 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2259 if (!desc) return SWIG_ERROR;
2260 }
2261 if (ty) {
2262 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2263 if (tc) {
2264 int newmemory = 0;
2265 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2266 assert(!newmemory); /* newmemory handling not yet implemented */
2267 } else {
2268 return SWIG_ERROR;
2269 }
2270 } else {
2271 *ptr = vptr;
2272 }
2273 return SWIG_OK;
2274 }
2275 }
2276
2277 /* Convert a packed value value */
2278
2279 SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject * obj,void * ptr,size_t sz,swig_type_info * ty)2280 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2281 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2282 if (!to) return SWIG_ERROR;
2283 if (ty) {
2284 if (to != ty) {
2285 /* check type cast? */
2286 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2287 if (!tc) return SWIG_ERROR;
2288 }
2289 }
2290 return SWIG_OK;
2291 }
2292
2293 /* -----------------------------------------------------------------------------
2294 * Create a new pointer object
2295 * ----------------------------------------------------------------------------- */
2296
2297 /*
2298 Create a new instance object, whitout calling __init__, and set the
2299 'this' attribute.
2300 */
2301
2302 SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData * data,PyObject * swig_this)2303 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2304 {
2305 #if (PY_VERSION_HEX >= 0x02020000)
2306 PyObject *inst = 0;
2307 PyObject *newraw = data->newraw;
2308 if (newraw) {
2309 inst = PyObject_Call(newraw, data->newargs, NULL);
2310 if (inst) {
2311 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2312 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2313 if (dictptr != NULL) {
2314 PyObject *dict = *dictptr;
2315 if (dict == NULL) {
2316 dict = PyDict_New();
2317 *dictptr = dict;
2318 PyDict_SetItem(dict, SWIG_This(), swig_this);
2319 }
2320 }
2321 #else
2322 PyObject *key = SWIG_This();
2323 PyObject_SetAttr(inst, key, swig_this);
2324 #endif
2325 }
2326 } else {
2327 #if PY_VERSION_HEX >= 0x03000000
2328 inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2329 PyObject_SetAttr(inst, SWIG_This(), swig_this);
2330 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2331 #else
2332 PyObject *dict = PyDict_New();
2333 PyDict_SetItem(dict, SWIG_This(), swig_this);
2334 inst = PyInstance_NewRaw(data->newargs, dict);
2335 Py_DECREF(dict);
2336 #endif
2337 }
2338 return inst;
2339 #else
2340 #if (PY_VERSION_HEX >= 0x02010000)
2341 PyObject *inst;
2342 PyObject *dict = PyDict_New();
2343 PyDict_SetItem(dict, SWIG_This(), swig_this);
2344 inst = PyInstance_NewRaw(data->newargs, dict);
2345 Py_DECREF(dict);
2346 return (PyObject *) inst;
2347 #else
2348 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2349 if (inst == NULL) {
2350 return NULL;
2351 }
2352 inst->in_class = (PyClassObject *)data->newargs;
2353 Py_INCREF(inst->in_class);
2354 inst->in_dict = PyDict_New();
2355 if (inst->in_dict == NULL) {
2356 Py_DECREF(inst);
2357 return NULL;
2358 }
2359 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2360 inst->in_weakreflist = NULL;
2361 #endif
2362 #ifdef Py_TPFLAGS_GC
2363 PyObject_GC_Init(inst);
2364 #endif
2365 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2366 return (PyObject *) inst;
2367 #endif
2368 #endif
2369 }
2370
2371 SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject * inst,PyObject * swig_this)2372 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2373 {
2374 PyObject *dict;
2375 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2376 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2377 if (dictptr != NULL) {
2378 dict = *dictptr;
2379 if (dict == NULL) {
2380 dict = PyDict_New();
2381 *dictptr = dict;
2382 }
2383 PyDict_SetItem(dict, SWIG_This(), swig_this);
2384 return;
2385 }
2386 #endif
2387 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2388 PyDict_SetItem(dict, SWIG_This(), swig_this);
2389 Py_DECREF(dict);
2390 }
2391
2392
2393 SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject * args)2394 SWIG_Python_InitShadowInstance(PyObject *args) {
2395 PyObject *obj[2];
2396 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2397 return NULL;
2398 } else {
2399 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2400 if (sthis) {
2401 SwigPyObject_append((PyObject*) sthis, obj[1]);
2402 } else {
2403 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2404 }
2405 return SWIG_Py_Void();
2406 }
2407 }
2408
2409 /* Create a new pointer object */
2410
2411 SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(void * ptr,swig_type_info * type,int flags)2412 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2413 if (!ptr) {
2414 return SWIG_Py_Void();
2415 } else {
2416 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2417 PyObject *robj = SwigPyObject_New(ptr, type, own);
2418 SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2419 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2420 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2421 if (inst) {
2422 Py_DECREF(robj);
2423 robj = inst;
2424 }
2425 }
2426 return robj;
2427 }
2428 }
2429
2430 /* Create a new packed object */
2431
2432 SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void * ptr,size_t sz,swig_type_info * type)2433 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2434 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2435 }
2436
2437 /* -----------------------------------------------------------------------------*
2438 * Get type list
2439 * -----------------------------------------------------------------------------*/
2440
2441 #ifdef SWIG_LINK_RUNTIME
2442 void *SWIG_ReturnGlobalTypeList(void *);
2443 #endif
2444
2445 SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void)2446 SWIG_Python_GetModule(void) {
2447 static void *type_pointer = (void *)0;
2448 /* first check if module already created */
2449 if (!type_pointer) {
2450 #ifdef SWIG_LINK_RUNTIME
2451 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2452 #else
2453 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2454 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2455 if (PyErr_Occurred()) {
2456 PyErr_Clear();
2457 type_pointer = (void *)0;
2458 }
2459 #endif
2460 }
2461 return (swig_module_info *) type_pointer;
2462 }
2463
2464 #if PY_MAJOR_VERSION < 2
2465 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2466 is copied out of Python/modsupport.c in python version 2.3.4 */
2467 SWIGINTERN int
PyModule_AddObject(PyObject * m,char * name,PyObject * o)2468 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2469 {
2470 PyObject *dict;
2471 if (!PyModule_Check(m)) {
2472 PyErr_SetString(PyExc_TypeError,
2473 "PyModule_AddObject() needs module as first arg");
2474 return SWIG_ERROR;
2475 }
2476 if (!o) {
2477 PyErr_SetString(PyExc_TypeError,
2478 "PyModule_AddObject() needs non-NULL value");
2479 return SWIG_ERROR;
2480 }
2481
2482 dict = PyModule_GetDict(m);
2483 if (dict == NULL) {
2484 /* Internal error -- modules must have a dict! */
2485 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2486 PyModule_GetName(m));
2487 return SWIG_ERROR;
2488 }
2489 if (PyDict_SetItemString(dict, name, o))
2490 return SWIG_ERROR;
2491 Py_DECREF(o);
2492 return SWIG_OK;
2493 }
2494 #endif
2495
2496 SWIGRUNTIME void
SWIG_Python_DestroyModule(void * vptr)2497 SWIG_Python_DestroyModule(void *vptr)
2498 {
2499 swig_module_info *swig_module = (swig_module_info *) vptr;
2500 swig_type_info **types = swig_module->types;
2501 size_t i;
2502 for (i =0; i < swig_module->size; ++i) {
2503 swig_type_info *ty = types[i];
2504 if (ty->owndata) {
2505 SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2506 if (data) SwigPyClientData_Del(data);
2507 }
2508 }
2509 Py_DECREF(SWIG_This());
2510 }
2511
2512 SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info * swig_module)2513 SWIG_Python_SetModule(swig_module_info *swig_module) {
2514 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2515
2516 #if PY_VERSION_HEX >= 0x03000000
2517 /* Add a dummy module object into sys.modules */
2518 PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2519 #else
2520 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2521 swig_empty_runtime_method_table);
2522 #endif
2523 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2524 if (pointer && module) {
2525 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2526 } else {
2527 Py_XDECREF(pointer);
2528 }
2529 }
2530
2531 /* The python cached type query */
2532 SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void)2533 SWIG_Python_TypeCache(void) {
2534 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2535 return cache;
2536 }
2537
2538 SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char * type)2539 SWIG_Python_TypeQuery(const char *type)
2540 {
2541 PyObject *cache = SWIG_Python_TypeCache();
2542 PyObject *key = SWIG_Python_str_FromChar(type);
2543 PyObject *obj = PyDict_GetItem(cache, key);
2544 swig_type_info *descriptor;
2545 if (obj) {
2546 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2547 } else {
2548 swig_module_info *swig_module = SWIG_Python_GetModule();
2549 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2550 if (descriptor) {
2551 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2552 PyDict_SetItem(cache, key, obj);
2553 Py_DECREF(obj);
2554 }
2555 }
2556 Py_DECREF(key);
2557 return descriptor;
2558 }
2559
2560 /*
2561 For backward compatibility only
2562 */
2563 #define SWIG_POINTER_EXCEPTION 0
2564 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2565 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2566
2567 SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char * mesg,int infront)2568 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2569 {
2570 if (PyErr_Occurred()) {
2571 PyObject *type = 0;
2572 PyObject *value = 0;
2573 PyObject *traceback = 0;
2574 PyErr_Fetch(&type, &value, &traceback);
2575 if (value) {
2576 char *tmp;
2577 PyObject *old_str = PyObject_Str(value);
2578 Py_XINCREF(type);
2579 PyErr_Clear();
2580 if (infront) {
2581 PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2582 } else {
2583 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2584 }
2585 SWIG_Python_str_DelForPy3(tmp);
2586 Py_DECREF(old_str);
2587 }
2588 return 1;
2589 } else {
2590 return 0;
2591 }
2592 }
2593
2594 SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)2595 SWIG_Python_ArgFail(int argnum)
2596 {
2597 if (PyErr_Occurred()) {
2598 /* add information about failing argument */
2599 char mesg[256];
2600 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2601 return SWIG_Python_AddErrMesg(mesg, 1);
2602 } else {
2603 return 0;
2604 }
2605 }
2606
2607 SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject * self)2608 SwigPyObject_GetDesc(PyObject *self)
2609 {
2610 SwigPyObject *v = (SwigPyObject *)self;
2611 swig_type_info *ty = v ? v->ty : 0;
2612 return ty ? ty->str : (char*)"";
2613 }
2614
2615 SWIGRUNTIME void
SWIG_Python_TypeError(const char * type,PyObject * obj)2616 SWIG_Python_TypeError(const char *type, PyObject *obj)
2617 {
2618 if (type) {
2619 #if defined(SWIG_COBJECT_TYPES)
2620 if (obj && SwigPyObject_Check(obj)) {
2621 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2622 if (otype) {
2623 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2624 type, otype);
2625 return;
2626 }
2627 } else
2628 #endif
2629 {
2630 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2631 if (otype) {
2632 PyObject *str = PyObject_Str(obj);
2633 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2634 if (cstr) {
2635 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2636 type, otype, cstr);
2637 SWIG_Python_str_DelForPy3(cstr);
2638 } else {
2639 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2640 type, otype);
2641 }
2642 Py_XDECREF(str);
2643 return;
2644 }
2645 }
2646 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2647 } else {
2648 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2649 }
2650 }
2651
2652
2653 /* Convert a pointer value, signal an exception on a type mismatch */
2654 SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject * obj,swig_type_info * ty,int argnum,int flags)2655 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2656 void *result;
2657 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2658 PyErr_Clear();
2659 #if SWIG_POINTER_EXCEPTION
2660 if (flags) {
2661 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2662 SWIG_Python_ArgFail(argnum);
2663 }
2664 #endif
2665 }
2666 return result;
2667 }
2668
2669
2670 #ifdef __cplusplus
2671 #if 0
2672 { /* cc-mode */
2673 #endif
2674 }
2675 #endif
2676
2677
2678
2679 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2680
2681 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2682
2683
2684
2685 /* -------- TYPES TABLE (BEGIN) -------- */
2686
2687 #define SWIGTYPE_p_XdmfArray swig_types[0]
2688 #define SWIGTYPE_p_XdmfAttribute swig_types[1]
2689 #define SWIGTYPE_p_XdmfDOM swig_types[2]
2690 #define SWIGTYPE_p_XdmfDataDesc swig_types[3]
2691 #define SWIGTYPE_p_XdmfDataItem swig_types[4]
2692 #define SWIGTYPE_p_XdmfDataStructure swig_types[5]
2693 #define SWIGTYPE_p_XdmfDataTransform swig_types[6]
2694 #define SWIGTYPE_p_XdmfDiff swig_types[7]
2695 #define SWIGTYPE_p_XdmfDomain swig_types[8]
2696 #define SWIGTYPE_p_XdmfDsm swig_types[9]
2697 #define SWIGTYPE_p_XdmfDsmBuffer swig_types[10]
2698 #define SWIGTYPE_p_XdmfDsmComm swig_types[11]
2699 #define SWIGTYPE_p_XdmfDsmMsg swig_types[12]
2700 #define SWIGTYPE_p_XdmfElement swig_types[13]
2701 #define SWIGTYPE_p_XdmfExodusReader swig_types[14]
2702 #define SWIGTYPE_p_XdmfGeometry swig_types[15]
2703 #define SWIGTYPE_p_XdmfGrid swig_types[16]
2704 #define SWIGTYPE_p_XdmfHDF swig_types[17]
2705 #define SWIGTYPE_p_XdmfHeavyData swig_types[18]
2706 #define SWIGTYPE_p_XdmfInformation swig_types[19]
2707 #define SWIGTYPE_p_XdmfLightData swig_types[20]
2708 #define SWIGTYPE_p_XdmfMap swig_types[21]
2709 #define SWIGTYPE_p_XdmfObject swig_types[22]
2710 #define SWIGTYPE_p_XdmfRegion swig_types[23]
2711 #define SWIGTYPE_p_XdmfRoot swig_types[24]
2712 #define SWIGTYPE_p_XdmfSet swig_types[25]
2713 #define SWIGTYPE_p_XdmfTime swig_types[26]
2714 #define SWIGTYPE_p_XdmfTopology swig_types[27]
2715 #define SWIGTYPE_p_XdmfValues swig_types[28]
2716 #define SWIGTYPE_p_XdmfValuesBinary swig_types[29]
2717 #define SWIGTYPE_p_XdmfValuesHDF swig_types[30]
2718 #define SWIGTYPE_p_XdmfValuesXML swig_types[31]
2719 #define SWIGTYPE_p_char swig_types[32]
2720 #define SWIGTYPE_p_double swig_types[33]
2721 #define SWIGTYPE_p_float swig_types[34]
2722 #define SWIGTYPE_p_int swig_types[35]
2723 #define SWIGTYPE_p_long_long swig_types[36]
2724 #define SWIGTYPE_p_short swig_types[37]
2725 #define SWIGTYPE_p_unsigned_char swig_types[38]
2726 #define SWIGTYPE_p_unsigned_int swig_types[39]
2727 #define SWIGTYPE_p_unsigned_short swig_types[40]
2728 static swig_type_info *swig_types[42];
2729 static swig_module_info swig_module = {swig_types, 41, 0, 0, 0, 0};
2730 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2731 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2732
2733 /* -------- TYPES TABLE (END) -------- */
2734
2735 #if (PY_VERSION_HEX <= 0x02000000)
2736 # if !defined(SWIG_PYTHON_CLASSIC)
2737 # error "This python version requires swig to be run with the '-classic' option"
2738 # endif
2739 #endif
2740
2741 /*-----------------------------------------------
2742 @(target):= _XdmfUtils.so
2743 ------------------------------------------------*/
2744 #if PY_VERSION_HEX >= 0x03000000
2745 # define SWIG_init PyInit__XdmfUtils
2746
2747 #else
2748 # define SWIG_init init_XdmfUtils
2749
2750 #endif
2751 #define SWIG_name "_XdmfUtils"
2752
2753 #define SWIGVERSION 0x010339
2754 #define SWIG_VERSION SWIGVERSION
2755
2756
2757 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2758 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2759
2760
2761 #include <stdexcept>
2762
2763
2764 namespace swig {
2765 class SwigPtr_PyObject {
2766 protected:
2767 PyObject *_obj;
2768
2769 public:
SwigPtr_PyObject()2770 SwigPtr_PyObject() :_obj(0)
2771 {
2772 }
2773
SwigPtr_PyObject(const SwigPtr_PyObject & item)2774 SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
2775 {
2776 Py_XINCREF(_obj);
2777 }
2778
SwigPtr_PyObject(PyObject * obj,bool initial_ref=true)2779 SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
2780 {
2781 if (initial_ref) {
2782 Py_XINCREF(_obj);
2783 }
2784 }
2785
operator =(const SwigPtr_PyObject & item)2786 SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
2787 {
2788 Py_XINCREF(item._obj);
2789 Py_XDECREF(_obj);
2790 _obj = item._obj;
2791 return *this;
2792 }
2793
~SwigPtr_PyObject()2794 ~SwigPtr_PyObject()
2795 {
2796 Py_XDECREF(_obj);
2797 }
2798
operator PyObject*() const2799 operator PyObject *() const
2800 {
2801 return _obj;
2802 }
2803
operator ->() const2804 PyObject *operator->() const
2805 {
2806 return _obj;
2807 }
2808 };
2809 }
2810
2811
2812 namespace swig {
2813 struct SwigVar_PyObject : SwigPtr_PyObject {
SwigVar_PyObjectswig::SwigVar_PyObject2814 SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
2815
operator =swig::SwigVar_PyObject2816 SwigVar_PyObject & operator = (PyObject* obj)
2817 {
2818 Py_XDECREF(_obj);
2819 _obj = obj;
2820 return *this;
2821 }
2822 };
2823 }
2824
2825
2826
2827 #include <XdmfDiff.h>
2828 #include <XdmfExodusReader.h>
2829 #include <Xdmf.h>
2830
2831 #ifndef HAVE_STRTOLL
2832 # define strtoll XDMF_strtoll
XDMF_strtoll(char * str,void *,int)2833 inline XDMF_LONG64 XDMF_strtoll(char *str, void*, int)
2834 {
2835 XDMF_LONG64 result = 0;
2836 int negative=0;
2837
2838 while (*str == ' ' || *str == '\t')
2839 {
2840 str++;
2841 }
2842 if (*str == '+')
2843 {
2844 str++;
2845 }
2846 else if (*str == '-')
2847 {
2848 negative = 1;
2849 str++;
2850 }
2851
2852 while (*str >= '0' && *str <= '9')
2853 {
2854 result = (result*10)-(*str++ - '0');
2855 }
2856 return negative ? result : -result;
2857 }
2858 #else
2859 # define XDMF_strtoll strtoll
2860 #endif
2861
2862
2863
2864 SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)2865 SWIG_pchar_descriptor(void)
2866 {
2867 static int init = 0;
2868 static swig_type_info* info = 0;
2869 if (!init) {
2870 info = SWIG_TypeQuery("_p_char");
2871 init = 1;
2872 }
2873 return info;
2874 }
2875
2876
2877 SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject * obj,char ** cptr,size_t * psize,int * alloc)2878 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2879 {
2880 #if PY_VERSION_HEX>=0x03000000
2881 if (PyUnicode_Check(obj))
2882 #else
2883 if (PyString_Check(obj))
2884 #endif
2885 {
2886 char *cstr; Py_ssize_t len;
2887 #if PY_VERSION_HEX>=0x03000000
2888 if (!alloc && cptr) {
2889 /* We can't allow converting without allocation, since the internal
2890 representation of string in Python 3 is UCS-2/UCS-4 but we require
2891 a UTF-8 representation.
2892 TODO(bhy) More detailed explanation */
2893 return SWIG_RuntimeError;
2894 }
2895 obj = PyUnicode_AsUTF8String(obj);
2896 PyBytes_AsStringAndSize(obj, &cstr, &len);
2897 if(alloc) *alloc = SWIG_NEWOBJ;
2898 #else
2899 PyString_AsStringAndSize(obj, &cstr, &len);
2900 #endif
2901 if (cptr) {
2902 if (alloc) {
2903 /*
2904 In python the user should not be able to modify the inner
2905 string representation. To warranty that, if you define
2906 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
2907 buffer is always returned.
2908
2909 The default behavior is just to return the pointer value,
2910 so, be careful.
2911 */
2912 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
2913 if (*alloc != SWIG_OLDOBJ)
2914 #else
2915 if (*alloc == SWIG_NEWOBJ)
2916 #endif
2917 {
2918 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
2919 *alloc = SWIG_NEWOBJ;
2920 }
2921 else {
2922 *cptr = cstr;
2923 *alloc = SWIG_OLDOBJ;
2924 }
2925 } else {
2926 #if PY_VERSION_HEX>=0x03000000
2927 assert(0); /* Should never reach here in Python 3 */
2928 #endif
2929 *cptr = SWIG_Python_str_AsChar(obj);
2930 }
2931 }
2932 if (psize) *psize = len + 1;
2933 #if PY_VERSION_HEX>=0x03000000
2934 Py_XDECREF(obj);
2935 #endif
2936 return SWIG_OK;
2937 } else {
2938 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2939 if (pchar_descriptor) {
2940 void* vptr = 0;
2941 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
2942 if (cptr) *cptr = (char *) vptr;
2943 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
2944 if (alloc) *alloc = SWIG_OLDOBJ;
2945 return SWIG_OK;
2946 }
2947 }
2948 }
2949 return SWIG_TypeError;
2950 }
2951
2952
2953
2954
2955
2956 SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char * carray,size_t size)2957 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2958 {
2959 if (carray) {
2960 if (size > INT_MAX) {
2961 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2962 return pchar_descriptor ?
2963 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2964 } else {
2965 #if PY_VERSION_HEX >= 0x03000000
2966 return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
2967 #else
2968 return PyString_FromStringAndSize(carray, static_cast< int >(size));
2969 #endif
2970 }
2971 } else {
2972 return SWIG_Py_Void();
2973 }
2974 }
2975
2976
2977 SWIGINTERNINLINE PyObject *
SWIG_From_std_string(const std::string & s)2978 SWIG_From_std_string (const std::string& s)
2979 {
2980 if (s.size()) {
2981 return SWIG_FromCharPtrAndSize(s.data(), s.size());
2982 } else {
2983 return SWIG_FromCharPtrAndSize(s.c_str(), 0);
2984 }
2985 }
2986
2987
2988 #include <limits.h>
2989 #if !defined(SWIG_NO_LLONG_MAX)
2990 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2991 # define LLONG_MAX __LONG_LONG_MAX__
2992 # define LLONG_MIN (-LLONG_MAX - 1LL)
2993 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2994 # endif
2995 #endif
2996
2997
2998 SWIGINTERN int
SWIG_AsVal_double(PyObject * obj,double * val)2999 SWIG_AsVal_double (PyObject *obj, double *val)
3000 {
3001 int res = SWIG_TypeError;
3002 if (PyFloat_Check(obj)) {
3003 if (val) *val = PyFloat_AsDouble(obj);
3004 return SWIG_OK;
3005 } else if (PyInt_Check(obj)) {
3006 if (val) *val = PyInt_AsLong(obj);
3007 return SWIG_OK;
3008 } else if (PyLong_Check(obj)) {
3009 double v = PyLong_AsDouble(obj);
3010 if (!PyErr_Occurred()) {
3011 if (val) *val = v;
3012 return SWIG_OK;
3013 } else {
3014 PyErr_Clear();
3015 }
3016 }
3017 #ifdef SWIG_PYTHON_CAST_MODE
3018 {
3019 int dispatch = 0;
3020 double d = PyFloat_AsDouble(obj);
3021 if (!PyErr_Occurred()) {
3022 if (val) *val = d;
3023 return SWIG_AddCast(SWIG_OK);
3024 } else {
3025 PyErr_Clear();
3026 }
3027 if (!dispatch) {
3028 long v = PyLong_AsLong(obj);
3029 if (!PyErr_Occurred()) {
3030 if (val) *val = v;
3031 return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3032 } else {
3033 PyErr_Clear();
3034 }
3035 }
3036 }
3037 #endif
3038 return res;
3039 }
3040
3041
3042 #include <float.h>
3043
3044
3045 #include <math.h>
3046
3047
3048 SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double * d,double min,double max)3049 SWIG_CanCastAsInteger(double *d, double min, double max) {
3050 double x = *d;
3051 if ((min <= x && x <= max)) {
3052 double fx = floor(x);
3053 double cx = ceil(x);
3054 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3055 if ((errno == EDOM) || (errno == ERANGE)) {
3056 errno = 0;
3057 } else {
3058 double summ, reps, diff;
3059 if (rd < x) {
3060 diff = x - rd;
3061 } else if (rd > x) {
3062 diff = rd - x;
3063 } else {
3064 return 1;
3065 }
3066 summ = rd + x;
3067 reps = diff/summ;
3068 if (reps < 8*DBL_EPSILON) {
3069 *d = rd;
3070 return 1;
3071 }
3072 }
3073 }
3074 return 0;
3075 }
3076
3077
3078 SWIGINTERN int
SWIG_AsVal_long(PyObject * obj,long * val)3079 SWIG_AsVal_long (PyObject *obj, long* val)
3080 {
3081 if (PyInt_Check(obj)) {
3082 if (val) *val = PyInt_AsLong(obj);
3083 return SWIG_OK;
3084 } else if (PyLong_Check(obj)) {
3085 long v = PyLong_AsLong(obj);
3086 if (!PyErr_Occurred()) {
3087 if (val) *val = v;
3088 return SWIG_OK;
3089 } else {
3090 PyErr_Clear();
3091 }
3092 }
3093 #ifdef SWIG_PYTHON_CAST_MODE
3094 {
3095 int dispatch = 0;
3096 long v = PyInt_AsLong(obj);
3097 if (!PyErr_Occurred()) {
3098 if (val) *val = v;
3099 return SWIG_AddCast(SWIG_OK);
3100 } else {
3101 PyErr_Clear();
3102 }
3103 if (!dispatch) {
3104 double d;
3105 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3106 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3107 if (val) *val = (long)(d);
3108 return res;
3109 }
3110 }
3111 }
3112 #endif
3113 return SWIG_TypeError;
3114 }
3115
3116
3117 SWIGINTERN int
SWIG_AsVal_int(PyObject * obj,int * val)3118 SWIG_AsVal_int (PyObject * obj, int *val)
3119 {
3120 long v;
3121 int res = SWIG_AsVal_long (obj, &v);
3122 if (SWIG_IsOK(res)) {
3123 if ((v < INT_MIN || v > INT_MAX)) {
3124 return SWIG_OverflowError;
3125 } else {
3126 if (val) *val = static_cast< int >(v);
3127 }
3128 }
3129 return res;
3130 }
3131
3132
3133 #define SWIG_From_long PyInt_FromLong
3134
3135
3136 SWIGINTERNINLINE PyObject *
SWIG_From_int(int value)3137 SWIG_From_int (int value)
3138 {
3139 return SWIG_From_long (value);
3140 }
3141
3142
3143 SWIGINTERNINLINE PyObject *
SWIG_FromCharPtr(const char * cptr)3144 SWIG_FromCharPtr(const char *cptr)
3145 {
3146 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3147 }
3148
3149
3150 #define SWIG_From_double PyFloat_FromDouble
3151
3152
XdmfSwigException(int code,const char * msg)3153 void XdmfSwigException(int code, const char* msg)
3154 {
3155 /* SWIG_exception(code, msg); */
3156 }
3157
3158 #ifdef __cplusplus
3159 extern "C" {
3160 #endif
_wrap_new_XdmfDiff__SWIG_0(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3161 SWIGINTERN PyObject *_wrap_new_XdmfDiff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3162 PyObject *resultobj = 0;
3163 XdmfConstString arg1 = (XdmfConstString) 0 ;
3164 XdmfConstString arg2 = (XdmfConstString) 0 ;
3165 int res1 ;
3166 char *buf1 = 0 ;
3167 int alloc1 = 0 ;
3168 int res2 ;
3169 char *buf2 = 0 ;
3170 int alloc2 = 0 ;
3171 PyObject * obj0 = 0 ;
3172 PyObject * obj1 = 0 ;
3173 XdmfDiff *result = 0 ;
3174
3175 if (!PyArg_ParseTuple(args,(char *)"OO:new_XdmfDiff",&obj0,&obj1)) SWIG_fail;
3176 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
3177 if (!SWIG_IsOK(res1)) {
3178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XdmfDiff" "', argument " "1"" of type '" "XdmfConstString""'");
3179 }
3180 arg1 = reinterpret_cast< XdmfConstString >(buf1);
3181 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3182 if (!SWIG_IsOK(res2)) {
3183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XdmfDiff" "', argument " "2"" of type '" "XdmfConstString""'");
3184 }
3185 arg2 = reinterpret_cast< XdmfConstString >(buf2);
3186 result = (XdmfDiff *)new XdmfDiff(arg1,arg2);
3187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfDiff, SWIG_POINTER_NEW | 0 );
3188 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
3189 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3190 return resultobj;
3191 fail:
3192 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
3193 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3194 return NULL;
3195 }
3196
3197
_wrap_new_XdmfDiff__SWIG_1(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3198 SWIGINTERN PyObject *_wrap_new_XdmfDiff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3199 PyObject *resultobj = 0;
3200 XdmfDOM *arg1 = (XdmfDOM *) 0 ;
3201 XdmfDOM *arg2 = (XdmfDOM *) 0 ;
3202 void *argp1 = 0 ;
3203 int res1 = 0 ;
3204 void *argp2 = 0 ;
3205 int res2 = 0 ;
3206 PyObject * obj0 = 0 ;
3207 PyObject * obj1 = 0 ;
3208 XdmfDiff *result = 0 ;
3209
3210 if (!PyArg_ParseTuple(args,(char *)"OO:new_XdmfDiff",&obj0,&obj1)) SWIG_fail;
3211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDOM, 0 | 0 );
3212 if (!SWIG_IsOK(res1)) {
3213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XdmfDiff" "', argument " "1"" of type '" "XdmfDOM *""'");
3214 }
3215 arg1 = reinterpret_cast< XdmfDOM * >(argp1);
3216 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfDOM, 0 | 0 );
3217 if (!SWIG_IsOK(res2)) {
3218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XdmfDiff" "', argument " "2"" of type '" "XdmfDOM *""'");
3219 }
3220 arg2 = reinterpret_cast< XdmfDOM * >(argp2);
3221 result = (XdmfDiff *)new XdmfDiff(arg1,arg2);
3222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfDiff, SWIG_POINTER_NEW | 0 );
3223 return resultobj;
3224 fail:
3225 return NULL;
3226 }
3227
3228
_wrap_new_XdmfDiff(PyObject * self,PyObject * args)3229 SWIGINTERN PyObject *_wrap_new_XdmfDiff(PyObject *self, PyObject *args) {
3230 int argc;
3231 PyObject *argv[3];
3232 int ii;
3233
3234 if (!PyTuple_Check(args)) SWIG_fail;
3235 argc = (int)PyObject_Length(args);
3236 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
3237 argv[ii] = PyTuple_GET_ITEM(args,ii);
3238 }
3239 if (argc == 2) {
3240 int _v;
3241 void *vptr = 0;
3242 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDOM, 0);
3243 _v = SWIG_CheckState(res);
3244 if (_v) {
3245 void *vptr = 0;
3246 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfDOM, 0);
3247 _v = SWIG_CheckState(res);
3248 if (_v) {
3249 return _wrap_new_XdmfDiff__SWIG_1(self, args);
3250 }
3251 }
3252 }
3253 if (argc == 2) {
3254 int _v;
3255 int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
3256 _v = SWIG_CheckState(res);
3257 if (_v) {
3258 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
3259 _v = SWIG_CheckState(res);
3260 if (_v) {
3261 return _wrap_new_XdmfDiff__SWIG_0(self, args);
3262 }
3263 }
3264 }
3265
3266 fail:
3267 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_XdmfDiff'.\n"
3268 " Possible C/C++ prototypes are:\n"
3269 " XdmfDiff(XdmfConstString,XdmfConstString)\n"
3270 " XdmfDiff(XdmfDOM *,XdmfDOM *)\n");
3271 return NULL;
3272 }
3273
3274
_wrap_delete_XdmfDiff(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3275 SWIGINTERN PyObject *_wrap_delete_XdmfDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3276 PyObject *resultobj = 0;
3277 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3278 void *argp1 = 0 ;
3279 int res1 = 0 ;
3280 PyObject * obj0 = 0 ;
3281
3282 if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfDiff",&obj0)) SWIG_fail;
3283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, SWIG_POINTER_DISOWN | 0 );
3284 if (!SWIG_IsOK(res1)) {
3285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfDiff" "', argument " "1"" of type '" "XdmfDiff *""'");
3286 }
3287 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3288 delete arg1;
3289 resultobj = SWIG_Py_Void();
3290 return resultobj;
3291 fail:
3292 return NULL;
3293 }
3294
3295
_wrap_XdmfDiff_GetDiffs__SWIG_0(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3296 SWIGINTERN PyObject *_wrap_XdmfDiff_GetDiffs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3297 PyObject *resultobj = 0;
3298 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3299 void *argp1 = 0 ;
3300 int res1 = 0 ;
3301 PyObject * obj0 = 0 ;
3302 std::string result;
3303
3304 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_GetDiffs",&obj0)) SWIG_fail;
3305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3306 if (!SWIG_IsOK(res1)) {
3307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetDiffs" "', argument " "1"" of type '" "XdmfDiff *""'");
3308 }
3309 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3310 result = (arg1)->GetDiffs();
3311 resultobj = SWIG_From_std_string(static_cast< std::string >(result));
3312 return resultobj;
3313 fail:
3314 return NULL;
3315 }
3316
3317
_wrap_XdmfDiff_GetDiffs__SWIG_1(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3318 SWIGINTERN PyObject *_wrap_XdmfDiff_GetDiffs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3319 PyObject *resultobj = 0;
3320 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3321 XdmfConstString arg2 = (XdmfConstString) 0 ;
3322 void *argp1 = 0 ;
3323 int res1 = 0 ;
3324 int res2 ;
3325 char *buf2 = 0 ;
3326 int alloc2 = 0 ;
3327 PyObject * obj0 = 0 ;
3328 PyObject * obj1 = 0 ;
3329 std::string result;
3330
3331 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_GetDiffs",&obj0,&obj1)) SWIG_fail;
3332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3333 if (!SWIG_IsOK(res1)) {
3334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetDiffs" "', argument " "1"" of type '" "XdmfDiff *""'");
3335 }
3336 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3337 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3338 if (!SWIG_IsOK(res2)) {
3339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDiff_GetDiffs" "', argument " "2"" of type '" "XdmfConstString""'");
3340 }
3341 arg2 = reinterpret_cast< XdmfConstString >(buf2);
3342 result = (arg1)->GetDiffs(arg2);
3343 resultobj = SWIG_From_std_string(static_cast< std::string >(result));
3344 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3345 return resultobj;
3346 fail:
3347 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3348 return NULL;
3349 }
3350
3351
_wrap_XdmfDiff_GetDiffs(PyObject * self,PyObject * args)3352 SWIGINTERN PyObject *_wrap_XdmfDiff_GetDiffs(PyObject *self, PyObject *args) {
3353 int argc;
3354 PyObject *argv[3];
3355 int ii;
3356
3357 if (!PyTuple_Check(args)) SWIG_fail;
3358 argc = (int)PyObject_Length(args);
3359 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
3360 argv[ii] = PyTuple_GET_ITEM(args,ii);
3361 }
3362 if (argc == 1) {
3363 int _v;
3364 void *vptr = 0;
3365 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3366 _v = SWIG_CheckState(res);
3367 if (_v) {
3368 return _wrap_XdmfDiff_GetDiffs__SWIG_0(self, args);
3369 }
3370 }
3371 if (argc == 2) {
3372 int _v;
3373 void *vptr = 0;
3374 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3375 _v = SWIG_CheckState(res);
3376 if (_v) {
3377 int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
3378 _v = SWIG_CheckState(res);
3379 if (_v) {
3380 return _wrap_XdmfDiff_GetDiffs__SWIG_1(self, args);
3381 }
3382 }
3383 }
3384
3385 fail:
3386 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDiff_GetDiffs'.\n"
3387 " Possible C/C++ prototypes are:\n"
3388 " GetDiffs(XdmfDiff *)\n"
3389 " GetDiffs(XdmfDiff *,XdmfConstString)\n");
3390 return NULL;
3391 }
3392
3393
_wrap_XdmfDiff_SetIgnoreTime__SWIG_0(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3394 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3395 PyObject *resultobj = 0;
3396 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3397 XdmfBoolean arg2 ;
3398 void *argp1 = 0 ;
3399 int res1 = 0 ;
3400 int val2 ;
3401 int ecode2 = 0 ;
3402 PyObject * obj0 = 0 ;
3403 PyObject * obj1 = 0 ;
3404 XdmfInt32 result;
3405
3406 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_SetIgnoreTime",&obj0,&obj1)) SWIG_fail;
3407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3408 if (!SWIG_IsOK(res1)) {
3409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetIgnoreTime" "', argument " "1"" of type '" "XdmfDiff *""'");
3410 }
3411 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3412 ecode2 = SWIG_AsVal_int(obj1, &val2);
3413 if (!SWIG_IsOK(ecode2)) {
3414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDiff_SetIgnoreTime" "', argument " "2"" of type '" "XdmfBoolean""'");
3415 }
3416 arg2 = static_cast< XdmfBoolean >(val2);
3417 result = (XdmfInt32)(arg1)->SetIgnoreTime(arg2);
3418 resultobj = SWIG_From_int(static_cast< int >(result));
3419 return resultobj;
3420 fail:
3421 return NULL;
3422 }
3423
3424
_wrap_XdmfDiff_SetIgnoreTime__SWIG_1(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3425 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3426 PyObject *resultobj = 0;
3427 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3428 void *argp1 = 0 ;
3429 int res1 = 0 ;
3430 PyObject * obj0 = 0 ;
3431 XdmfInt32 result;
3432
3433 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_SetIgnoreTime",&obj0)) SWIG_fail;
3434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3435 if (!SWIG_IsOK(res1)) {
3436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetIgnoreTime" "', argument " "1"" of type '" "XdmfDiff *""'");
3437 }
3438 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3439 result = (XdmfInt32)(arg1)->SetIgnoreTime();
3440 resultobj = SWIG_From_int(static_cast< int >(result));
3441 return resultobj;
3442 fail:
3443 return NULL;
3444 }
3445
3446
_wrap_XdmfDiff_SetIgnoreTime(PyObject * self,PyObject * args)3447 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreTime(PyObject *self, PyObject *args) {
3448 int argc;
3449 PyObject *argv[3];
3450 int ii;
3451
3452 if (!PyTuple_Check(args)) SWIG_fail;
3453 argc = (int)PyObject_Length(args);
3454 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
3455 argv[ii] = PyTuple_GET_ITEM(args,ii);
3456 }
3457 if (argc == 1) {
3458 int _v;
3459 void *vptr = 0;
3460 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3461 _v = SWIG_CheckState(res);
3462 if (_v) {
3463 return _wrap_XdmfDiff_SetIgnoreTime__SWIG_1(self, args);
3464 }
3465 }
3466 if (argc == 2) {
3467 int _v;
3468 void *vptr = 0;
3469 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3470 _v = SWIG_CheckState(res);
3471 if (_v) {
3472 {
3473 int res = SWIG_AsVal_int(argv[1], NULL);
3474 _v = SWIG_CheckState(res);
3475 }
3476 if (_v) {
3477 return _wrap_XdmfDiff_SetIgnoreTime__SWIG_0(self, args);
3478 }
3479 }
3480 }
3481
3482 fail:
3483 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDiff_SetIgnoreTime'.\n"
3484 " Possible C/C++ prototypes are:\n"
3485 " SetIgnoreTime(XdmfDiff *,XdmfBoolean)\n"
3486 " SetIgnoreTime(XdmfDiff *)\n");
3487 return NULL;
3488 }
3489
3490
_wrap_XdmfDiff_GetIgnoreTime(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3491 SWIGINTERN PyObject *_wrap_XdmfDiff_GetIgnoreTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3492 PyObject *resultobj = 0;
3493 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3494 void *argp1 = 0 ;
3495 int res1 = 0 ;
3496 PyObject * obj0 = 0 ;
3497 XdmfInt32 result;
3498
3499 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_GetIgnoreTime",&obj0)) SWIG_fail;
3500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3501 if (!SWIG_IsOK(res1)) {
3502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetIgnoreTime" "', argument " "1"" of type '" "XdmfDiff *""'");
3503 }
3504 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3505 result = (XdmfInt32)(arg1)->GetIgnoreTime();
3506 resultobj = SWIG_From_int(static_cast< int >(result));
3507 return resultobj;
3508 fail:
3509 return NULL;
3510 }
3511
3512
_wrap_XdmfDiff_SetIgnoreGeometry__SWIG_0(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3513 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreGeometry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3514 PyObject *resultobj = 0;
3515 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3516 XdmfBoolean arg2 ;
3517 void *argp1 = 0 ;
3518 int res1 = 0 ;
3519 int val2 ;
3520 int ecode2 = 0 ;
3521 PyObject * obj0 = 0 ;
3522 PyObject * obj1 = 0 ;
3523 XdmfInt32 result;
3524
3525 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_SetIgnoreGeometry",&obj0,&obj1)) SWIG_fail;
3526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3527 if (!SWIG_IsOK(res1)) {
3528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetIgnoreGeometry" "', argument " "1"" of type '" "XdmfDiff *""'");
3529 }
3530 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3531 ecode2 = SWIG_AsVal_int(obj1, &val2);
3532 if (!SWIG_IsOK(ecode2)) {
3533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDiff_SetIgnoreGeometry" "', argument " "2"" of type '" "XdmfBoolean""'");
3534 }
3535 arg2 = static_cast< XdmfBoolean >(val2);
3536 result = (XdmfInt32)(arg1)->SetIgnoreGeometry(arg2);
3537 resultobj = SWIG_From_int(static_cast< int >(result));
3538 return resultobj;
3539 fail:
3540 return NULL;
3541 }
3542
3543
_wrap_XdmfDiff_SetIgnoreGeometry__SWIG_1(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3544 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreGeometry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3545 PyObject *resultobj = 0;
3546 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3547 void *argp1 = 0 ;
3548 int res1 = 0 ;
3549 PyObject * obj0 = 0 ;
3550 XdmfInt32 result;
3551
3552 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_SetIgnoreGeometry",&obj0)) SWIG_fail;
3553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3554 if (!SWIG_IsOK(res1)) {
3555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetIgnoreGeometry" "', argument " "1"" of type '" "XdmfDiff *""'");
3556 }
3557 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3558 result = (XdmfInt32)(arg1)->SetIgnoreGeometry();
3559 resultobj = SWIG_From_int(static_cast< int >(result));
3560 return resultobj;
3561 fail:
3562 return NULL;
3563 }
3564
3565
_wrap_XdmfDiff_SetIgnoreGeometry(PyObject * self,PyObject * args)3566 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreGeometry(PyObject *self, PyObject *args) {
3567 int argc;
3568 PyObject *argv[3];
3569 int ii;
3570
3571 if (!PyTuple_Check(args)) SWIG_fail;
3572 argc = (int)PyObject_Length(args);
3573 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
3574 argv[ii] = PyTuple_GET_ITEM(args,ii);
3575 }
3576 if (argc == 1) {
3577 int _v;
3578 void *vptr = 0;
3579 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3580 _v = SWIG_CheckState(res);
3581 if (_v) {
3582 return _wrap_XdmfDiff_SetIgnoreGeometry__SWIG_1(self, args);
3583 }
3584 }
3585 if (argc == 2) {
3586 int _v;
3587 void *vptr = 0;
3588 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3589 _v = SWIG_CheckState(res);
3590 if (_v) {
3591 {
3592 int res = SWIG_AsVal_int(argv[1], NULL);
3593 _v = SWIG_CheckState(res);
3594 }
3595 if (_v) {
3596 return _wrap_XdmfDiff_SetIgnoreGeometry__SWIG_0(self, args);
3597 }
3598 }
3599 }
3600
3601 fail:
3602 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDiff_SetIgnoreGeometry'.\n"
3603 " Possible C/C++ prototypes are:\n"
3604 " SetIgnoreGeometry(XdmfDiff *,XdmfBoolean)\n"
3605 " SetIgnoreGeometry(XdmfDiff *)\n");
3606 return NULL;
3607 }
3608
3609
_wrap_XdmfDiff_GetIgnoreGeometry(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3610 SWIGINTERN PyObject *_wrap_XdmfDiff_GetIgnoreGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3611 PyObject *resultobj = 0;
3612 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3613 void *argp1 = 0 ;
3614 int res1 = 0 ;
3615 PyObject * obj0 = 0 ;
3616 XdmfInt32 result;
3617
3618 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_GetIgnoreGeometry",&obj0)) SWIG_fail;
3619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3620 if (!SWIG_IsOK(res1)) {
3621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetIgnoreGeometry" "', argument " "1"" of type '" "XdmfDiff *""'");
3622 }
3623 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3624 result = (XdmfInt32)(arg1)->GetIgnoreGeometry();
3625 resultobj = SWIG_From_int(static_cast< int >(result));
3626 return resultobj;
3627 fail:
3628 return NULL;
3629 }
3630
3631
_wrap_XdmfDiff_SetIgnoreTopology__SWIG_0(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3632 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreTopology__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3633 PyObject *resultobj = 0;
3634 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3635 XdmfBoolean arg2 ;
3636 void *argp1 = 0 ;
3637 int res1 = 0 ;
3638 int val2 ;
3639 int ecode2 = 0 ;
3640 PyObject * obj0 = 0 ;
3641 PyObject * obj1 = 0 ;
3642 XdmfInt32 result;
3643
3644 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_SetIgnoreTopology",&obj0,&obj1)) SWIG_fail;
3645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3646 if (!SWIG_IsOK(res1)) {
3647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetIgnoreTopology" "', argument " "1"" of type '" "XdmfDiff *""'");
3648 }
3649 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3650 ecode2 = SWIG_AsVal_int(obj1, &val2);
3651 if (!SWIG_IsOK(ecode2)) {
3652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDiff_SetIgnoreTopology" "', argument " "2"" of type '" "XdmfBoolean""'");
3653 }
3654 arg2 = static_cast< XdmfBoolean >(val2);
3655 result = (XdmfInt32)(arg1)->SetIgnoreTopology(arg2);
3656 resultobj = SWIG_From_int(static_cast< int >(result));
3657 return resultobj;
3658 fail:
3659 return NULL;
3660 }
3661
3662
_wrap_XdmfDiff_SetIgnoreTopology__SWIG_1(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3663 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreTopology__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3664 PyObject *resultobj = 0;
3665 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3666 void *argp1 = 0 ;
3667 int res1 = 0 ;
3668 PyObject * obj0 = 0 ;
3669 XdmfInt32 result;
3670
3671 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_SetIgnoreTopology",&obj0)) SWIG_fail;
3672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3673 if (!SWIG_IsOK(res1)) {
3674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetIgnoreTopology" "', argument " "1"" of type '" "XdmfDiff *""'");
3675 }
3676 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3677 result = (XdmfInt32)(arg1)->SetIgnoreTopology();
3678 resultobj = SWIG_From_int(static_cast< int >(result));
3679 return resultobj;
3680 fail:
3681 return NULL;
3682 }
3683
3684
_wrap_XdmfDiff_SetIgnoreTopology(PyObject * self,PyObject * args)3685 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreTopology(PyObject *self, PyObject *args) {
3686 int argc;
3687 PyObject *argv[3];
3688 int ii;
3689
3690 if (!PyTuple_Check(args)) SWIG_fail;
3691 argc = (int)PyObject_Length(args);
3692 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
3693 argv[ii] = PyTuple_GET_ITEM(args,ii);
3694 }
3695 if (argc == 1) {
3696 int _v;
3697 void *vptr = 0;
3698 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3699 _v = SWIG_CheckState(res);
3700 if (_v) {
3701 return _wrap_XdmfDiff_SetIgnoreTopology__SWIG_1(self, args);
3702 }
3703 }
3704 if (argc == 2) {
3705 int _v;
3706 void *vptr = 0;
3707 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3708 _v = SWIG_CheckState(res);
3709 if (_v) {
3710 {
3711 int res = SWIG_AsVal_int(argv[1], NULL);
3712 _v = SWIG_CheckState(res);
3713 }
3714 if (_v) {
3715 return _wrap_XdmfDiff_SetIgnoreTopology__SWIG_0(self, args);
3716 }
3717 }
3718 }
3719
3720 fail:
3721 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDiff_SetIgnoreTopology'.\n"
3722 " Possible C/C++ prototypes are:\n"
3723 " SetIgnoreTopology(XdmfDiff *,XdmfBoolean)\n"
3724 " SetIgnoreTopology(XdmfDiff *)\n");
3725 return NULL;
3726 }
3727
3728
_wrap_XdmfDiff_GetIgnoreTopology(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3729 SWIGINTERN PyObject *_wrap_XdmfDiff_GetIgnoreTopology(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3730 PyObject *resultobj = 0;
3731 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3732 void *argp1 = 0 ;
3733 int res1 = 0 ;
3734 PyObject * obj0 = 0 ;
3735 XdmfInt32 result;
3736
3737 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_GetIgnoreTopology",&obj0)) SWIG_fail;
3738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3739 if (!SWIG_IsOK(res1)) {
3740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetIgnoreTopology" "', argument " "1"" of type '" "XdmfDiff *""'");
3741 }
3742 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3743 result = (XdmfInt32)(arg1)->GetIgnoreTopology();
3744 resultobj = SWIG_From_int(static_cast< int >(result));
3745 return resultobj;
3746 fail:
3747 return NULL;
3748 }
3749
3750
_wrap_XdmfDiff_SetIgnoreAllAttributes__SWIG_0(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3751 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreAllAttributes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3752 PyObject *resultobj = 0;
3753 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3754 XdmfBoolean arg2 ;
3755 void *argp1 = 0 ;
3756 int res1 = 0 ;
3757 int val2 ;
3758 int ecode2 = 0 ;
3759 PyObject * obj0 = 0 ;
3760 PyObject * obj1 = 0 ;
3761 XdmfInt32 result;
3762
3763 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_SetIgnoreAllAttributes",&obj0,&obj1)) SWIG_fail;
3764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3765 if (!SWIG_IsOK(res1)) {
3766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetIgnoreAllAttributes" "', argument " "1"" of type '" "XdmfDiff *""'");
3767 }
3768 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3769 ecode2 = SWIG_AsVal_int(obj1, &val2);
3770 if (!SWIG_IsOK(ecode2)) {
3771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDiff_SetIgnoreAllAttributes" "', argument " "2"" of type '" "XdmfBoolean""'");
3772 }
3773 arg2 = static_cast< XdmfBoolean >(val2);
3774 result = (XdmfInt32)(arg1)->SetIgnoreAllAttributes(arg2);
3775 resultobj = SWIG_From_int(static_cast< int >(result));
3776 return resultobj;
3777 fail:
3778 return NULL;
3779 }
3780
3781
_wrap_XdmfDiff_SetIgnoreAllAttributes__SWIG_1(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3782 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreAllAttributes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3783 PyObject *resultobj = 0;
3784 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3785 void *argp1 = 0 ;
3786 int res1 = 0 ;
3787 PyObject * obj0 = 0 ;
3788 XdmfInt32 result;
3789
3790 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_SetIgnoreAllAttributes",&obj0)) SWIG_fail;
3791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3792 if (!SWIG_IsOK(res1)) {
3793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetIgnoreAllAttributes" "', argument " "1"" of type '" "XdmfDiff *""'");
3794 }
3795 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3796 result = (XdmfInt32)(arg1)->SetIgnoreAllAttributes();
3797 resultobj = SWIG_From_int(static_cast< int >(result));
3798 return resultobj;
3799 fail:
3800 return NULL;
3801 }
3802
3803
_wrap_XdmfDiff_SetIgnoreAllAttributes(PyObject * self,PyObject * args)3804 SWIGINTERN PyObject *_wrap_XdmfDiff_SetIgnoreAllAttributes(PyObject *self, PyObject *args) {
3805 int argc;
3806 PyObject *argv[3];
3807 int ii;
3808
3809 if (!PyTuple_Check(args)) SWIG_fail;
3810 argc = (int)PyObject_Length(args);
3811 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
3812 argv[ii] = PyTuple_GET_ITEM(args,ii);
3813 }
3814 if (argc == 1) {
3815 int _v;
3816 void *vptr = 0;
3817 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3818 _v = SWIG_CheckState(res);
3819 if (_v) {
3820 return _wrap_XdmfDiff_SetIgnoreAllAttributes__SWIG_1(self, args);
3821 }
3822 }
3823 if (argc == 2) {
3824 int _v;
3825 void *vptr = 0;
3826 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3827 _v = SWIG_CheckState(res);
3828 if (_v) {
3829 {
3830 int res = SWIG_AsVal_int(argv[1], NULL);
3831 _v = SWIG_CheckState(res);
3832 }
3833 if (_v) {
3834 return _wrap_XdmfDiff_SetIgnoreAllAttributes__SWIG_0(self, args);
3835 }
3836 }
3837 }
3838
3839 fail:
3840 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDiff_SetIgnoreAllAttributes'.\n"
3841 " Possible C/C++ prototypes are:\n"
3842 " SetIgnoreAllAttributes(XdmfDiff *,XdmfBoolean)\n"
3843 " SetIgnoreAllAttributes(XdmfDiff *)\n");
3844 return NULL;
3845 }
3846
3847
_wrap_XdmfDiff_GetIgnoreAllAttributes(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3848 SWIGINTERN PyObject *_wrap_XdmfDiff_GetIgnoreAllAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3849 PyObject *resultobj = 0;
3850 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3851 void *argp1 = 0 ;
3852 int res1 = 0 ;
3853 PyObject * obj0 = 0 ;
3854 XdmfInt32 result;
3855
3856 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_GetIgnoreAllAttributes",&obj0)) SWIG_fail;
3857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3858 if (!SWIG_IsOK(res1)) {
3859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetIgnoreAllAttributes" "', argument " "1"" of type '" "XdmfDiff *""'");
3860 }
3861 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3862 result = (XdmfInt32)(arg1)->GetIgnoreAllAttributes();
3863 resultobj = SWIG_From_int(static_cast< int >(result));
3864 return resultobj;
3865 fail:
3866 return NULL;
3867 }
3868
3869
_wrap_XdmfDiff_SetDisplayFailuresOnly__SWIG_0(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3870 SWIGINTERN PyObject *_wrap_XdmfDiff_SetDisplayFailuresOnly__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3871 PyObject *resultobj = 0;
3872 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3873 XdmfBoolean arg2 ;
3874 void *argp1 = 0 ;
3875 int res1 = 0 ;
3876 int val2 ;
3877 int ecode2 = 0 ;
3878 PyObject * obj0 = 0 ;
3879 PyObject * obj1 = 0 ;
3880 XdmfInt32 result;
3881
3882 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_SetDisplayFailuresOnly",&obj0,&obj1)) SWIG_fail;
3883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3884 if (!SWIG_IsOK(res1)) {
3885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetDisplayFailuresOnly" "', argument " "1"" of type '" "XdmfDiff *""'");
3886 }
3887 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3888 ecode2 = SWIG_AsVal_int(obj1, &val2);
3889 if (!SWIG_IsOK(ecode2)) {
3890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDiff_SetDisplayFailuresOnly" "', argument " "2"" of type '" "XdmfBoolean""'");
3891 }
3892 arg2 = static_cast< XdmfBoolean >(val2);
3893 result = (XdmfInt32)(arg1)->SetDisplayFailuresOnly(arg2);
3894 resultobj = SWIG_From_int(static_cast< int >(result));
3895 return resultobj;
3896 fail:
3897 return NULL;
3898 }
3899
3900
_wrap_XdmfDiff_SetDisplayFailuresOnly__SWIG_1(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3901 SWIGINTERN PyObject *_wrap_XdmfDiff_SetDisplayFailuresOnly__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3902 PyObject *resultobj = 0;
3903 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3904 void *argp1 = 0 ;
3905 int res1 = 0 ;
3906 PyObject * obj0 = 0 ;
3907 XdmfInt32 result;
3908
3909 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_SetDisplayFailuresOnly",&obj0)) SWIG_fail;
3910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3911 if (!SWIG_IsOK(res1)) {
3912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetDisplayFailuresOnly" "', argument " "1"" of type '" "XdmfDiff *""'");
3913 }
3914 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3915 result = (XdmfInt32)(arg1)->SetDisplayFailuresOnly();
3916 resultobj = SWIG_From_int(static_cast< int >(result));
3917 return resultobj;
3918 fail:
3919 return NULL;
3920 }
3921
3922
_wrap_XdmfDiff_SetDisplayFailuresOnly(PyObject * self,PyObject * args)3923 SWIGINTERN PyObject *_wrap_XdmfDiff_SetDisplayFailuresOnly(PyObject *self, PyObject *args) {
3924 int argc;
3925 PyObject *argv[3];
3926 int ii;
3927
3928 if (!PyTuple_Check(args)) SWIG_fail;
3929 argc = (int)PyObject_Length(args);
3930 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
3931 argv[ii] = PyTuple_GET_ITEM(args,ii);
3932 }
3933 if (argc == 1) {
3934 int _v;
3935 void *vptr = 0;
3936 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3937 _v = SWIG_CheckState(res);
3938 if (_v) {
3939 return _wrap_XdmfDiff_SetDisplayFailuresOnly__SWIG_1(self, args);
3940 }
3941 }
3942 if (argc == 2) {
3943 int _v;
3944 void *vptr = 0;
3945 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
3946 _v = SWIG_CheckState(res);
3947 if (_v) {
3948 {
3949 int res = SWIG_AsVal_int(argv[1], NULL);
3950 _v = SWIG_CheckState(res);
3951 }
3952 if (_v) {
3953 return _wrap_XdmfDiff_SetDisplayFailuresOnly__SWIG_0(self, args);
3954 }
3955 }
3956 }
3957
3958 fail:
3959 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDiff_SetDisplayFailuresOnly'.\n"
3960 " Possible C/C++ prototypes are:\n"
3961 " SetDisplayFailuresOnly(XdmfDiff *,XdmfBoolean)\n"
3962 " SetDisplayFailuresOnly(XdmfDiff *)\n");
3963 return NULL;
3964 }
3965
3966
_wrap_XdmfDiff_GetDisplayFailuresOnly(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3967 SWIGINTERN PyObject *_wrap_XdmfDiff_GetDisplayFailuresOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3968 PyObject *resultobj = 0;
3969 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3970 void *argp1 = 0 ;
3971 int res1 = 0 ;
3972 PyObject * obj0 = 0 ;
3973 XdmfInt32 result;
3974
3975 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_GetDisplayFailuresOnly",&obj0)) SWIG_fail;
3976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
3977 if (!SWIG_IsOK(res1)) {
3978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetDisplayFailuresOnly" "', argument " "1"" of type '" "XdmfDiff *""'");
3979 }
3980 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
3981 result = (XdmfInt32)(arg1)->GetDisplayFailuresOnly();
3982 resultobj = SWIG_From_int(static_cast< int >(result));
3983 return resultobj;
3984 fail:
3985 return NULL;
3986 }
3987
3988
_wrap_XdmfDiff_SetVerboseOutput__SWIG_0(PyObject * SWIGUNUSEDPARM (self),PyObject * args)3989 SWIGINTERN PyObject *_wrap_XdmfDiff_SetVerboseOutput__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3990 PyObject *resultobj = 0;
3991 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
3992 XdmfBoolean arg2 ;
3993 void *argp1 = 0 ;
3994 int res1 = 0 ;
3995 int val2 ;
3996 int ecode2 = 0 ;
3997 PyObject * obj0 = 0 ;
3998 PyObject * obj1 = 0 ;
3999 XdmfInt32 result;
4000
4001 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_SetVerboseOutput",&obj0,&obj1)) SWIG_fail;
4002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4003 if (!SWIG_IsOK(res1)) {
4004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetVerboseOutput" "', argument " "1"" of type '" "XdmfDiff *""'");
4005 }
4006 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4007 ecode2 = SWIG_AsVal_int(obj1, &val2);
4008 if (!SWIG_IsOK(ecode2)) {
4009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDiff_SetVerboseOutput" "', argument " "2"" of type '" "XdmfBoolean""'");
4010 }
4011 arg2 = static_cast< XdmfBoolean >(val2);
4012 result = (XdmfInt32)(arg1)->SetVerboseOutput(arg2);
4013 resultobj = SWIG_From_int(static_cast< int >(result));
4014 return resultobj;
4015 fail:
4016 return NULL;
4017 }
4018
4019
_wrap_XdmfDiff_SetVerboseOutput__SWIG_1(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4020 SWIGINTERN PyObject *_wrap_XdmfDiff_SetVerboseOutput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4021 PyObject *resultobj = 0;
4022 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4023 void *argp1 = 0 ;
4024 int res1 = 0 ;
4025 PyObject * obj0 = 0 ;
4026 XdmfInt32 result;
4027
4028 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_SetVerboseOutput",&obj0)) SWIG_fail;
4029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4030 if (!SWIG_IsOK(res1)) {
4031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetVerboseOutput" "', argument " "1"" of type '" "XdmfDiff *""'");
4032 }
4033 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4034 result = (XdmfInt32)(arg1)->SetVerboseOutput();
4035 resultobj = SWIG_From_int(static_cast< int >(result));
4036 return resultobj;
4037 fail:
4038 return NULL;
4039 }
4040
4041
_wrap_XdmfDiff_SetVerboseOutput(PyObject * self,PyObject * args)4042 SWIGINTERN PyObject *_wrap_XdmfDiff_SetVerboseOutput(PyObject *self, PyObject *args) {
4043 int argc;
4044 PyObject *argv[3];
4045 int ii;
4046
4047 if (!PyTuple_Check(args)) SWIG_fail;
4048 argc = (int)PyObject_Length(args);
4049 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4050 argv[ii] = PyTuple_GET_ITEM(args,ii);
4051 }
4052 if (argc == 1) {
4053 int _v;
4054 void *vptr = 0;
4055 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
4056 _v = SWIG_CheckState(res);
4057 if (_v) {
4058 return _wrap_XdmfDiff_SetVerboseOutput__SWIG_1(self, args);
4059 }
4060 }
4061 if (argc == 2) {
4062 int _v;
4063 void *vptr = 0;
4064 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
4065 _v = SWIG_CheckState(res);
4066 if (_v) {
4067 {
4068 int res = SWIG_AsVal_int(argv[1], NULL);
4069 _v = SWIG_CheckState(res);
4070 }
4071 if (_v) {
4072 return _wrap_XdmfDiff_SetVerboseOutput__SWIG_0(self, args);
4073 }
4074 }
4075 }
4076
4077 fail:
4078 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDiff_SetVerboseOutput'.\n"
4079 " Possible C/C++ prototypes are:\n"
4080 " SetVerboseOutput(XdmfDiff *,XdmfBoolean)\n"
4081 " SetVerboseOutput(XdmfDiff *)\n");
4082 return NULL;
4083 }
4084
4085
_wrap_XdmfDiff_GetVerboseOutput(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4086 SWIGINTERN PyObject *_wrap_XdmfDiff_GetVerboseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4087 PyObject *resultobj = 0;
4088 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4089 void *argp1 = 0 ;
4090 int res1 = 0 ;
4091 PyObject * obj0 = 0 ;
4092 XdmfInt32 result;
4093
4094 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_GetVerboseOutput",&obj0)) SWIG_fail;
4095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4096 if (!SWIG_IsOK(res1)) {
4097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetVerboseOutput" "', argument " "1"" of type '" "XdmfDiff *""'");
4098 }
4099 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4100 result = (XdmfInt32)(arg1)->GetVerboseOutput();
4101 resultobj = SWIG_From_int(static_cast< int >(result));
4102 return resultobj;
4103 fail:
4104 return NULL;
4105 }
4106
4107
_wrap_XdmfDiff_SetCreateDiffFile__SWIG_0(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4108 SWIGINTERN PyObject *_wrap_XdmfDiff_SetCreateDiffFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4109 PyObject *resultobj = 0;
4110 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4111 XdmfBoolean arg2 ;
4112 void *argp1 = 0 ;
4113 int res1 = 0 ;
4114 int val2 ;
4115 int ecode2 = 0 ;
4116 PyObject * obj0 = 0 ;
4117 PyObject * obj1 = 0 ;
4118 XdmfInt32 result;
4119
4120 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_SetCreateDiffFile",&obj0,&obj1)) SWIG_fail;
4121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4122 if (!SWIG_IsOK(res1)) {
4123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetCreateDiffFile" "', argument " "1"" of type '" "XdmfDiff *""'");
4124 }
4125 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4126 ecode2 = SWIG_AsVal_int(obj1, &val2);
4127 if (!SWIG_IsOK(ecode2)) {
4128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDiff_SetCreateDiffFile" "', argument " "2"" of type '" "XdmfBoolean""'");
4129 }
4130 arg2 = static_cast< XdmfBoolean >(val2);
4131 result = (XdmfInt32)(arg1)->SetCreateDiffFile(arg2);
4132 resultobj = SWIG_From_int(static_cast< int >(result));
4133 return resultobj;
4134 fail:
4135 return NULL;
4136 }
4137
4138
_wrap_XdmfDiff_SetCreateDiffFile__SWIG_1(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4139 SWIGINTERN PyObject *_wrap_XdmfDiff_SetCreateDiffFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4140 PyObject *resultobj = 0;
4141 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4142 void *argp1 = 0 ;
4143 int res1 = 0 ;
4144 PyObject * obj0 = 0 ;
4145 XdmfInt32 result;
4146
4147 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_SetCreateDiffFile",&obj0)) SWIG_fail;
4148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4149 if (!SWIG_IsOK(res1)) {
4150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetCreateDiffFile" "', argument " "1"" of type '" "XdmfDiff *""'");
4151 }
4152 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4153 result = (XdmfInt32)(arg1)->SetCreateDiffFile();
4154 resultobj = SWIG_From_int(static_cast< int >(result));
4155 return resultobj;
4156 fail:
4157 return NULL;
4158 }
4159
4160
_wrap_XdmfDiff_SetCreateDiffFile(PyObject * self,PyObject * args)4161 SWIGINTERN PyObject *_wrap_XdmfDiff_SetCreateDiffFile(PyObject *self, PyObject *args) {
4162 int argc;
4163 PyObject *argv[3];
4164 int ii;
4165
4166 if (!PyTuple_Check(args)) SWIG_fail;
4167 argc = (int)PyObject_Length(args);
4168 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4169 argv[ii] = PyTuple_GET_ITEM(args,ii);
4170 }
4171 if (argc == 1) {
4172 int _v;
4173 void *vptr = 0;
4174 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
4175 _v = SWIG_CheckState(res);
4176 if (_v) {
4177 return _wrap_XdmfDiff_SetCreateDiffFile__SWIG_1(self, args);
4178 }
4179 }
4180 if (argc == 2) {
4181 int _v;
4182 void *vptr = 0;
4183 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDiff, 0);
4184 _v = SWIG_CheckState(res);
4185 if (_v) {
4186 {
4187 int res = SWIG_AsVal_int(argv[1], NULL);
4188 _v = SWIG_CheckState(res);
4189 }
4190 if (_v) {
4191 return _wrap_XdmfDiff_SetCreateDiffFile__SWIG_0(self, args);
4192 }
4193 }
4194 }
4195
4196 fail:
4197 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDiff_SetCreateDiffFile'.\n"
4198 " Possible C/C++ prototypes are:\n"
4199 " SetCreateDiffFile(XdmfDiff *,XdmfBoolean)\n"
4200 " SetCreateDiffFile(XdmfDiff *)\n");
4201 return NULL;
4202 }
4203
4204
_wrap_XdmfDiff_GetCreateDiffFile(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4205 SWIGINTERN PyObject *_wrap_XdmfDiff_GetCreateDiffFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4206 PyObject *resultobj = 0;
4207 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4208 void *argp1 = 0 ;
4209 int res1 = 0 ;
4210 PyObject * obj0 = 0 ;
4211 XdmfInt32 result;
4212
4213 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_GetCreateDiffFile",&obj0)) SWIG_fail;
4214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4215 if (!SWIG_IsOK(res1)) {
4216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetCreateDiffFile" "', argument " "1"" of type '" "XdmfDiff *""'");
4217 }
4218 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4219 result = (XdmfInt32)(arg1)->GetCreateDiffFile();
4220 resultobj = SWIG_From_int(static_cast< int >(result));
4221 return resultobj;
4222 fail:
4223 return NULL;
4224 }
4225
4226
_wrap_XdmfDiff_SetDiffFileName(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4227 SWIGINTERN PyObject *_wrap_XdmfDiff_SetDiffFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4228 PyObject *resultobj = 0;
4229 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4230 XdmfString arg2 = (XdmfString) 0 ;
4231 void *argp1 = 0 ;
4232 int res1 = 0 ;
4233 int res2 ;
4234 char *buf2 = 0 ;
4235 int alloc2 = 0 ;
4236 PyObject * obj0 = 0 ;
4237 PyObject * obj1 = 0 ;
4238 XdmfInt32 result;
4239
4240 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_SetDiffFileName",&obj0,&obj1)) SWIG_fail;
4241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4242 if (!SWIG_IsOK(res1)) {
4243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetDiffFileName" "', argument " "1"" of type '" "XdmfDiff *""'");
4244 }
4245 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4246 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4247 if (!SWIG_IsOK(res2)) {
4248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDiff_SetDiffFileName" "', argument " "2"" of type '" "XdmfString""'");
4249 }
4250 arg2 = reinterpret_cast< XdmfString >(buf2);
4251 result = (XdmfInt32)(arg1)->SetDiffFileName(arg2);
4252 resultobj = SWIG_From_int(static_cast< int >(result));
4253 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4254 return resultobj;
4255 fail:
4256 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4257 return NULL;
4258 }
4259
4260
_wrap_XdmfDiff_GetDiffFileName(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4261 SWIGINTERN PyObject *_wrap_XdmfDiff_GetDiffFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4262 PyObject *resultobj = 0;
4263 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4264 void *argp1 = 0 ;
4265 int res1 = 0 ;
4266 PyObject * obj0 = 0 ;
4267 XdmfString result;
4268
4269 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_GetDiffFileName",&obj0)) SWIG_fail;
4270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4271 if (!SWIG_IsOK(res1)) {
4272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetDiffFileName" "', argument " "1"" of type '" "XdmfDiff *""'");
4273 }
4274 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4275 result = (XdmfString)(arg1)->GetDiffFileName();
4276 resultobj = SWIG_FromCharPtr((const char *)result);
4277 return resultobj;
4278 fail:
4279 return NULL;
4280 }
4281
4282
_wrap_XdmfDiff_SetRelativeError(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4283 SWIGINTERN PyObject *_wrap_XdmfDiff_SetRelativeError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4284 PyObject *resultobj = 0;
4285 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4286 XdmfFloat64 arg2 ;
4287 void *argp1 = 0 ;
4288 int res1 = 0 ;
4289 double val2 ;
4290 int ecode2 = 0 ;
4291 PyObject * obj0 = 0 ;
4292 PyObject * obj1 = 0 ;
4293 XdmfInt32 result;
4294
4295 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_SetRelativeError",&obj0,&obj1)) SWIG_fail;
4296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4297 if (!SWIG_IsOK(res1)) {
4298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetRelativeError" "', argument " "1"" of type '" "XdmfDiff *""'");
4299 }
4300 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4301 ecode2 = SWIG_AsVal_double(obj1, &val2);
4302 if (!SWIG_IsOK(ecode2)) {
4303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDiff_SetRelativeError" "', argument " "2"" of type '" "XdmfFloat64""'");
4304 }
4305 arg2 = static_cast< XdmfFloat64 >(val2);
4306 result = (XdmfInt32)(arg1)->SetRelativeError(arg2);
4307 resultobj = SWIG_From_int(static_cast< int >(result));
4308 return resultobj;
4309 fail:
4310 return NULL;
4311 }
4312
4313
_wrap_XdmfDiff_GetRelativeError(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4314 SWIGINTERN PyObject *_wrap_XdmfDiff_GetRelativeError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4315 PyObject *resultobj = 0;
4316 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4317 void *argp1 = 0 ;
4318 int res1 = 0 ;
4319 PyObject * obj0 = 0 ;
4320 XdmfFloat64 result;
4321
4322 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_GetRelativeError",&obj0)) SWIG_fail;
4323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4324 if (!SWIG_IsOK(res1)) {
4325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetRelativeError" "', argument " "1"" of type '" "XdmfDiff *""'");
4326 }
4327 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4328 result = (XdmfFloat64)(arg1)->GetRelativeError();
4329 resultobj = SWIG_From_double(static_cast< double >(result));
4330 return resultobj;
4331 fail:
4332 return NULL;
4333 }
4334
4335
_wrap_XdmfDiff_SetAbsoluteError(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4336 SWIGINTERN PyObject *_wrap_XdmfDiff_SetAbsoluteError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4337 PyObject *resultobj = 0;
4338 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4339 XdmfFloat64 arg2 ;
4340 void *argp1 = 0 ;
4341 int res1 = 0 ;
4342 double val2 ;
4343 int ecode2 = 0 ;
4344 PyObject * obj0 = 0 ;
4345 PyObject * obj1 = 0 ;
4346 XdmfInt32 result;
4347
4348 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_SetAbsoluteError",&obj0,&obj1)) SWIG_fail;
4349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4350 if (!SWIG_IsOK(res1)) {
4351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_SetAbsoluteError" "', argument " "1"" of type '" "XdmfDiff *""'");
4352 }
4353 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4354 ecode2 = SWIG_AsVal_double(obj1, &val2);
4355 if (!SWIG_IsOK(ecode2)) {
4356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDiff_SetAbsoluteError" "', argument " "2"" of type '" "XdmfFloat64""'");
4357 }
4358 arg2 = static_cast< XdmfFloat64 >(val2);
4359 result = (XdmfInt32)(arg1)->SetAbsoluteError(arg2);
4360 resultobj = SWIG_From_int(static_cast< int >(result));
4361 return resultobj;
4362 fail:
4363 return NULL;
4364 }
4365
4366
_wrap_XdmfDiff_GetAbsoluteError(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4367 SWIGINTERN PyObject *_wrap_XdmfDiff_GetAbsoluteError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4368 PyObject *resultobj = 0;
4369 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4370 void *argp1 = 0 ;
4371 int res1 = 0 ;
4372 PyObject * obj0 = 0 ;
4373 XdmfFloat64 result;
4374
4375 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_GetAbsoluteError",&obj0)) SWIG_fail;
4376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4377 if (!SWIG_IsOK(res1)) {
4378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_GetAbsoluteError" "', argument " "1"" of type '" "XdmfDiff *""'");
4379 }
4380 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4381 result = (XdmfFloat64)(arg1)->GetAbsoluteError();
4382 resultobj = SWIG_From_double(static_cast< double >(result));
4383 return resultobj;
4384 fail:
4385 return NULL;
4386 }
4387
4388
_wrap_XdmfDiff_IncludeGrid(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4389 SWIGINTERN PyObject *_wrap_XdmfDiff_IncludeGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4390 PyObject *resultobj = 0;
4391 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4392 XdmfString arg2 = (XdmfString) 0 ;
4393 void *argp1 = 0 ;
4394 int res1 = 0 ;
4395 int res2 ;
4396 char *buf2 = 0 ;
4397 int alloc2 = 0 ;
4398 PyObject * obj0 = 0 ;
4399 PyObject * obj1 = 0 ;
4400 XdmfInt32 result;
4401
4402 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_IncludeGrid",&obj0,&obj1)) SWIG_fail;
4403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4404 if (!SWIG_IsOK(res1)) {
4405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_IncludeGrid" "', argument " "1"" of type '" "XdmfDiff *""'");
4406 }
4407 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4408 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4409 if (!SWIG_IsOK(res2)) {
4410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDiff_IncludeGrid" "', argument " "2"" of type '" "XdmfString""'");
4411 }
4412 arg2 = reinterpret_cast< XdmfString >(buf2);
4413 result = (XdmfInt32)(arg1)->IncludeGrid(arg2);
4414 resultobj = SWIG_From_int(static_cast< int >(result));
4415 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4416 return resultobj;
4417 fail:
4418 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4419 return NULL;
4420 }
4421
4422
_wrap_XdmfDiff_IgnoreGrid(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4423 SWIGINTERN PyObject *_wrap_XdmfDiff_IgnoreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4424 PyObject *resultobj = 0;
4425 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4426 XdmfString arg2 = (XdmfString) 0 ;
4427 void *argp1 = 0 ;
4428 int res1 = 0 ;
4429 int res2 ;
4430 char *buf2 = 0 ;
4431 int alloc2 = 0 ;
4432 PyObject * obj0 = 0 ;
4433 PyObject * obj1 = 0 ;
4434 XdmfInt32 result;
4435
4436 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_IgnoreGrid",&obj0,&obj1)) SWIG_fail;
4437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4438 if (!SWIG_IsOK(res1)) {
4439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_IgnoreGrid" "', argument " "1"" of type '" "XdmfDiff *""'");
4440 }
4441 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4442 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4443 if (!SWIG_IsOK(res2)) {
4444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDiff_IgnoreGrid" "', argument " "2"" of type '" "XdmfString""'");
4445 }
4446 arg2 = reinterpret_cast< XdmfString >(buf2);
4447 result = (XdmfInt32)(arg1)->IgnoreGrid(arg2);
4448 resultobj = SWIG_From_int(static_cast< int >(result));
4449 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4450 return resultobj;
4451 fail:
4452 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4453 return NULL;
4454 }
4455
4456
_wrap_XdmfDiff_IncludeAttribute(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4457 SWIGINTERN PyObject *_wrap_XdmfDiff_IncludeAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4458 PyObject *resultobj = 0;
4459 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4460 XdmfString arg2 = (XdmfString) 0 ;
4461 void *argp1 = 0 ;
4462 int res1 = 0 ;
4463 int res2 ;
4464 char *buf2 = 0 ;
4465 int alloc2 = 0 ;
4466 PyObject * obj0 = 0 ;
4467 PyObject * obj1 = 0 ;
4468 XdmfInt32 result;
4469
4470 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_IncludeAttribute",&obj0,&obj1)) SWIG_fail;
4471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4472 if (!SWIG_IsOK(res1)) {
4473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_IncludeAttribute" "', argument " "1"" of type '" "XdmfDiff *""'");
4474 }
4475 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4476 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4477 if (!SWIG_IsOK(res2)) {
4478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDiff_IncludeAttribute" "', argument " "2"" of type '" "XdmfString""'");
4479 }
4480 arg2 = reinterpret_cast< XdmfString >(buf2);
4481 result = (XdmfInt32)(arg1)->IncludeAttribute(arg2);
4482 resultobj = SWIG_From_int(static_cast< int >(result));
4483 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4484 return resultobj;
4485 fail:
4486 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4487 return NULL;
4488 }
4489
4490
_wrap_XdmfDiff_IgnoreAttribute(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4491 SWIGINTERN PyObject *_wrap_XdmfDiff_IgnoreAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4494 XdmfString arg2 = (XdmfString) 0 ;
4495 void *argp1 = 0 ;
4496 int res1 = 0 ;
4497 int res2 ;
4498 char *buf2 = 0 ;
4499 int alloc2 = 0 ;
4500 PyObject * obj0 = 0 ;
4501 PyObject * obj1 = 0 ;
4502 XdmfInt32 result;
4503
4504 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_IgnoreAttribute",&obj0,&obj1)) SWIG_fail;
4505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4506 if (!SWIG_IsOK(res1)) {
4507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_IgnoreAttribute" "', argument " "1"" of type '" "XdmfDiff *""'");
4508 }
4509 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4510 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4511 if (!SWIG_IsOK(res2)) {
4512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDiff_IgnoreAttribute" "', argument " "2"" of type '" "XdmfString""'");
4513 }
4514 arg2 = reinterpret_cast< XdmfString >(buf2);
4515 result = (XdmfInt32)(arg1)->IgnoreAttribute(arg2);
4516 resultobj = SWIG_From_int(static_cast< int >(result));
4517 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4518 return resultobj;
4519 fail:
4520 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4521 return NULL;
4522 }
4523
4524
_wrap_XdmfDiff_ParseSettingsFile(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4525 SWIGINTERN PyObject *_wrap_XdmfDiff_ParseSettingsFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4526 PyObject *resultobj = 0;
4527 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4528 XdmfConstString arg2 = (XdmfConstString) 0 ;
4529 void *argp1 = 0 ;
4530 int res1 = 0 ;
4531 int res2 ;
4532 char *buf2 = 0 ;
4533 int alloc2 = 0 ;
4534 PyObject * obj0 = 0 ;
4535 PyObject * obj1 = 0 ;
4536 XdmfInt32 result;
4537
4538 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDiff_ParseSettingsFile",&obj0,&obj1)) SWIG_fail;
4539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4540 if (!SWIG_IsOK(res1)) {
4541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_ParseSettingsFile" "', argument " "1"" of type '" "XdmfDiff *""'");
4542 }
4543 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4544 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4545 if (!SWIG_IsOK(res2)) {
4546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDiff_ParseSettingsFile" "', argument " "2"" of type '" "XdmfConstString""'");
4547 }
4548 arg2 = reinterpret_cast< XdmfConstString >(buf2);
4549 result = (XdmfInt32)(arg1)->ParseSettingsFile(arg2);
4550 resultobj = SWIG_From_int(static_cast< int >(result));
4551 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4552 return resultobj;
4553 fail:
4554 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4555 return NULL;
4556 }
4557
4558
_wrap_XdmfDiff_AreEquivalent(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4559 SWIGINTERN PyObject *_wrap_XdmfDiff_AreEquivalent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4560 PyObject *resultobj = 0;
4561 XdmfDiff *arg1 = (XdmfDiff *) 0 ;
4562 void *argp1 = 0 ;
4563 int res1 = 0 ;
4564 PyObject * obj0 = 0 ;
4565 XdmfBoolean result;
4566
4567 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDiff_AreEquivalent",&obj0)) SWIG_fail;
4568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDiff, 0 | 0 );
4569 if (!SWIG_IsOK(res1)) {
4570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDiff_AreEquivalent" "', argument " "1"" of type '" "XdmfDiff *""'");
4571 }
4572 arg1 = reinterpret_cast< XdmfDiff * >(argp1);
4573 result = (XdmfBoolean)(arg1)->AreEquivalent();
4574 resultobj = SWIG_From_int(static_cast< int >(result));
4575 return resultobj;
4576 fail:
4577 return NULL;
4578 }
4579
4580
XdmfDiff_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4581 SWIGINTERN PyObject *XdmfDiff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4582 PyObject *obj;
4583 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4584 SWIG_TypeNewClientData(SWIGTYPE_p_XdmfDiff, SWIG_NewClientData(obj));
4585 return SWIG_Py_Void();
4586 }
4587
_wrap_new_XdmfDataTransform(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4588 SWIGINTERN PyObject *_wrap_new_XdmfDataTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4589 PyObject *resultobj = 0;
4590 XdmfDataTransform *result = 0 ;
4591
4592 if (!PyArg_ParseTuple(args,(char *)":new_XdmfDataTransform")) SWIG_fail;
4593 result = (XdmfDataTransform *)new XdmfDataTransform();
4594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfDataTransform, SWIG_POINTER_NEW | 0 );
4595 return resultobj;
4596 fail:
4597 return NULL;
4598 }
4599
4600
_wrap_delete_XdmfDataTransform(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4601 SWIGINTERN PyObject *_wrap_delete_XdmfDataTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4602 PyObject *resultobj = 0;
4603 XdmfDataTransform *arg1 = (XdmfDataTransform *) 0 ;
4604 void *argp1 = 0 ;
4605 int res1 = 0 ;
4606 PyObject * obj0 = 0 ;
4607
4608 if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfDataTransform",&obj0)) SWIG_fail;
4609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDataTransform, SWIG_POINTER_DISOWN | 0 );
4610 if (!SWIG_IsOK(res1)) {
4611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfDataTransform" "', argument " "1"" of type '" "XdmfDataTransform *""'");
4612 }
4613 arg1 = reinterpret_cast< XdmfDataTransform * >(argp1);
4614 delete arg1;
4615 resultobj = SWIG_Py_Void();
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
_wrap_XdmfDataTransform_GetClassName(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4622 SWIGINTERN PyObject *_wrap_XdmfDataTransform_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4623 PyObject *resultobj = 0;
4624 XdmfDataTransform *arg1 = (XdmfDataTransform *) 0 ;
4625 void *argp1 = 0 ;
4626 int res1 = 0 ;
4627 PyObject * obj0 = 0 ;
4628 XdmfConstString result;
4629
4630 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataTransform_GetClassName",&obj0)) SWIG_fail;
4631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDataTransform, 0 | 0 );
4632 if (!SWIG_IsOK(res1)) {
4633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataTransform_GetClassName" "', argument " "1"" of type '" "XdmfDataTransform *""'");
4634 }
4635 arg1 = reinterpret_cast< XdmfDataTransform * >(argp1);
4636 result = (XdmfConstString)(arg1)->GetClassName();
4637 resultobj = SWIG_FromCharPtr((const char *)result);
4638 return resultobj;
4639 fail:
4640 return NULL;
4641 }
4642
4643
_wrap_XdmfDataTransform_UpdateInformation(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4644 SWIGINTERN PyObject *_wrap_XdmfDataTransform_UpdateInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4645 PyObject *resultobj = 0;
4646 XdmfDataTransform *arg1 = (XdmfDataTransform *) 0 ;
4647 void *argp1 = 0 ;
4648 int res1 = 0 ;
4649 PyObject * obj0 = 0 ;
4650 XdmfInt32 result;
4651
4652 if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataTransform_UpdateInformation",&obj0)) SWIG_fail;
4653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDataTransform, 0 | 0 );
4654 if (!SWIG_IsOK(res1)) {
4655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataTransform_UpdateInformation" "', argument " "1"" of type '" "XdmfDataTransform *""'");
4656 }
4657 arg1 = reinterpret_cast< XdmfDataTransform * >(argp1);
4658 result = (XdmfInt32)(arg1)->UpdateInformation();
4659 resultobj = SWIG_From_int(static_cast< int >(result));
4660 return resultobj;
4661 fail:
4662 return NULL;
4663 }
4664
4665
XdmfDataTransform_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4666 SWIGINTERN PyObject *XdmfDataTransform_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4667 PyObject *obj;
4668 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4669 SWIG_TypeNewClientData(SWIGTYPE_p_XdmfDataTransform, SWIG_NewClientData(obj));
4670 return SWIG_Py_Void();
4671 }
4672
_wrap_new_XdmfValuesBinary(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4673 SWIGINTERN PyObject *_wrap_new_XdmfValuesBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4674 PyObject *resultobj = 0;
4675 XdmfValuesBinary *result = 0 ;
4676
4677 if (!PyArg_ParseTuple(args,(char *)":new_XdmfValuesBinary")) SWIG_fail;
4678 result = (XdmfValuesBinary *)new XdmfValuesBinary();
4679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfValuesBinary, SWIG_POINTER_NEW | 0 );
4680 return resultobj;
4681 fail:
4682 return NULL;
4683 }
4684
4685
_wrap_delete_XdmfValuesBinary(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4686 SWIGINTERN PyObject *_wrap_delete_XdmfValuesBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4687 PyObject *resultobj = 0;
4688 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
4689 void *argp1 = 0 ;
4690 int res1 = 0 ;
4691 PyObject * obj0 = 0 ;
4692
4693 if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfValuesBinary",&obj0)) SWIG_fail;
4694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, SWIG_POINTER_DISOWN | 0 );
4695 if (!SWIG_IsOK(res1)) {
4696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfValuesBinary" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
4697 }
4698 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
4699 delete arg1;
4700 resultobj = SWIG_Py_Void();
4701 return resultobj;
4702 fail:
4703 return NULL;
4704 }
4705
4706
_wrap_XdmfValuesBinary_GetClassName(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4707 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4708 PyObject *resultobj = 0;
4709 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
4710 void *argp1 = 0 ;
4711 int res1 = 0 ;
4712 PyObject * obj0 = 0 ;
4713 XdmfConstString result;
4714
4715 if (!PyArg_ParseTuple(args,(char *)"O:XdmfValuesBinary_GetClassName",&obj0)) SWIG_fail;
4716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, 0 | 0 );
4717 if (!SWIG_IsOK(res1)) {
4718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfValuesBinary_GetClassName" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
4719 }
4720 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
4721 result = (XdmfConstString)(arg1)->GetClassName();
4722 resultobj = SWIG_FromCharPtr((const char *)result);
4723 return resultobj;
4724 fail:
4725 return NULL;
4726 }
4727
4728
_wrap_XdmfValuesBinary_Read__SWIG_0(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4729 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4730 PyObject *resultobj = 0;
4731 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
4732 XdmfArray *arg2 = (XdmfArray *) 0 ;
4733 void *argp1 = 0 ;
4734 int res1 = 0 ;
4735 void *argp2 = 0 ;
4736 int res2 = 0 ;
4737 PyObject * obj0 = 0 ;
4738 PyObject * obj1 = 0 ;
4739 XdmfArray *result = 0 ;
4740
4741 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfValuesBinary_Read",&obj0,&obj1)) SWIG_fail;
4742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, 0 | 0 );
4743 if (!SWIG_IsOK(res1)) {
4744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfValuesBinary_Read" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
4745 }
4746 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
4747 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfArray, 0 | 0 );
4748 if (!SWIG_IsOK(res2)) {
4749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfValuesBinary_Read" "', argument " "2"" of type '" "XdmfArray *""'");
4750 }
4751 arg2 = reinterpret_cast< XdmfArray * >(argp2);
4752 result = (XdmfArray *)(arg1)->Read(arg2);
4753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfArray, 0 | 0 );
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
_wrap_XdmfValuesBinary_Read__SWIG_1(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4760 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4761 PyObject *resultobj = 0;
4762 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
4763 void *argp1 = 0 ;
4764 int res1 = 0 ;
4765 PyObject * obj0 = 0 ;
4766 XdmfArray *result = 0 ;
4767
4768 if (!PyArg_ParseTuple(args,(char *)"O:XdmfValuesBinary_Read",&obj0)) SWIG_fail;
4769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, 0 | 0 );
4770 if (!SWIG_IsOK(res1)) {
4771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfValuesBinary_Read" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
4772 }
4773 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
4774 result = (XdmfArray *)(arg1)->Read();
4775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfArray, 0 | 0 );
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
_wrap_XdmfValuesBinary_Read(PyObject * self,PyObject * args)4782 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_Read(PyObject *self, PyObject *args) {
4783 int argc;
4784 PyObject *argv[3];
4785 int ii;
4786
4787 if (!PyTuple_Check(args)) SWIG_fail;
4788 argc = (int)PyObject_Length(args);
4789 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4790 argv[ii] = PyTuple_GET_ITEM(args,ii);
4791 }
4792 if (argc == 1) {
4793 int _v;
4794 void *vptr = 0;
4795 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfValuesBinary, 0);
4796 _v = SWIG_CheckState(res);
4797 if (_v) {
4798 return _wrap_XdmfValuesBinary_Read__SWIG_1(self, args);
4799 }
4800 }
4801 if (argc == 2) {
4802 int _v;
4803 void *vptr = 0;
4804 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfValuesBinary, 0);
4805 _v = SWIG_CheckState(res);
4806 if (_v) {
4807 void *vptr = 0;
4808 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfArray, 0);
4809 _v = SWIG_CheckState(res);
4810 if (_v) {
4811 return _wrap_XdmfValuesBinary_Read__SWIG_0(self, args);
4812 }
4813 }
4814 }
4815
4816 fail:
4817 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfValuesBinary_Read'.\n"
4818 " Possible C/C++ prototypes are:\n"
4819 " Read(XdmfValuesBinary *,XdmfArray *)\n"
4820 " Read(XdmfValuesBinary *)\n");
4821 return NULL;
4822 }
4823
4824
_wrap_XdmfValuesBinary_Write__SWIG_0(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4825 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4826 PyObject *resultobj = 0;
4827 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
4828 XdmfArray *arg2 = (XdmfArray *) 0 ;
4829 XdmfConstString arg3 = (XdmfConstString) 0 ;
4830 void *argp1 = 0 ;
4831 int res1 = 0 ;
4832 void *argp2 = 0 ;
4833 int res2 = 0 ;
4834 int res3 ;
4835 char *buf3 = 0 ;
4836 int alloc3 = 0 ;
4837 PyObject * obj0 = 0 ;
4838 PyObject * obj1 = 0 ;
4839 PyObject * obj2 = 0 ;
4840 XdmfInt32 result;
4841
4842 if (!PyArg_ParseTuple(args,(char *)"OOO:XdmfValuesBinary_Write",&obj0,&obj1,&obj2)) SWIG_fail;
4843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, 0 | 0 );
4844 if (!SWIG_IsOK(res1)) {
4845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfValuesBinary_Write" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
4846 }
4847 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
4848 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfArray, 0 | 0 );
4849 if (!SWIG_IsOK(res2)) {
4850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfValuesBinary_Write" "', argument " "2"" of type '" "XdmfArray *""'");
4851 }
4852 arg2 = reinterpret_cast< XdmfArray * >(argp2);
4853 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
4854 if (!SWIG_IsOK(res3)) {
4855 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfValuesBinary_Write" "', argument " "3"" of type '" "XdmfConstString""'");
4856 }
4857 arg3 = reinterpret_cast< XdmfConstString >(buf3);
4858 result = (XdmfInt32)(arg1)->Write(arg2,arg3);
4859 resultobj = SWIG_From_int(static_cast< int >(result));
4860 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
4861 return resultobj;
4862 fail:
4863 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
4864 return NULL;
4865 }
4866
4867
_wrap_XdmfValuesBinary_Write__SWIG_1(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4868 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4869 PyObject *resultobj = 0;
4870 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
4871 XdmfArray *arg2 = (XdmfArray *) 0 ;
4872 void *argp1 = 0 ;
4873 int res1 = 0 ;
4874 void *argp2 = 0 ;
4875 int res2 = 0 ;
4876 PyObject * obj0 = 0 ;
4877 PyObject * obj1 = 0 ;
4878 XdmfInt32 result;
4879
4880 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfValuesBinary_Write",&obj0,&obj1)) SWIG_fail;
4881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, 0 | 0 );
4882 if (!SWIG_IsOK(res1)) {
4883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfValuesBinary_Write" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
4884 }
4885 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
4886 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfArray, 0 | 0 );
4887 if (!SWIG_IsOK(res2)) {
4888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfValuesBinary_Write" "', argument " "2"" of type '" "XdmfArray *""'");
4889 }
4890 arg2 = reinterpret_cast< XdmfArray * >(argp2);
4891 result = (XdmfInt32)(arg1)->Write(arg2);
4892 resultobj = SWIG_From_int(static_cast< int >(result));
4893 return resultobj;
4894 fail:
4895 return NULL;
4896 }
4897
4898
_wrap_XdmfValuesBinary_Write(PyObject * self,PyObject * args)4899 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_Write(PyObject *self, PyObject *args) {
4900 int argc;
4901 PyObject *argv[4];
4902 int ii;
4903
4904 if (!PyTuple_Check(args)) SWIG_fail;
4905 argc = (int)PyObject_Length(args);
4906 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4907 argv[ii] = PyTuple_GET_ITEM(args,ii);
4908 }
4909 if (argc == 2) {
4910 int _v;
4911 void *vptr = 0;
4912 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfValuesBinary, 0);
4913 _v = SWIG_CheckState(res);
4914 if (_v) {
4915 void *vptr = 0;
4916 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfArray, 0);
4917 _v = SWIG_CheckState(res);
4918 if (_v) {
4919 return _wrap_XdmfValuesBinary_Write__SWIG_1(self, args);
4920 }
4921 }
4922 }
4923 if (argc == 3) {
4924 int _v;
4925 void *vptr = 0;
4926 int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfValuesBinary, 0);
4927 _v = SWIG_CheckState(res);
4928 if (_v) {
4929 void *vptr = 0;
4930 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfArray, 0);
4931 _v = SWIG_CheckState(res);
4932 if (_v) {
4933 int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
4934 _v = SWIG_CheckState(res);
4935 if (_v) {
4936 return _wrap_XdmfValuesBinary_Write__SWIG_0(self, args);
4937 }
4938 }
4939 }
4940 }
4941
4942 fail:
4943 SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfValuesBinary_Write'.\n"
4944 " Possible C/C++ prototypes are:\n"
4945 " Write(XdmfValuesBinary *,XdmfArray *,XdmfConstString)\n"
4946 " Write(XdmfValuesBinary *,XdmfArray *)\n");
4947 return NULL;
4948 }
4949
4950
_wrap_XdmfValuesBinary_GetEndian(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4951 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_GetEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4952 PyObject *resultobj = 0;
4953 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
4954 void *argp1 = 0 ;
4955 int res1 = 0 ;
4956 PyObject * obj0 = 0 ;
4957 XdmfConstString result;
4958
4959 if (!PyArg_ParseTuple(args,(char *)"O:XdmfValuesBinary_GetEndian",&obj0)) SWIG_fail;
4960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, 0 | 0 );
4961 if (!SWIG_IsOK(res1)) {
4962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfValuesBinary_GetEndian" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
4963 }
4964 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
4965 result = (XdmfConstString)(arg1)->GetEndian();
4966 resultobj = SWIG_FromCharPtr((const char *)result);
4967 return resultobj;
4968 fail:
4969 return NULL;
4970 }
4971
4972
_wrap_XdmfValuesBinary_SetEndian(PyObject * SWIGUNUSEDPARM (self),PyObject * args)4973 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_SetEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4974 PyObject *resultobj = 0;
4975 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
4976 XdmfConstString arg2 = (XdmfConstString) 0 ;
4977 void *argp1 = 0 ;
4978 int res1 = 0 ;
4979 int res2 ;
4980 char *buf2 = 0 ;
4981 int alloc2 = 0 ;
4982 PyObject * obj0 = 0 ;
4983 PyObject * obj1 = 0 ;
4984 XdmfInt32 result;
4985
4986 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfValuesBinary_SetEndian",&obj0,&obj1)) SWIG_fail;
4987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, 0 | 0 );
4988 if (!SWIG_IsOK(res1)) {
4989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfValuesBinary_SetEndian" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
4990 }
4991 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
4992 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4993 if (!SWIG_IsOK(res2)) {
4994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfValuesBinary_SetEndian" "', argument " "2"" of type '" "XdmfConstString""'");
4995 }
4996 arg2 = reinterpret_cast< XdmfConstString >(buf2);
4997 result = (XdmfInt32)(arg1)->SetEndian(arg2);
4998 resultobj = SWIG_From_int(static_cast< int >(result));
4999 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5000 return resultobj;
5001 fail:
5002 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5003 return NULL;
5004 }
5005
5006
_wrap_XdmfValuesBinary_GetSeek(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5007 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_GetSeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5008 PyObject *resultobj = 0;
5009 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
5010 void *argp1 = 0 ;
5011 int res1 = 0 ;
5012 PyObject * obj0 = 0 ;
5013 XdmfConstString result;
5014
5015 if (!PyArg_ParseTuple(args,(char *)"O:XdmfValuesBinary_GetSeek",&obj0)) SWIG_fail;
5016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, 0 | 0 );
5017 if (!SWIG_IsOK(res1)) {
5018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfValuesBinary_GetSeek" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
5019 }
5020 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
5021 result = (XdmfConstString)(arg1)->GetSeek();
5022 resultobj = SWIG_FromCharPtr((const char *)result);
5023 return resultobj;
5024 fail:
5025 return NULL;
5026 }
5027
5028
_wrap_XdmfValuesBinary_SetSeek(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5029 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_SetSeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5030 PyObject *resultobj = 0;
5031 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
5032 XdmfConstString arg2 = (XdmfConstString) 0 ;
5033 void *argp1 = 0 ;
5034 int res1 = 0 ;
5035 int res2 ;
5036 char *buf2 = 0 ;
5037 int alloc2 = 0 ;
5038 PyObject * obj0 = 0 ;
5039 PyObject * obj1 = 0 ;
5040 XdmfInt32 result;
5041
5042 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfValuesBinary_SetSeek",&obj0,&obj1)) SWIG_fail;
5043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, 0 | 0 );
5044 if (!SWIG_IsOK(res1)) {
5045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfValuesBinary_SetSeek" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
5046 }
5047 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
5048 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5049 if (!SWIG_IsOK(res2)) {
5050 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfValuesBinary_SetSeek" "', argument " "2"" of type '" "XdmfConstString""'");
5051 }
5052 arg2 = reinterpret_cast< XdmfConstString >(buf2);
5053 result = (XdmfInt32)(arg1)->SetSeek(arg2);
5054 resultobj = SWIG_From_int(static_cast< int >(result));
5055 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5056 return resultobj;
5057 fail:
5058 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5059 return NULL;
5060 }
5061
5062
_wrap_XdmfValuesBinary_GetCompression(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5063 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_GetCompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5064 PyObject *resultobj = 0;
5065 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
5066 void *argp1 = 0 ;
5067 int res1 = 0 ;
5068 PyObject * obj0 = 0 ;
5069 XdmfConstString result;
5070
5071 if (!PyArg_ParseTuple(args,(char *)"O:XdmfValuesBinary_GetCompression",&obj0)) SWIG_fail;
5072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, 0 | 0 );
5073 if (!SWIG_IsOK(res1)) {
5074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfValuesBinary_GetCompression" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
5075 }
5076 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
5077 result = (XdmfConstString)(arg1)->GetCompression();
5078 resultobj = SWIG_FromCharPtr((const char *)result);
5079 return resultobj;
5080 fail:
5081 return NULL;
5082 }
5083
5084
_wrap_XdmfValuesBinary_SetCompression(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5085 SWIGINTERN PyObject *_wrap_XdmfValuesBinary_SetCompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5086 PyObject *resultobj = 0;
5087 XdmfValuesBinary *arg1 = (XdmfValuesBinary *) 0 ;
5088 XdmfConstString arg2 = (XdmfConstString) 0 ;
5089 void *argp1 = 0 ;
5090 int res1 = 0 ;
5091 int res2 ;
5092 char *buf2 = 0 ;
5093 int alloc2 = 0 ;
5094 PyObject * obj0 = 0 ;
5095 PyObject * obj1 = 0 ;
5096 XdmfInt32 result;
5097
5098 if (!PyArg_ParseTuple(args,(char *)"OO:XdmfValuesBinary_SetCompression",&obj0,&obj1)) SWIG_fail;
5099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfValuesBinary, 0 | 0 );
5100 if (!SWIG_IsOK(res1)) {
5101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfValuesBinary_SetCompression" "', argument " "1"" of type '" "XdmfValuesBinary *""'");
5102 }
5103 arg1 = reinterpret_cast< XdmfValuesBinary * >(argp1);
5104 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5105 if (!SWIG_IsOK(res2)) {
5106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfValuesBinary_SetCompression" "', argument " "2"" of type '" "XdmfConstString""'");
5107 }
5108 arg2 = reinterpret_cast< XdmfConstString >(buf2);
5109 result = (XdmfInt32)(arg1)->SetCompression(arg2);
5110 resultobj = SWIG_From_int(static_cast< int >(result));
5111 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5112 return resultobj;
5113 fail:
5114 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5115 return NULL;
5116 }
5117
5118
XdmfValuesBinary_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5119 SWIGINTERN PyObject *XdmfValuesBinary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5120 PyObject *obj;
5121 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5122 SWIG_TypeNewClientData(SWIGTYPE_p_XdmfValuesBinary, SWIG_NewClientData(obj));
5123 return SWIG_Py_Void();
5124 }
5125
_wrap_new_XdmfExodusReader(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5126 SWIGINTERN PyObject *_wrap_new_XdmfExodusReader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5127 PyObject *resultobj = 0;
5128 XdmfExodusReader *result = 0 ;
5129
5130 if (!PyArg_ParseTuple(args,(char *)":new_XdmfExodusReader")) SWIG_fail;
5131 result = (XdmfExodusReader *)new XdmfExodusReader();
5132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfExodusReader, SWIG_POINTER_NEW | 0 );
5133 return resultobj;
5134 fail:
5135 return NULL;
5136 }
5137
5138
_wrap_delete_XdmfExodusReader(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5139 SWIGINTERN PyObject *_wrap_delete_XdmfExodusReader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5140 PyObject *resultobj = 0;
5141 XdmfExodusReader *arg1 = (XdmfExodusReader *) 0 ;
5142 void *argp1 = 0 ;
5143 int res1 = 0 ;
5144 PyObject * obj0 = 0 ;
5145
5146 if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfExodusReader",&obj0)) SWIG_fail;
5147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfExodusReader, SWIG_POINTER_DISOWN | 0 );
5148 if (!SWIG_IsOK(res1)) {
5149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfExodusReader" "', argument " "1"" of type '" "XdmfExodusReader *""'");
5150 }
5151 arg1 = reinterpret_cast< XdmfExodusReader * >(argp1);
5152 delete arg1;
5153 resultobj = SWIG_Py_Void();
5154 return resultobj;
5155 fail:
5156 return NULL;
5157 }
5158
5159
_wrap_XdmfExodusReader_read(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5160 SWIGINTERN PyObject *_wrap_XdmfExodusReader_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5161 PyObject *resultobj = 0;
5162 XdmfExodusReader *arg1 = (XdmfExodusReader *) 0 ;
5163 char *arg2 = (char *) 0 ;
5164 XdmfElement *arg3 = (XdmfElement *) 0 ;
5165 void *argp1 = 0 ;
5166 int res1 = 0 ;
5167 int res2 ;
5168 char *buf2 = 0 ;
5169 int alloc2 = 0 ;
5170 void *argp3 = 0 ;
5171 int res3 = 0 ;
5172 PyObject * obj0 = 0 ;
5173 PyObject * obj1 = 0 ;
5174 PyObject * obj2 = 0 ;
5175 XdmfGrid *result = 0 ;
5176
5177 if (!PyArg_ParseTuple(args,(char *)"OOO:XdmfExodusReader_read",&obj0,&obj1,&obj2)) SWIG_fail;
5178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfExodusReader, 0 | 0 );
5179 if (!SWIG_IsOK(res1)) {
5180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfExodusReader_read" "', argument " "1"" of type '" "XdmfExodusReader *""'");
5181 }
5182 arg1 = reinterpret_cast< XdmfExodusReader * >(argp1);
5183 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5184 if (!SWIG_IsOK(res2)) {
5185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfExodusReader_read" "', argument " "2"" of type '" "char const *""'");
5186 }
5187 arg2 = reinterpret_cast< char * >(buf2);
5188 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_XdmfElement, 0 | 0 );
5189 if (!SWIG_IsOK(res3)) {
5190 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfExodusReader_read" "', argument " "3"" of type '" "XdmfElement *""'");
5191 }
5192 arg3 = reinterpret_cast< XdmfElement * >(argp3);
5193 result = (XdmfGrid *)(arg1)->read((char const *)arg2,arg3);
5194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfGrid, 0 | 0 );
5195 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5196 return resultobj;
5197 fail:
5198 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5199 return NULL;
5200 }
5201
5202
XdmfExodusReader_swigregister(PyObject * SWIGUNUSEDPARM (self),PyObject * args)5203 SWIGINTERN PyObject *XdmfExodusReader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5204 PyObject *obj;
5205 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5206 SWIG_TypeNewClientData(SWIGTYPE_p_XdmfExodusReader, SWIG_NewClientData(obj));
5207 return SWIG_Py_Void();
5208 }
5209
5210 static PyMethodDef SwigMethods[] = {
5211 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
5212 { (char *)"new_XdmfDiff", _wrap_new_XdmfDiff, METH_VARARGS, NULL},
5213 { (char *)"delete_XdmfDiff", _wrap_delete_XdmfDiff, METH_VARARGS, NULL},
5214 { (char *)"XdmfDiff_GetDiffs", _wrap_XdmfDiff_GetDiffs, METH_VARARGS, NULL},
5215 { (char *)"XdmfDiff_SetIgnoreTime", _wrap_XdmfDiff_SetIgnoreTime, METH_VARARGS, NULL},
5216 { (char *)"XdmfDiff_GetIgnoreTime", _wrap_XdmfDiff_GetIgnoreTime, METH_VARARGS, NULL},
5217 { (char *)"XdmfDiff_SetIgnoreGeometry", _wrap_XdmfDiff_SetIgnoreGeometry, METH_VARARGS, NULL},
5218 { (char *)"XdmfDiff_GetIgnoreGeometry", _wrap_XdmfDiff_GetIgnoreGeometry, METH_VARARGS, NULL},
5219 { (char *)"XdmfDiff_SetIgnoreTopology", _wrap_XdmfDiff_SetIgnoreTopology, METH_VARARGS, NULL},
5220 { (char *)"XdmfDiff_GetIgnoreTopology", _wrap_XdmfDiff_GetIgnoreTopology, METH_VARARGS, NULL},
5221 { (char *)"XdmfDiff_SetIgnoreAllAttributes", _wrap_XdmfDiff_SetIgnoreAllAttributes, METH_VARARGS, NULL},
5222 { (char *)"XdmfDiff_GetIgnoreAllAttributes", _wrap_XdmfDiff_GetIgnoreAllAttributes, METH_VARARGS, NULL},
5223 { (char *)"XdmfDiff_SetDisplayFailuresOnly", _wrap_XdmfDiff_SetDisplayFailuresOnly, METH_VARARGS, NULL},
5224 { (char *)"XdmfDiff_GetDisplayFailuresOnly", _wrap_XdmfDiff_GetDisplayFailuresOnly, METH_VARARGS, NULL},
5225 { (char *)"XdmfDiff_SetVerboseOutput", _wrap_XdmfDiff_SetVerboseOutput, METH_VARARGS, NULL},
5226 { (char *)"XdmfDiff_GetVerboseOutput", _wrap_XdmfDiff_GetVerboseOutput, METH_VARARGS, NULL},
5227 { (char *)"XdmfDiff_SetCreateDiffFile", _wrap_XdmfDiff_SetCreateDiffFile, METH_VARARGS, NULL},
5228 { (char *)"XdmfDiff_GetCreateDiffFile", _wrap_XdmfDiff_GetCreateDiffFile, METH_VARARGS, NULL},
5229 { (char *)"XdmfDiff_SetDiffFileName", _wrap_XdmfDiff_SetDiffFileName, METH_VARARGS, NULL},
5230 { (char *)"XdmfDiff_GetDiffFileName", _wrap_XdmfDiff_GetDiffFileName, METH_VARARGS, NULL},
5231 { (char *)"XdmfDiff_SetRelativeError", _wrap_XdmfDiff_SetRelativeError, METH_VARARGS, NULL},
5232 { (char *)"XdmfDiff_GetRelativeError", _wrap_XdmfDiff_GetRelativeError, METH_VARARGS, NULL},
5233 { (char *)"XdmfDiff_SetAbsoluteError", _wrap_XdmfDiff_SetAbsoluteError, METH_VARARGS, NULL},
5234 { (char *)"XdmfDiff_GetAbsoluteError", _wrap_XdmfDiff_GetAbsoluteError, METH_VARARGS, NULL},
5235 { (char *)"XdmfDiff_IncludeGrid", _wrap_XdmfDiff_IncludeGrid, METH_VARARGS, NULL},
5236 { (char *)"XdmfDiff_IgnoreGrid", _wrap_XdmfDiff_IgnoreGrid, METH_VARARGS, NULL},
5237 { (char *)"XdmfDiff_IncludeAttribute", _wrap_XdmfDiff_IncludeAttribute, METH_VARARGS, NULL},
5238 { (char *)"XdmfDiff_IgnoreAttribute", _wrap_XdmfDiff_IgnoreAttribute, METH_VARARGS, NULL},
5239 { (char *)"XdmfDiff_ParseSettingsFile", _wrap_XdmfDiff_ParseSettingsFile, METH_VARARGS, NULL},
5240 { (char *)"XdmfDiff_AreEquivalent", _wrap_XdmfDiff_AreEquivalent, METH_VARARGS, NULL},
5241 { (char *)"XdmfDiff_swigregister", XdmfDiff_swigregister, METH_VARARGS, NULL},
5242 { (char *)"new_XdmfDataTransform", _wrap_new_XdmfDataTransform, METH_VARARGS, NULL},
5243 { (char *)"delete_XdmfDataTransform", _wrap_delete_XdmfDataTransform, METH_VARARGS, NULL},
5244 { (char *)"XdmfDataTransform_GetClassName", _wrap_XdmfDataTransform_GetClassName, METH_VARARGS, NULL},
5245 { (char *)"XdmfDataTransform_UpdateInformation", _wrap_XdmfDataTransform_UpdateInformation, METH_VARARGS, NULL},
5246 { (char *)"XdmfDataTransform_swigregister", XdmfDataTransform_swigregister, METH_VARARGS, NULL},
5247 { (char *)"new_XdmfValuesBinary", _wrap_new_XdmfValuesBinary, METH_VARARGS, NULL},
5248 { (char *)"delete_XdmfValuesBinary", _wrap_delete_XdmfValuesBinary, METH_VARARGS, NULL},
5249 { (char *)"XdmfValuesBinary_GetClassName", _wrap_XdmfValuesBinary_GetClassName, METH_VARARGS, NULL},
5250 { (char *)"XdmfValuesBinary_Read", _wrap_XdmfValuesBinary_Read, METH_VARARGS, NULL},
5251 { (char *)"XdmfValuesBinary_Write", _wrap_XdmfValuesBinary_Write, METH_VARARGS, NULL},
5252 { (char *)"XdmfValuesBinary_GetEndian", _wrap_XdmfValuesBinary_GetEndian, METH_VARARGS, NULL},
5253 { (char *)"XdmfValuesBinary_SetEndian", _wrap_XdmfValuesBinary_SetEndian, METH_VARARGS, NULL},
5254 { (char *)"XdmfValuesBinary_GetSeek", _wrap_XdmfValuesBinary_GetSeek, METH_VARARGS, NULL},
5255 { (char *)"XdmfValuesBinary_SetSeek", _wrap_XdmfValuesBinary_SetSeek, METH_VARARGS, NULL},
5256 { (char *)"XdmfValuesBinary_GetCompression", _wrap_XdmfValuesBinary_GetCompression, METH_VARARGS, NULL},
5257 { (char *)"XdmfValuesBinary_SetCompression", _wrap_XdmfValuesBinary_SetCompression, METH_VARARGS, NULL},
5258 { (char *)"XdmfValuesBinary_swigregister", XdmfValuesBinary_swigregister, METH_VARARGS, NULL},
5259 { (char *)"new_XdmfExodusReader", _wrap_new_XdmfExodusReader, METH_VARARGS, NULL},
5260 { (char *)"delete_XdmfExodusReader", _wrap_delete_XdmfExodusReader, METH_VARARGS, NULL},
5261 { (char *)"XdmfExodusReader_read", _wrap_XdmfExodusReader_read, METH_VARARGS, NULL},
5262 { (char *)"XdmfExodusReader_swigregister", XdmfExodusReader_swigregister, METH_VARARGS, NULL},
5263 { NULL, NULL, 0, NULL }
5264 };
5265
5266
5267 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5268
_p_XdmfDataTransformTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5269 static void *_p_XdmfDataTransformTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5270 return (void *)((XdmfLightData *) (XdmfElement *)(XdmfDataItem *) ((XdmfDataTransform *) x));
5271 }
_p_XdmfDOMTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5272 static void *_p_XdmfDOMTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5273 return (void *)((XdmfLightData *) ((XdmfDOM *) x));
5274 }
_p_XdmfDataItemTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5275 static void *_p_XdmfDataItemTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5276 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfDataItem *) x));
5277 }
_p_XdmfInformationTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5278 static void *_p_XdmfInformationTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5279 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfInformation *) x));
5280 }
_p_XdmfMapTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5281 static void *_p_XdmfMapTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5282 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfMap *) x));
5283 }
_p_XdmfValuesHDFTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5284 static void *_p_XdmfValuesHDFTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5285 return (void *)((XdmfLightData *) (XdmfElement *)(XdmfDataItem *)(XdmfValues *) ((XdmfValuesHDF *) x));
5286 }
_p_XdmfGridTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5287 static void *_p_XdmfGridTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5288 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfGrid *) x));
5289 }
_p_XdmfValuesXMLTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5290 static void *_p_XdmfValuesXMLTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5291 return (void *)((XdmfLightData *) (XdmfElement *)(XdmfDataItem *)(XdmfValues *) ((XdmfValuesXML *) x));
5292 }
_p_XdmfSetTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5293 static void *_p_XdmfSetTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5294 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfSet *) x));
5295 }
_p_XdmfAttributeTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5296 static void *_p_XdmfAttributeTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5297 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfAttribute *) x));
5298 }
_p_XdmfValuesTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5299 static void *_p_XdmfValuesTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5300 return (void *)((XdmfLightData *) (XdmfElement *)(XdmfDataItem *) ((XdmfValues *) x));
5301 }
_p_XdmfRootTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5302 static void *_p_XdmfRootTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5303 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfRoot *) x));
5304 }
_p_XdmfDomainTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5305 static void *_p_XdmfDomainTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5306 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfDomain *) x));
5307 }
_p_XdmfTimeTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5308 static void *_p_XdmfTimeTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5309 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfTime *) x));
5310 }
_p_XdmfValuesBinaryTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5311 static void *_p_XdmfValuesBinaryTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5312 return (void *)((XdmfLightData *) (XdmfElement *)(XdmfDataItem *)(XdmfValues *) ((XdmfValuesBinary *) x));
5313 }
_p_XdmfTopologyTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5314 static void *_p_XdmfTopologyTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5315 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfTopology *) x));
5316 }
_p_XdmfGeometryTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5317 static void *_p_XdmfGeometryTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5318 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfGeometry *) x));
5319 }
_p_XdmfElementTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5320 static void *_p_XdmfElementTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5321 return (void *)((XdmfLightData *) ((XdmfElement *) x));
5322 }
_p_XdmfRegionTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5323 static void *_p_XdmfRegionTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5324 return (void *)((XdmfLightData *) (XdmfElement *) ((XdmfRegion *) x));
5325 }
_p_XdmfDataStructureTo_p_XdmfLightData(void * x,int * SWIGUNUSEDPARM (newmemory))5326 static void *_p_XdmfDataStructureTo_p_XdmfLightData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5327 return (void *)((XdmfLightData *) (XdmfElement *)(XdmfDataItem *) ((XdmfDataStructure *) x));
5328 }
_p_XdmfLightDataTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5329 static void *_p_XdmfLightDataTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5330 return (void *)((XdmfObject *) ((XdmfLightData *) x));
5331 }
_p_XdmfDataTransformTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5332 static void *_p_XdmfDataTransformTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5333 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *)(XdmfDataItem *) ((XdmfDataTransform *) x));
5334 }
_p_XdmfDOMTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5335 static void *_p_XdmfDOMTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5336 return (void *)((XdmfObject *) (XdmfLightData *) ((XdmfDOM *) x));
5337 }
_p_XdmfDsmMsgTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5338 static void *_p_XdmfDsmMsgTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5339 return (void *)((XdmfObject *) ((XdmfDsmMsg *) x));
5340 }
_p_XdmfDataItemTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5341 static void *_p_XdmfDataItemTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5342 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfDataItem *) x));
5343 }
_p_XdmfInformationTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5344 static void *_p_XdmfInformationTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5345 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfInformation *) x));
5346 }
_p_XdmfMapTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5347 static void *_p_XdmfMapTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5348 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfMap *) x));
5349 }
_p_XdmfValuesHDFTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5350 static void *_p_XdmfValuesHDFTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5351 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *)(XdmfDataItem *)(XdmfValues *) ((XdmfValuesHDF *) x));
5352 }
_p_XdmfGridTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5353 static void *_p_XdmfGridTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5354 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfGrid *) x));
5355 }
_p_XdmfValuesXMLTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5356 static void *_p_XdmfValuesXMLTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5357 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *)(XdmfDataItem *)(XdmfValues *) ((XdmfValuesXML *) x));
5358 }
_p_XdmfSetTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5359 static void *_p_XdmfSetTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5360 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfSet *) x));
5361 }
_p_XdmfHeavyDataTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5362 static void *_p_XdmfHeavyDataTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5363 return (void *)((XdmfObject *) (XdmfDataDesc *) ((XdmfHeavyData *) x));
5364 }
_p_XdmfAttributeTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5365 static void *_p_XdmfAttributeTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5366 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfAttribute *) x));
5367 }
_p_XdmfValuesTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5368 static void *_p_XdmfValuesTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5369 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *)(XdmfDataItem *) ((XdmfValues *) x));
5370 }
_p_XdmfDomainTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5371 static void *_p_XdmfDomainTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5372 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfDomain *) x));
5373 }
_p_XdmfRootTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5374 static void *_p_XdmfRootTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5375 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfRoot *) x));
5376 }
_p_XdmfTimeTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5377 static void *_p_XdmfTimeTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5378 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfTime *) x));
5379 }
_p_XdmfValuesBinaryTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5380 static void *_p_XdmfValuesBinaryTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5381 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *)(XdmfDataItem *)(XdmfValues *) ((XdmfValuesBinary *) x));
5382 }
_p_XdmfTopologyTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5383 static void *_p_XdmfTopologyTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5384 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfTopology *) x));
5385 }
_p_XdmfDataDescTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5386 static void *_p_XdmfDataDescTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5387 return (void *)((XdmfObject *) ((XdmfDataDesc *) x));
5388 }
_p_XdmfDsmTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5389 static void *_p_XdmfDsmTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5390 return (void *)((XdmfObject *) ((XdmfDsm *) x));
5391 }
_p_XdmfArrayTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5392 static void *_p_XdmfArrayTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5393 return (void *)((XdmfObject *) (XdmfDataDesc *) ((XdmfArray *) x));
5394 }
_p_XdmfDsmCommTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5395 static void *_p_XdmfDsmCommTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5396 return (void *)((XdmfObject *) ((XdmfDsmComm *) x));
5397 }
_p_XdmfElementTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5398 static void *_p_XdmfElementTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5399 return (void *)((XdmfObject *) (XdmfLightData *) ((XdmfElement *) x));
5400 }
_p_XdmfGeometryTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5401 static void *_p_XdmfGeometryTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5402 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfGeometry *) x));
5403 }
_p_XdmfRegionTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5404 static void *_p_XdmfRegionTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5405 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *) ((XdmfRegion *) x));
5406 }
_p_XdmfHDFTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5407 static void *_p_XdmfHDFTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5408 return (void *)((XdmfObject *) (XdmfDataDesc *)(XdmfHeavyData *) ((XdmfHDF *) x));
5409 }
_p_XdmfDataStructureTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5410 static void *_p_XdmfDataStructureTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5411 return (void *)((XdmfObject *) (XdmfLightData *)(XdmfElement *)(XdmfDataItem *) ((XdmfDataStructure *) x));
5412 }
_p_XdmfDsmBufferTo_p_XdmfObject(void * x,int * SWIGUNUSEDPARM (newmemory))5413 static void *_p_XdmfDsmBufferTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5414 return (void *)((XdmfObject *) (XdmfDsm *) ((XdmfDsmBuffer *) x));
5415 }
_p_XdmfDataStructureTo_p_XdmfDataItem(void * x,int * SWIGUNUSEDPARM (newmemory))5416 static void *_p_XdmfDataStructureTo_p_XdmfDataItem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5417 return (void *)((XdmfDataItem *) ((XdmfDataStructure *) x));
5418 }
_p_XdmfValuesXMLTo_p_XdmfDataItem(void * x,int * SWIGUNUSEDPARM (newmemory))5419 static void *_p_XdmfValuesXMLTo_p_XdmfDataItem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5420 return (void *)((XdmfDataItem *) (XdmfValues *) ((XdmfValuesXML *) x));
5421 }
_p_XdmfValuesBinaryTo_p_XdmfDataItem(void * x,int * SWIGUNUSEDPARM (newmemory))5422 static void *_p_XdmfValuesBinaryTo_p_XdmfDataItem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5423 return (void *)((XdmfDataItem *) (XdmfValues *) ((XdmfValuesBinary *) x));
5424 }
_p_XdmfValuesTo_p_XdmfDataItem(void * x,int * SWIGUNUSEDPARM (newmemory))5425 static void *_p_XdmfValuesTo_p_XdmfDataItem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5426 return (void *)((XdmfDataItem *) ((XdmfValues *) x));
5427 }
_p_XdmfValuesHDFTo_p_XdmfDataItem(void * x,int * SWIGUNUSEDPARM (newmemory))5428 static void *_p_XdmfValuesHDFTo_p_XdmfDataItem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5429 return (void *)((XdmfDataItem *) (XdmfValues *) ((XdmfValuesHDF *) x));
5430 }
_p_XdmfDataTransformTo_p_XdmfDataItem(void * x,int * SWIGUNUSEDPARM (newmemory))5431 static void *_p_XdmfDataTransformTo_p_XdmfDataItem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5432 return (void *)((XdmfDataItem *) ((XdmfDataTransform *) x));
5433 }
_p_XdmfValuesXMLTo_p_XdmfValues(void * x,int * SWIGUNUSEDPARM (newmemory))5434 static void *_p_XdmfValuesXMLTo_p_XdmfValues(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5435 return (void *)((XdmfValues *) ((XdmfValuesXML *) x));
5436 }
_p_XdmfValuesBinaryTo_p_XdmfValues(void * x,int * SWIGUNUSEDPARM (newmemory))5437 static void *_p_XdmfValuesBinaryTo_p_XdmfValues(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5438 return (void *)((XdmfValues *) ((XdmfValuesBinary *) x));
5439 }
_p_XdmfValuesHDFTo_p_XdmfValues(void * x,int * SWIGUNUSEDPARM (newmemory))5440 static void *_p_XdmfValuesHDFTo_p_XdmfValues(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5441 return (void *)((XdmfValues *) ((XdmfValuesHDF *) x));
5442 }
_p_XdmfDataTransformTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5443 static void *_p_XdmfDataTransformTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5444 return (void *)((XdmfElement *) (XdmfDataItem *) ((XdmfDataTransform *) x));
5445 }
_p_XdmfDataItemTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5446 static void *_p_XdmfDataItemTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5447 return (void *)((XdmfElement *) ((XdmfDataItem *) x));
5448 }
_p_XdmfInformationTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5449 static void *_p_XdmfInformationTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5450 return (void *)((XdmfElement *) ((XdmfInformation *) x));
5451 }
_p_XdmfMapTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5452 static void *_p_XdmfMapTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5453 return (void *)((XdmfElement *) ((XdmfMap *) x));
5454 }
_p_XdmfValuesHDFTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5455 static void *_p_XdmfValuesHDFTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5456 return (void *)((XdmfElement *) (XdmfDataItem *)(XdmfValues *) ((XdmfValuesHDF *) x));
5457 }
_p_XdmfGridTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5458 static void *_p_XdmfGridTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5459 return (void *)((XdmfElement *) ((XdmfGrid *) x));
5460 }
_p_XdmfValuesXMLTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5461 static void *_p_XdmfValuesXMLTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5462 return (void *)((XdmfElement *) (XdmfDataItem *)(XdmfValues *) ((XdmfValuesXML *) x));
5463 }
_p_XdmfSetTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5464 static void *_p_XdmfSetTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5465 return (void *)((XdmfElement *) ((XdmfSet *) x));
5466 }
_p_XdmfAttributeTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5467 static void *_p_XdmfAttributeTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5468 return (void *)((XdmfElement *) ((XdmfAttribute *) x));
5469 }
_p_XdmfValuesTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5470 static void *_p_XdmfValuesTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5471 return (void *)((XdmfElement *) (XdmfDataItem *) ((XdmfValues *) x));
5472 }
_p_XdmfTimeTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5473 static void *_p_XdmfTimeTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5474 return (void *)((XdmfElement *) ((XdmfTime *) x));
5475 }
_p_XdmfRootTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5476 static void *_p_XdmfRootTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5477 return (void *)((XdmfElement *) ((XdmfRoot *) x));
5478 }
_p_XdmfDomainTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5479 static void *_p_XdmfDomainTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5480 return (void *)((XdmfElement *) ((XdmfDomain *) x));
5481 }
_p_XdmfValuesBinaryTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5482 static void *_p_XdmfValuesBinaryTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5483 return (void *)((XdmfElement *) (XdmfDataItem *)(XdmfValues *) ((XdmfValuesBinary *) x));
5484 }
_p_XdmfTopologyTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5485 static void *_p_XdmfTopologyTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5486 return (void *)((XdmfElement *) ((XdmfTopology *) x));
5487 }
_p_XdmfRegionTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5488 static void *_p_XdmfRegionTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5489 return (void *)((XdmfElement *) ((XdmfRegion *) x));
5490 }
_p_XdmfGeometryTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5491 static void *_p_XdmfGeometryTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5492 return (void *)((XdmfElement *) ((XdmfGeometry *) x));
5493 }
_p_XdmfDataStructureTo_p_XdmfElement(void * x,int * SWIGUNUSEDPARM (newmemory))5494 static void *_p_XdmfDataStructureTo_p_XdmfElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5495 return (void *)((XdmfElement *) (XdmfDataItem *) ((XdmfDataStructure *) x));
5496 }
5497 static swig_type_info _swigt__p_XdmfArray = {"_p_XdmfArray", "XdmfArray *", 0, 0, (void*)0, 0};
5498 static swig_type_info _swigt__p_XdmfDOM = {"_p_XdmfDOM", "XdmfDOM *", 0, 0, (void*)0, 0};
5499 static swig_type_info _swigt__p_XdmfDataItem = {"_p_XdmfDataItem", "XdmfDataItem *", 0, 0, (void*)0, 0};
5500 static swig_type_info _swigt__p_XdmfDataStructure = {"_p_XdmfDataStructure", 0, 0, 0, 0, 0};
5501 static swig_type_info _swigt__p_XdmfValuesXML = {"_p_XdmfValuesXML", 0, 0, 0, 0, 0};
5502 static swig_type_info _swigt__p_XdmfValuesHDF = {"_p_XdmfValuesHDF", 0, 0, 0, 0, 0};
5503 static swig_type_info _swigt__p_XdmfDataTransform = {"_p_XdmfDataTransform", "XdmfDataTransform *", 0, 0, (void*)0, 0};
5504 static swig_type_info _swigt__p_XdmfDiff = {"_p_XdmfDiff", "XdmfDiff *", 0, 0, (void*)0, 0};
5505 static swig_type_info _swigt__p_XdmfElement = {"_p_XdmfElement", "XdmfElement *", 0, 0, (void*)0, 0};
5506 static swig_type_info _swigt__p_XdmfMap = {"_p_XdmfMap", 0, 0, 0, 0, 0};
5507 static swig_type_info _swigt__p_XdmfInformation = {"_p_XdmfInformation", 0, 0, 0, 0, 0};
5508 static swig_type_info _swigt__p_XdmfSet = {"_p_XdmfSet", 0, 0, 0, 0, 0};
5509 static swig_type_info _swigt__p_XdmfAttribute = {"_p_XdmfAttribute", 0, 0, 0, 0, 0};
5510 static swig_type_info _swigt__p_XdmfTime = {"_p_XdmfTime", 0, 0, 0, 0, 0};
5511 static swig_type_info _swigt__p_XdmfDomain = {"_p_XdmfDomain", 0, 0, 0, 0, 0};
5512 static swig_type_info _swigt__p_XdmfRoot = {"_p_XdmfRoot", 0, 0, 0, 0, 0};
5513 static swig_type_info _swigt__p_XdmfTopology = {"_p_XdmfTopology", 0, 0, 0, 0, 0};
5514 static swig_type_info _swigt__p_XdmfRegion = {"_p_XdmfRegion", 0, 0, 0, 0, 0};
5515 static swig_type_info _swigt__p_XdmfGeometry = {"_p_XdmfGeometry", 0, 0, 0, 0, 0};
5516 static swig_type_info _swigt__p_XdmfExodusReader = {"_p_XdmfExodusReader", "XdmfExodusReader *", 0, 0, (void*)0, 0};
5517 static swig_type_info _swigt__p_XdmfGrid = {"_p_XdmfGrid", "XdmfGrid *", 0, 0, (void*)0, 0};
5518 static swig_type_info _swigt__p_XdmfLightData = {"_p_XdmfLightData", "XdmfLightData *", 0, 0, (void*)0, 0};
5519 static swig_type_info _swigt__p_XdmfObject = {"_p_XdmfObject", "XdmfObject *", 0, 0, (void*)0, 0};
5520 static swig_type_info _swigt__p_XdmfDsmMsg = {"_p_XdmfDsmMsg", 0, 0, 0, 0, 0};
5521 static swig_type_info _swigt__p_XdmfHeavyData = {"_p_XdmfHeavyData", 0, 0, 0, 0, 0};
5522 static swig_type_info _swigt__p_XdmfDataDesc = {"_p_XdmfDataDesc", 0, 0, 0, 0, 0};
5523 static swig_type_info _swigt__p_XdmfDsm = {"_p_XdmfDsm", 0, 0, 0, 0, 0};
5524 static swig_type_info _swigt__p_XdmfDsmComm = {"_p_XdmfDsmComm", 0, 0, 0, 0, 0};
5525 static swig_type_info _swigt__p_XdmfHDF = {"_p_XdmfHDF", 0, 0, 0, 0, 0};
5526 static swig_type_info _swigt__p_XdmfDsmBuffer = {"_p_XdmfDsmBuffer", 0, 0, 0, 0, 0};
5527 static swig_type_info _swigt__p_XdmfValues = {"_p_XdmfValues", "XdmfValues *", 0, 0, (void*)0, 0};
5528 static swig_type_info _swigt__p_XdmfValuesBinary = {"_p_XdmfValuesBinary", "XdmfValuesBinary *", 0, 0, (void*)0, 0};
5529 static swig_type_info _swigt__p_char = {"_p_char", "char *|XdmfInt8 *", 0, 0, (void*)0, 0};
5530 static swig_type_info _swigt__p_double = {"_p_double", "XdmfFloat64 *|double *", 0, 0, (void*)0, 0};
5531 static swig_type_info _swigt__p_float = {"_p_float", "float *|XdmfFloat32 *", 0, 0, (void*)0, 0};
5532 static swig_type_info _swigt__p_int = {"_p_int", "int *|XdmfInt32 *|XdmfBoolean *", 0, 0, (void*)0, 0};
5533 static swig_type_info _swigt__p_long_long = {"_p_long_long", "XdmfInt64 *|long long *|XdmfLength *", 0, 0, (void*)0, 0};
5534 static swig_type_info _swigt__p_short = {"_p_short", "XdmfInt16 *|short *", 0, 0, (void*)0, 0};
5535 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|XdmfUInt8 *|XdmfByte *", 0, 0, (void*)0, 0};
5536 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "XdmfUInt32 *|unsigned int *", 0, 0, (void*)0, 0};
5537 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "XdmfUInt16 *|unsigned short *", 0, 0, (void*)0, 0};
5538
5539 static swig_type_info *swig_type_initial[] = {
5540 &_swigt__p_XdmfArray,
5541 &_swigt__p_XdmfAttribute,
5542 &_swigt__p_XdmfDOM,
5543 &_swigt__p_XdmfDataDesc,
5544 &_swigt__p_XdmfDataItem,
5545 &_swigt__p_XdmfDataStructure,
5546 &_swigt__p_XdmfDataTransform,
5547 &_swigt__p_XdmfDiff,
5548 &_swigt__p_XdmfDomain,
5549 &_swigt__p_XdmfDsm,
5550 &_swigt__p_XdmfDsmBuffer,
5551 &_swigt__p_XdmfDsmComm,
5552 &_swigt__p_XdmfDsmMsg,
5553 &_swigt__p_XdmfElement,
5554 &_swigt__p_XdmfExodusReader,
5555 &_swigt__p_XdmfGeometry,
5556 &_swigt__p_XdmfGrid,
5557 &_swigt__p_XdmfHDF,
5558 &_swigt__p_XdmfHeavyData,
5559 &_swigt__p_XdmfInformation,
5560 &_swigt__p_XdmfLightData,
5561 &_swigt__p_XdmfMap,
5562 &_swigt__p_XdmfObject,
5563 &_swigt__p_XdmfRegion,
5564 &_swigt__p_XdmfRoot,
5565 &_swigt__p_XdmfSet,
5566 &_swigt__p_XdmfTime,
5567 &_swigt__p_XdmfTopology,
5568 &_swigt__p_XdmfValues,
5569 &_swigt__p_XdmfValuesBinary,
5570 &_swigt__p_XdmfValuesHDF,
5571 &_swigt__p_XdmfValuesXML,
5572 &_swigt__p_char,
5573 &_swigt__p_double,
5574 &_swigt__p_float,
5575 &_swigt__p_int,
5576 &_swigt__p_long_long,
5577 &_swigt__p_short,
5578 &_swigt__p_unsigned_char,
5579 &_swigt__p_unsigned_int,
5580 &_swigt__p_unsigned_short,
5581 };
5582
5583 static swig_cast_info _swigc__p_XdmfArray[] = { {&_swigt__p_XdmfArray, 0, 0, 0},{0, 0, 0, 0}};
5584 static swig_cast_info _swigc__p_XdmfDOM[] = { {&_swigt__p_XdmfDOM, 0, 0, 0},{0, 0, 0, 0}};
5585 static swig_cast_info _swigc__p_XdmfDataStructure[] = {{&_swigt__p_XdmfDataStructure, 0, 0, 0},{0, 0, 0, 0}};
5586 static swig_cast_info _swigc__p_XdmfValuesXML[] = {{&_swigt__p_XdmfValuesXML, 0, 0, 0},{0, 0, 0, 0}};
5587 static swig_cast_info _swigc__p_XdmfValuesHDF[] = {{&_swigt__p_XdmfValuesHDF, 0, 0, 0},{0, 0, 0, 0}};
5588 static swig_cast_info _swigc__p_XdmfDataItem[] = { {&_swigt__p_XdmfDataItem, 0, 0, 0}, {&_swigt__p_XdmfDataStructure, _p_XdmfDataStructureTo_p_XdmfDataItem, 0, 0}, {&_swigt__p_XdmfValuesXML, _p_XdmfValuesXMLTo_p_XdmfDataItem, 0, 0}, {&_swigt__p_XdmfValuesBinary, _p_XdmfValuesBinaryTo_p_XdmfDataItem, 0, 0}, {&_swigt__p_XdmfValues, _p_XdmfValuesTo_p_XdmfDataItem, 0, 0}, {&_swigt__p_XdmfValuesHDF, _p_XdmfValuesHDFTo_p_XdmfDataItem, 0, 0}, {&_swigt__p_XdmfDataTransform, _p_XdmfDataTransformTo_p_XdmfDataItem, 0, 0},{0, 0, 0, 0}};
5589 static swig_cast_info _swigc__p_XdmfDataTransform[] = { {&_swigt__p_XdmfDataTransform, 0, 0, 0},{0, 0, 0, 0}};
5590 static swig_cast_info _swigc__p_XdmfDiff[] = { {&_swigt__p_XdmfDiff, 0, 0, 0},{0, 0, 0, 0}};
5591 static swig_cast_info _swigc__p_XdmfMap[] = {{&_swigt__p_XdmfMap, 0, 0, 0},{0, 0, 0, 0}};
5592 static swig_cast_info _swigc__p_XdmfInformation[] = {{&_swigt__p_XdmfInformation, 0, 0, 0},{0, 0, 0, 0}};
5593 static swig_cast_info _swigc__p_XdmfSet[] = {{&_swigt__p_XdmfSet, 0, 0, 0},{0, 0, 0, 0}};
5594 static swig_cast_info _swigc__p_XdmfAttribute[] = {{&_swigt__p_XdmfAttribute, 0, 0, 0},{0, 0, 0, 0}};
5595 static swig_cast_info _swigc__p_XdmfTime[] = {{&_swigt__p_XdmfTime, 0, 0, 0},{0, 0, 0, 0}};
5596 static swig_cast_info _swigc__p_XdmfDomain[] = {{&_swigt__p_XdmfDomain, 0, 0, 0},{0, 0, 0, 0}};
5597 static swig_cast_info _swigc__p_XdmfRoot[] = {{&_swigt__p_XdmfRoot, 0, 0, 0},{0, 0, 0, 0}};
5598 static swig_cast_info _swigc__p_XdmfTopology[] = {{&_swigt__p_XdmfTopology, 0, 0, 0},{0, 0, 0, 0}};
5599 static swig_cast_info _swigc__p_XdmfRegion[] = {{&_swigt__p_XdmfRegion, 0, 0, 0},{0, 0, 0, 0}};
5600 static swig_cast_info _swigc__p_XdmfGeometry[] = {{&_swigt__p_XdmfGeometry, 0, 0, 0},{0, 0, 0, 0}};
5601 static swig_cast_info _swigc__p_XdmfElement[] = { {&_swigt__p_XdmfDataTransform, _p_XdmfDataTransformTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfMap, _p_XdmfMapTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfDataItem, _p_XdmfDataItemTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfInformation, _p_XdmfInformationTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfValuesHDF, _p_XdmfValuesHDFTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfGrid, _p_XdmfGridTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfValuesXML, _p_XdmfValuesXMLTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfSet, _p_XdmfSetTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfAttribute, _p_XdmfAttributeTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfValues, _p_XdmfValuesTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfTime, _p_XdmfTimeTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfValuesBinary, _p_XdmfValuesBinaryTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfDomain, _p_XdmfDomainTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfRoot, _p_XdmfRootTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfTopology, _p_XdmfTopologyTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfElement, 0, 0, 0}, {&_swigt__p_XdmfRegion, _p_XdmfRegionTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfGeometry, _p_XdmfGeometryTo_p_XdmfElement, 0, 0}, {&_swigt__p_XdmfDataStructure, _p_XdmfDataStructureTo_p_XdmfElement, 0, 0},{0, 0, 0, 0}};
5602 static swig_cast_info _swigc__p_XdmfExodusReader[] = { {&_swigt__p_XdmfExodusReader, 0, 0, 0},{0, 0, 0, 0}};
5603 static swig_cast_info _swigc__p_XdmfGrid[] = { {&_swigt__p_XdmfGrid, 0, 0, 0},{0, 0, 0, 0}};
5604 static swig_cast_info _swigc__p_XdmfLightData[] = { {&_swigt__p_XdmfDataTransform, _p_XdmfDataTransformTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfLightData, 0, 0, 0}, {&_swigt__p_XdmfDOM, _p_XdmfDOMTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfMap, _p_XdmfMapTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfDataItem, _p_XdmfDataItemTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfInformation, _p_XdmfInformationTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfValuesHDF, _p_XdmfValuesHDFTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfGrid, _p_XdmfGridTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfValuesXML, _p_XdmfValuesXMLTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfSet, _p_XdmfSetTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfAttribute, _p_XdmfAttributeTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfValues, _p_XdmfValuesTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfValuesBinary, _p_XdmfValuesBinaryTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfDomain, _p_XdmfDomainTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfRoot, _p_XdmfRootTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfTime, _p_XdmfTimeTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfTopology, _p_XdmfTopologyTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfGeometry, _p_XdmfGeometryTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfElement, _p_XdmfElementTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfRegion, _p_XdmfRegionTo_p_XdmfLightData, 0, 0}, {&_swigt__p_XdmfDataStructure, _p_XdmfDataStructureTo_p_XdmfLightData, 0, 0},{0, 0, 0, 0}};
5605 static swig_cast_info _swigc__p_XdmfDsmMsg[] = {{&_swigt__p_XdmfDsmMsg, 0, 0, 0},{0, 0, 0, 0}};
5606 static swig_cast_info _swigc__p_XdmfHeavyData[] = {{&_swigt__p_XdmfHeavyData, 0, 0, 0},{0, 0, 0, 0}};
5607 static swig_cast_info _swigc__p_XdmfDataDesc[] = {{&_swigt__p_XdmfDataDesc, 0, 0, 0},{0, 0, 0, 0}};
5608 static swig_cast_info _swigc__p_XdmfDsm[] = {{&_swigt__p_XdmfDsm, 0, 0, 0},{0, 0, 0, 0}};
5609 static swig_cast_info _swigc__p_XdmfDsmComm[] = {{&_swigt__p_XdmfDsmComm, 0, 0, 0},{0, 0, 0, 0}};
5610 static swig_cast_info _swigc__p_XdmfHDF[] = {{&_swigt__p_XdmfHDF, 0, 0, 0},{0, 0, 0, 0}};
5611 static swig_cast_info _swigc__p_XdmfDsmBuffer[] = {{&_swigt__p_XdmfDsmBuffer, 0, 0, 0},{0, 0, 0, 0}};
5612 static swig_cast_info _swigc__p_XdmfObject[] = { {&_swigt__p_XdmfDataTransform, _p_XdmfDataTransformTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfLightData, _p_XdmfLightDataTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfDOM, _p_XdmfDOMTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfObject, 0, 0, 0}, {&_swigt__p_XdmfDsmMsg, _p_XdmfDsmMsgTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfMap, _p_XdmfMapTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfDataItem, _p_XdmfDataItemTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfInformation, _p_XdmfInformationTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfValuesHDF, _p_XdmfValuesHDFTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfGrid, _p_XdmfGridTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfValuesXML, _p_XdmfValuesXMLTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfSet, _p_XdmfSetTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfHeavyData, _p_XdmfHeavyDataTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfAttribute, _p_XdmfAttributeTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfValues, _p_XdmfValuesTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfValuesBinary, _p_XdmfValuesBinaryTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfDomain, _p_XdmfDomainTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfRoot, _p_XdmfRootTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfTime, _p_XdmfTimeTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfTopology, _p_XdmfTopologyTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfDataDesc, _p_XdmfDataDescTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfDsm, _p_XdmfDsmTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfArray, _p_XdmfArrayTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfDsmComm, _p_XdmfDsmCommTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfGeometry, _p_XdmfGeometryTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfElement, _p_XdmfElementTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfRegion, _p_XdmfRegionTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfDataStructure, _p_XdmfDataStructureTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfHDF, _p_XdmfHDFTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfDsmBuffer, _p_XdmfDsmBufferTo_p_XdmfObject, 0, 0},{0, 0, 0, 0}};
5613 static swig_cast_info _swigc__p_XdmfValues[] = { {&_swigt__p_XdmfValuesXML, _p_XdmfValuesXMLTo_p_XdmfValues, 0, 0}, {&_swigt__p_XdmfValuesBinary, _p_XdmfValuesBinaryTo_p_XdmfValues, 0, 0}, {&_swigt__p_XdmfValues, 0, 0, 0}, {&_swigt__p_XdmfValuesHDF, _p_XdmfValuesHDFTo_p_XdmfValues, 0, 0},{0, 0, 0, 0}};
5614 static swig_cast_info _swigc__p_XdmfValuesBinary[] = { {&_swigt__p_XdmfValuesBinary, 0, 0, 0},{0, 0, 0, 0}};
5615 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
5616 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
5617 static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
5618 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
5619 static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
5620 static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
5621 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
5622 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
5623 static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
5624
5625 static swig_cast_info *swig_cast_initial[] = {
5626 _swigc__p_XdmfArray,
5627 _swigc__p_XdmfAttribute,
5628 _swigc__p_XdmfDOM,
5629 _swigc__p_XdmfDataDesc,
5630 _swigc__p_XdmfDataItem,
5631 _swigc__p_XdmfDataStructure,
5632 _swigc__p_XdmfDataTransform,
5633 _swigc__p_XdmfDiff,
5634 _swigc__p_XdmfDomain,
5635 _swigc__p_XdmfDsm,
5636 _swigc__p_XdmfDsmBuffer,
5637 _swigc__p_XdmfDsmComm,
5638 _swigc__p_XdmfDsmMsg,
5639 _swigc__p_XdmfElement,
5640 _swigc__p_XdmfExodusReader,
5641 _swigc__p_XdmfGeometry,
5642 _swigc__p_XdmfGrid,
5643 _swigc__p_XdmfHDF,
5644 _swigc__p_XdmfHeavyData,
5645 _swigc__p_XdmfInformation,
5646 _swigc__p_XdmfLightData,
5647 _swigc__p_XdmfMap,
5648 _swigc__p_XdmfObject,
5649 _swigc__p_XdmfRegion,
5650 _swigc__p_XdmfRoot,
5651 _swigc__p_XdmfSet,
5652 _swigc__p_XdmfTime,
5653 _swigc__p_XdmfTopology,
5654 _swigc__p_XdmfValues,
5655 _swigc__p_XdmfValuesBinary,
5656 _swigc__p_XdmfValuesHDF,
5657 _swigc__p_XdmfValuesXML,
5658 _swigc__p_char,
5659 _swigc__p_double,
5660 _swigc__p_float,
5661 _swigc__p_int,
5662 _swigc__p_long_long,
5663 _swigc__p_short,
5664 _swigc__p_unsigned_char,
5665 _swigc__p_unsigned_int,
5666 _swigc__p_unsigned_short,
5667 };
5668
5669
5670 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
5671
5672 static swig_const_info swig_const_table[] = {
5673 {0, 0, 0, 0.0, 0, 0}};
5674
5675 #ifdef __cplusplus
5676 }
5677 #endif
5678 /* -----------------------------------------------------------------------------
5679 * Type initialization:
5680 * This problem is tough by the requirement that no dynamic
5681 * memory is used. Also, since swig_type_info structures store pointers to
5682 * swig_cast_info structures and swig_cast_info structures store pointers back
5683 * to swig_type_info structures, we need some lookup code at initialization.
5684 * The idea is that swig generates all the structures that are needed.
5685 * The runtime then collects these partially filled structures.
5686 * The SWIG_InitializeModule function takes these initial arrays out of
5687 * swig_module, and does all the lookup, filling in the swig_module.types
5688 * array with the correct data and linking the correct swig_cast_info
5689 * structures together.
5690 *
5691 * The generated swig_type_info structures are assigned staticly to an initial
5692 * array. We just loop through that array, and handle each type individually.
5693 * First we lookup if this type has been already loaded, and if so, use the
5694 * loaded structure instead of the generated one. Then we have to fill in the
5695 * cast linked list. The cast data is initially stored in something like a
5696 * two-dimensional array. Each row corresponds to a type (there are the same
5697 * number of rows as there are in the swig_type_initial array). Each entry in
5698 * a column is one of the swig_cast_info structures for that type.
5699 * The cast_initial array is actually an array of arrays, because each row has
5700 * a variable number of columns. So to actually build the cast linked list,
5701 * we find the array of casts associated with the type, and loop through it
5702 * adding the casts to the list. The one last trick we need to do is making
5703 * sure the type pointer in the swig_cast_info struct is correct.
5704 *
5705 * First off, we lookup the cast->type name to see if it is already loaded.
5706 * There are three cases to handle:
5707 * 1) If the cast->type has already been loaded AND the type we are adding
5708 * casting info to has not been loaded (it is in this module), THEN we
5709 * replace the cast->type pointer with the type pointer that has already
5710 * been loaded.
5711 * 2) If BOTH types (the one we are adding casting info to, and the
5712 * cast->type) are loaded, THEN the cast info has already been loaded by
5713 * the previous module so we just ignore it.
5714 * 3) Finally, if cast->type has not already been loaded, then we add that
5715 * swig_cast_info to the linked list (because the cast->type) pointer will
5716 * be correct.
5717 * ----------------------------------------------------------------------------- */
5718
5719 #ifdef __cplusplus
5720 extern "C" {
5721 #if 0
5722 } /* c-mode */
5723 #endif
5724 #endif
5725
5726 #if 0
5727 #define SWIGRUNTIME_DEBUG
5728 #endif
5729
5730
5731 SWIGRUNTIME void
SWIG_InitializeModule(void * clientdata)5732 SWIG_InitializeModule(void *clientdata) {
5733 size_t i;
5734 swig_module_info *module_head, *iter;
5735 int found, init;
5736
5737 clientdata = clientdata;
5738
5739 /* check to see if the circular list has been setup, if not, set it up */
5740 if (swig_module.next==0) {
5741 /* Initialize the swig_module */
5742 swig_module.type_initial = swig_type_initial;
5743 swig_module.cast_initial = swig_cast_initial;
5744 swig_module.next = &swig_module;
5745 init = 1;
5746 } else {
5747 init = 0;
5748 }
5749
5750 /* Try and load any already created modules */
5751 module_head = SWIG_GetModule(clientdata);
5752 if (!module_head) {
5753 /* This is the first module loaded for this interpreter */
5754 /* so set the swig module into the interpreter */
5755 SWIG_SetModule(clientdata, &swig_module);
5756 module_head = &swig_module;
5757 } else {
5758 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
5759 found=0;
5760 iter=module_head;
5761 do {
5762 if (iter==&swig_module) {
5763 found=1;
5764 break;
5765 }
5766 iter=iter->next;
5767 } while (iter!= module_head);
5768
5769 /* if the is found in the list, then all is done and we may leave */
5770 if (found) return;
5771 /* otherwise we must add out module into the list */
5772 swig_module.next = module_head->next;
5773 module_head->next = &swig_module;
5774 }
5775
5776 /* When multiple interpeters are used, a module could have already been initialized in
5777 a different interpreter, but not yet have a pointer in this interpreter.
5778 In this case, we do not want to continue adding types... everything should be
5779 set up already */
5780 if (init == 0) return;
5781
5782 /* Now work on filling in swig_module.types */
5783 #ifdef SWIGRUNTIME_DEBUG
5784 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
5785 #endif
5786 for (i = 0; i < swig_module.size; ++i) {
5787 swig_type_info *type = 0;
5788 swig_type_info *ret;
5789 swig_cast_info *cast;
5790
5791 #ifdef SWIGRUNTIME_DEBUG
5792 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
5793 #endif
5794
5795 /* if there is another module already loaded */
5796 if (swig_module.next != &swig_module) {
5797 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
5798 }
5799 if (type) {
5800 /* Overwrite clientdata field */
5801 #ifdef SWIGRUNTIME_DEBUG
5802 printf("SWIG_InitializeModule: found type %s\n", type->name);
5803 #endif
5804 if (swig_module.type_initial[i]->clientdata) {
5805 type->clientdata = swig_module.type_initial[i]->clientdata;
5806 #ifdef SWIGRUNTIME_DEBUG
5807 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
5808 #endif
5809 }
5810 } else {
5811 type = swig_module.type_initial[i];
5812 }
5813
5814 /* Insert casting types */
5815 cast = swig_module.cast_initial[i];
5816 while (cast->type) {
5817 /* Don't need to add information already in the list */
5818 ret = 0;
5819 #ifdef SWIGRUNTIME_DEBUG
5820 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
5821 #endif
5822 if (swig_module.next != &swig_module) {
5823 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
5824 #ifdef SWIGRUNTIME_DEBUG
5825 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
5826 #endif
5827 }
5828 if (ret) {
5829 if (type == swig_module.type_initial[i]) {
5830 #ifdef SWIGRUNTIME_DEBUG
5831 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
5832 #endif
5833 cast->type = ret;
5834 ret = 0;
5835 } else {
5836 /* Check for casting already in the list */
5837 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
5838 #ifdef SWIGRUNTIME_DEBUG
5839 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
5840 #endif
5841 if (!ocast) ret = 0;
5842 }
5843 }
5844
5845 if (!ret) {
5846 #ifdef SWIGRUNTIME_DEBUG
5847 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
5848 #endif
5849 if (type->cast) {
5850 type->cast->prev = cast;
5851 cast->next = type->cast;
5852 }
5853 type->cast = cast;
5854 }
5855 cast++;
5856 }
5857 /* Set entry in modules->types array equal to the type */
5858 swig_module.types[i] = type;
5859 }
5860 swig_module.types[i] = 0;
5861
5862 #ifdef SWIGRUNTIME_DEBUG
5863 printf("**** SWIG_InitializeModule: Cast List ******\n");
5864 for (i = 0; i < swig_module.size; ++i) {
5865 int j = 0;
5866 swig_cast_info *cast = swig_module.cast_initial[i];
5867 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
5868 while (cast->type) {
5869 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
5870 cast++;
5871 ++j;
5872 }
5873 printf("---- Total casts: %d\n",j);
5874 }
5875 printf("**** SWIG_InitializeModule: Cast List ******\n");
5876 #endif
5877 }
5878
5879 /* This function will propagate the clientdata field of type to
5880 * any new swig_type_info structures that have been added into the list
5881 * of equivalent types. It is like calling
5882 * SWIG_TypeClientData(type, clientdata) a second time.
5883 */
5884 SWIGRUNTIME void
SWIG_PropagateClientData(void)5885 SWIG_PropagateClientData(void) {
5886 size_t i;
5887 swig_cast_info *equiv;
5888 static int init_run = 0;
5889
5890 if (init_run) return;
5891 init_run = 1;
5892
5893 for (i = 0; i < swig_module.size; i++) {
5894 if (swig_module.types[i]->clientdata) {
5895 equiv = swig_module.types[i]->cast;
5896 while (equiv) {
5897 if (!equiv->converter) {
5898 if (equiv->type && !equiv->type->clientdata)
5899 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
5900 }
5901 equiv = equiv->next;
5902 }
5903 }
5904 }
5905 }
5906
5907 #ifdef __cplusplus
5908 #if 0
5909 {
5910 /* c-mode */
5911 #endif
5912 }
5913 #endif
5914
5915
5916
5917 #ifdef __cplusplus
5918 extern "C" {
5919 #endif
5920
5921 /* Python-specific SWIG API */
5922 #define SWIG_newvarlink() SWIG_Python_newvarlink()
5923 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
5924 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
5925
5926 /* -----------------------------------------------------------------------------
5927 * global variable support code.
5928 * ----------------------------------------------------------------------------- */
5929
5930 typedef struct swig_globalvar {
5931 char *name; /* Name of global variable */
5932 PyObject *(*get_attr)(void); /* Return the current value */
5933 int (*set_attr)(PyObject *); /* Set the value */
5934 struct swig_globalvar *next;
5935 } swig_globalvar;
5936
5937 typedef struct swig_varlinkobject {
5938 PyObject_HEAD
5939 swig_globalvar *vars;
5940 } swig_varlinkobject;
5941
5942 SWIGINTERN PyObject *
swig_varlink_repr(swig_varlinkobject * SWIGUNUSEDPARM (v))5943 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
5944 #if PY_VERSION_HEX >= 0x03000000
5945 return PyUnicode_InternFromString("<Swig global variables>");
5946 #else
5947 return PyString_FromString("<Swig global variables>");
5948 #endif
5949 }
5950
5951 SWIGINTERN PyObject *
swig_varlink_str(swig_varlinkobject * v)5952 swig_varlink_str(swig_varlinkobject *v) {
5953 #if PY_VERSION_HEX >= 0x03000000
5954 PyObject *str = PyUnicode_InternFromString("(");
5955 PyObject *tail;
5956 PyObject *joined;
5957 swig_globalvar *var;
5958 for (var = v->vars; var; var=var->next) {
5959 tail = PyUnicode_FromString(var->name);
5960 joined = PyUnicode_Concat(str, tail);
5961 Py_DecRef(str);
5962 Py_DecRef(tail);
5963 str = joined;
5964 if (var->next) {
5965 tail = PyUnicode_InternFromString(", ");
5966 joined = PyUnicode_Concat(str, tail);
5967 Py_DecRef(str);
5968 Py_DecRef(tail);
5969 str = joined;
5970 }
5971 }
5972 tail = PyUnicode_InternFromString(")");
5973 joined = PyUnicode_Concat(str, tail);
5974 Py_DecRef(str);
5975 Py_DecRef(tail);
5976 str = joined;
5977 #else
5978 PyObject *str = PyString_FromString("(");
5979 swig_globalvar *var;
5980 for (var = v->vars; var; var=var->next) {
5981 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
5982 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
5983 }
5984 PyString_ConcatAndDel(&str,PyString_FromString(")"));
5985 #endif
5986 return str;
5987 }
5988
5989 SWIGINTERN int
swig_varlink_print(swig_varlinkobject * v,FILE * fp,int SWIGUNUSEDPARM (flags))5990 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
5991 char *tmp;
5992 PyObject *str = swig_varlink_str(v);
5993 fprintf(fp,"Swig global variables ");
5994 fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
5995 SWIG_Python_str_DelForPy3(tmp);
5996 Py_DECREF(str);
5997 return 0;
5998 }
5999
6000 SWIGINTERN void
swig_varlink_dealloc(swig_varlinkobject * v)6001 swig_varlink_dealloc(swig_varlinkobject *v) {
6002 swig_globalvar *var = v->vars;
6003 while (var) {
6004 swig_globalvar *n = var->next;
6005 free(var->name);
6006 free(var);
6007 var = n;
6008 }
6009 }
6010
6011 SWIGINTERN PyObject *
swig_varlink_getattr(swig_varlinkobject * v,char * n)6012 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
6013 PyObject *res = NULL;
6014 swig_globalvar *var = v->vars;
6015 while (var) {
6016 if (strcmp(var->name,n) == 0) {
6017 res = (*var->get_attr)();
6018 break;
6019 }
6020 var = var->next;
6021 }
6022 if (res == NULL && !PyErr_Occurred()) {
6023 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6024 }
6025 return res;
6026 }
6027
6028 SWIGINTERN int
swig_varlink_setattr(swig_varlinkobject * v,char * n,PyObject * p)6029 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
6030 int res = 1;
6031 swig_globalvar *var = v->vars;
6032 while (var) {
6033 if (strcmp(var->name,n) == 0) {
6034 res = (*var->set_attr)(p);
6035 break;
6036 }
6037 var = var->next;
6038 }
6039 if (res == 1 && !PyErr_Occurred()) {
6040 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6041 }
6042 return res;
6043 }
6044
6045 SWIGINTERN PyTypeObject*
swig_varlink_type(void)6046 swig_varlink_type(void) {
6047 static char varlink__doc__[] = "Swig var link object";
6048 static PyTypeObject varlink_type;
6049 static int type_init = 0;
6050 if (!type_init) {
6051 const PyTypeObject tmp
6052 = {
6053 /* PyObject header changed in Python 3 */
6054 #if PY_VERSION_HEX >= 0x03000000
6055 PyVarObject_HEAD_INIT(&PyType_Type, 0)
6056 #else
6057 PyObject_HEAD_INIT(NULL)
6058 0, /* Number of items in variable part (ob_size) */
6059 #endif
6060 (char *)"swigvarlink", /* Type name (tp_name) */
6061 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
6062 0, /* Itemsize (tp_itemsize) */
6063 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
6064 (printfunc) swig_varlink_print, /* Print (tp_print) */
6065 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
6066 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
6067 0, /* tp_compare */
6068 (reprfunc) swig_varlink_repr, /* tp_repr */
6069 0, /* tp_as_number */
6070 0, /* tp_as_sequence */
6071 0, /* tp_as_mapping */
6072 0, /* tp_hash */
6073 0, /* tp_call */
6074 (reprfunc)swig_varlink_str, /* tp_str */
6075 0, /* tp_getattro */
6076 0, /* tp_setattro */
6077 0, /* tp_as_buffer */
6078 0, /* tp_flags */
6079 varlink__doc__, /* tp_doc */
6080 0, /* tp_traverse */
6081 0, /* tp_clear */
6082 0, /* tp_richcompare */
6083 0, /* tp_weaklistoffset */
6084 #if PY_VERSION_HEX >= 0x02020000
6085 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
6086 #endif
6087 #if PY_VERSION_HEX >= 0x02030000
6088 0, /* tp_del */
6089 #endif
6090 #ifdef COUNT_ALLOCS
6091 0,0,0,0 /* tp_alloc -> tp_next */
6092 #endif
6093 };
6094 varlink_type = tmp;
6095 /* for Python 3 we already assigned the ob_type in PyVarObject_HEAD_INIT() */
6096 #if PY_VERSION_HEX < 0x03000000
6097 varlink_type.ob_type = &PyType_Type;
6098 #endif
6099 type_init = 1;
6100 }
6101 return &varlink_type;
6102 }
6103
6104 /* Create a variable linking object for use later */
6105 SWIGINTERN PyObject *
SWIG_Python_newvarlink(void)6106 SWIG_Python_newvarlink(void) {
6107 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
6108 if (result) {
6109 result->vars = 0;
6110 }
6111 return ((PyObject*) result);
6112 }
6113
6114 SWIGINTERN void
SWIG_Python_addvarlink(PyObject * p,char * name,PyObject * (* get_attr)(void),int (* set_attr)(PyObject * p))6115 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
6116 swig_varlinkobject *v = (swig_varlinkobject *) p;
6117 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
6118 if (gv) {
6119 size_t size = strlen(name)+1;
6120 gv->name = (char *)malloc(size);
6121 if (gv->name) {
6122 strncpy(gv->name,name,size);
6123 gv->get_attr = get_attr;
6124 gv->set_attr = set_attr;
6125 gv->next = v->vars;
6126 }
6127 }
6128 v->vars = gv;
6129 }
6130
6131 SWIGINTERN PyObject *
SWIG_globals(void)6132 SWIG_globals(void) {
6133 static PyObject *_SWIG_globals = 0;
6134 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
6135 return _SWIG_globals;
6136 }
6137
6138 /* -----------------------------------------------------------------------------
6139 * constants/methods manipulation
6140 * ----------------------------------------------------------------------------- */
6141
6142 /* Install Constants */
6143 SWIGINTERN void
SWIG_Python_InstallConstants(PyObject * d,swig_const_info constants[])6144 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
6145 PyObject *obj = 0;
6146 size_t i;
6147 for (i = 0; constants[i].type; ++i) {
6148 switch(constants[i].type) {
6149 case SWIG_PY_POINTER:
6150 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
6151 break;
6152 case SWIG_PY_BINARY:
6153 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
6154 break;
6155 default:
6156 obj = 0;
6157 break;
6158 }
6159 if (obj) {
6160 PyDict_SetItemString(d, constants[i].name, obj);
6161 Py_DECREF(obj);
6162 }
6163 }
6164 }
6165
6166 /* -----------------------------------------------------------------------------*/
6167 /* Fix SwigMethods to carry the callback ptrs when needed */
6168 /* -----------------------------------------------------------------------------*/
6169
6170 SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef * methods,swig_const_info * const_table,swig_type_info ** types,swig_type_info ** types_initial)6171 SWIG_Python_FixMethods(PyMethodDef *methods,
6172 swig_const_info *const_table,
6173 swig_type_info **types,
6174 swig_type_info **types_initial) {
6175 size_t i;
6176 for (i = 0; methods[i].ml_name; ++i) {
6177 const char *c = methods[i].ml_doc;
6178 if (c && (c = strstr(c, "swig_ptr: "))) {
6179 int j;
6180 swig_const_info *ci = 0;
6181 const char *name = c + 10;
6182 for (j = 0; const_table[j].type; ++j) {
6183 if (strncmp(const_table[j].name, name,
6184 strlen(const_table[j].name)) == 0) {
6185 ci = &(const_table[j]);
6186 break;
6187 }
6188 }
6189 if (ci) {
6190 size_t shift = (ci->ptype) - types;
6191 swig_type_info *ty = types_initial[shift];
6192 size_t ldoc = (c - methods[i].ml_doc);
6193 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
6194 char *ndoc = (char*)malloc(ldoc + lptr + 10);
6195 if (ndoc) {
6196 char *buff = ndoc;
6197 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
6198 if (ptr) {
6199 strncpy(buff, methods[i].ml_doc, ldoc);
6200 buff += ldoc;
6201 strncpy(buff, "swig_ptr: ", 10);
6202 buff += 10;
6203 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
6204 methods[i].ml_doc = ndoc;
6205 }
6206 }
6207 }
6208 }
6209 }
6210 }
6211
6212 #ifdef __cplusplus
6213 }
6214 #endif
6215
6216 /* -----------------------------------------------------------------------------*
6217 * Partial Init method
6218 * -----------------------------------------------------------------------------*/
6219
6220 #ifdef __cplusplus
6221 extern "C"
6222 #endif
6223
6224 SWIGEXPORT
6225 #if PY_VERSION_HEX >= 0x03000000
6226 PyObject*
6227 #else
6228 void
6229 #endif
SWIG_init(void)6230 SWIG_init(void) {
6231 PyObject *m, *d;
6232 #if PY_VERSION_HEX >= 0x03000000
6233 static struct PyModuleDef SWIG_module = {
6234 PyModuleDef_HEAD_INIT,
6235 (char *) SWIG_name,
6236 NULL,
6237 -1,
6238 SwigMethods,
6239 NULL,
6240 NULL,
6241 NULL,
6242 NULL
6243 };
6244 #endif
6245
6246 /* Fix SwigMethods to carry the callback ptrs when needed */
6247 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
6248
6249 #if PY_VERSION_HEX >= 0x03000000
6250 m = PyModule_Create(&SWIG_module);
6251 #else
6252 m = Py_InitModule((char *) SWIG_name, SwigMethods);
6253 #endif
6254 d = PyModule_GetDict(m);
6255
6256 SWIG_InitializeModule(0);
6257 SWIG_InstallConstants(d,swig_const_table);
6258
6259
6260 #if PY_VERSION_HEX >= 0x03000000
6261 return m;
6262 #else
6263 return;
6264 #endif
6265 }
6266
6267