source: trunk/src/C++/pbs_wrap.cxx

Last change on this file was 344, checked in by bas, 7 years ago

removed printf basje from C++ trunk version, see #46

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