Back to index

nordugrid-arc-nox  1.1.0~rc6
arc_wrap.cpp
Go to the documentation of this file.
00001 /* ----------------------------------------------------------------------------
00002  * This file was automatically generated by SWIG (http://www.swig.org).
00003  * Version 1.3.36
00004  * 
00005  * This file is not intended to be easily readable and contains a number of 
00006  * coding conventions designed to improve portability and efficiency. Do not make
00007  * changes to this file unless you know what you are doing--modify the SWIG 
00008  * interface file instead. 
00009  * ----------------------------------------------------------------------------- */
00010 
00011 #define SWIGPYTHON
00012 #define SWIG_PYTHON_THREADS
00013 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
00014 
00015 #ifdef __cplusplus
00016 template<typename T> class SwigValueWrapper {
00017     T *tt;
00018 public:
00019     SwigValueWrapper() : tt(0) { }
00020     SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
00021     SwigValueWrapper(const T& t) : tt(new T(t)) { }
00022     ~SwigValueWrapper() { delete tt; } 
00023     SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
00024     operator T&() const { return *tt; }
00025     T *operator&() { return tt; }
00026 private:
00027     SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
00028 };
00029 
00030 template <typename T> T SwigValueInit() {
00031   return T();
00032 }
00033 #endif
00034 
00035 /* -----------------------------------------------------------------------------
00036  *  This section contains generic SWIG labels for method/variable
00037  *  declarations/attributes, and other compiler dependent labels.
00038  * ----------------------------------------------------------------------------- */
00039 
00040 /* template workaround for compilers that cannot correctly implement the C++ standard */
00041 #ifndef SWIGTEMPLATEDISAMBIGUATOR
00042 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
00043 #  define SWIGTEMPLATEDISAMBIGUATOR template
00044 # elif defined(__HP_aCC)
00045 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
00046 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
00047 #  define SWIGTEMPLATEDISAMBIGUATOR template
00048 # else
00049 #  define SWIGTEMPLATEDISAMBIGUATOR
00050 # endif
00051 #endif
00052 
00053 /* inline attribute */
00054 #ifndef SWIGINLINE
00055 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
00056 #   define SWIGINLINE inline
00057 # else
00058 #   define SWIGINLINE
00059 # endif
00060 #endif
00061 
00062 /* attribute recognised by some compilers to avoid 'unused' warnings */
00063 #ifndef SWIGUNUSED
00064 # if defined(__GNUC__)
00065 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
00066 #     define SWIGUNUSED __attribute__ ((__unused__)) 
00067 #   else
00068 #     define SWIGUNUSED
00069 #   endif
00070 # elif defined(__ICC)
00071 #   define SWIGUNUSED __attribute__ ((__unused__)) 
00072 # else
00073 #   define SWIGUNUSED 
00074 # endif
00075 #endif
00076 
00077 #ifndef SWIG_MSC_UNSUPPRESS_4505
00078 # if defined(_MSC_VER)
00079 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
00080 # endif 
00081 #endif
00082 
00083 #ifndef SWIGUNUSEDPARM
00084 # ifdef __cplusplus
00085 #   define SWIGUNUSEDPARM(p)
00086 # else
00087 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
00088 # endif
00089 #endif
00090 
00091 /* internal SWIG method */
00092 #ifndef SWIGINTERN
00093 # define SWIGINTERN static SWIGUNUSED
00094 #endif
00095 
00096 /* internal inline SWIG method */
00097 #ifndef SWIGINTERNINLINE
00098 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00099 #endif
00100 
00101 /* exporting methods */
00102 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
00103 #  ifndef GCC_HASCLASSVISIBILITY
00104 #    define GCC_HASCLASSVISIBILITY
00105 #  endif
00106 #endif
00107 
00108 #ifndef SWIGEXPORT
00109 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00110 #   if defined(STATIC_LINKED)
00111 #     define SWIGEXPORT
00112 #   else
00113 #     define SWIGEXPORT __declspec(dllexport)
00114 #   endif
00115 # else
00116 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
00117 #     define SWIGEXPORT __attribute__ ((visibility("default")))
00118 #   else
00119 #     define SWIGEXPORT
00120 #   endif
00121 # endif
00122 #endif
00123 
00124 /* calling conventions for Windows */
00125 #ifndef SWIGSTDCALL
00126 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00127 #   define SWIGSTDCALL __stdcall
00128 # else
00129 #   define SWIGSTDCALL
00130 # endif 
00131 #endif
00132 
00133 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
00134 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
00135 # define _CRT_SECURE_NO_DEPRECATE
00136 #endif
00137 
00138 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
00139 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
00140 # define _SCL_SECURE_NO_DEPRECATE
00141 #endif
00142 
00143 
00144 
00145 /* Python.h has to appear first */
00146 #include <Python.h>
00147 
00148 /* -----------------------------------------------------------------------------
00149  * swigrun.swg
00150  *
00151  * This file contains generic CAPI SWIG runtime support for pointer
00152  * type checking.
00153  * ----------------------------------------------------------------------------- */
00154 
00155 /* This should only be incremented when either the layout of swig_type_info changes,
00156    or for whatever reason, the runtime changes incompatibly */
00157 #define SWIG_RUNTIME_VERSION "4"
00158 
00159 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
00160 #ifdef SWIG_TYPE_TABLE
00161 # define SWIG_QUOTE_STRING(x) #x
00162 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
00163 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
00164 #else
00165 # define SWIG_TYPE_TABLE_NAME
00166 #endif
00167 
00168 /*
00169   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
00170   creating a static or dynamic library from the swig runtime code.
00171   In 99.9% of the cases, swig just needs to declare them as 'static'.
00172   
00173   But only do this if is strictly necessary, ie, if you have problems
00174   with your compiler or so.
00175 */
00176 
00177 #ifndef SWIGRUNTIME
00178 # define SWIGRUNTIME SWIGINTERN
00179 #endif
00180 
00181 #ifndef SWIGRUNTIMEINLINE
00182 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
00183 #endif
00184 
00185 /*  Generic buffer size */
00186 #ifndef SWIG_BUFFER_SIZE
00187 # define SWIG_BUFFER_SIZE 1024
00188 #endif
00189 
00190 /* Flags for pointer conversions */
00191 #define SWIG_POINTER_DISOWN        0x1
00192 #define SWIG_CAST_NEW_MEMORY       0x2
00193 
00194 /* Flags for new pointer objects */
00195 #define SWIG_POINTER_OWN           0x1
00196 
00197 
00198 /* 
00199    Flags/methods for returning states.
00200    
00201    The swig conversion methods, as ConvertPtr, return and integer 
00202    that tells if the conversion was successful or not. And if not,
00203    an error code can be returned (see swigerrors.swg for the codes).
00204    
00205    Use the following macros/flags to set or process the returning
00206    states.
00207    
00208    In old swig versions, you usually write code as:
00209 
00210      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
00211        // success code
00212      } else {
00213        //fail code
00214      }
00215 
00216    Now you can be more explicit as:
00217 
00218     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
00219     if (SWIG_IsOK(res)) {
00220       // success code
00221     } else {
00222       // fail code
00223     }
00224 
00225    that seems to be the same, but now you can also do
00226 
00227     Type *ptr;
00228     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
00229     if (SWIG_IsOK(res)) {
00230       // success code
00231       if (SWIG_IsNewObj(res) {
00232         ...
00233        delete *ptr;
00234       } else {
00235         ...
00236       }
00237     } else {
00238       // fail code
00239     }
00240     
00241    I.e., now SWIG_ConvertPtr can return new objects and you can
00242    identify the case and take care of the deallocation. Of course that
00243    requires also to SWIG_ConvertPtr to return new result values, as
00244 
00245       int SWIG_ConvertPtr(obj, ptr,...) {         
00246         if (<obj is ok>) {                       
00247           if (<need new object>) {               
00248             *ptr = <ptr to new allocated object>; 
00249             return SWIG_NEWOBJ;                  
00250           } else {                               
00251             *ptr = <ptr to old object>;          
00252             return SWIG_OLDOBJ;                  
00253           }                               
00254         } else {                                 
00255           return SWIG_BADOBJ;                    
00256         }                                        
00257       }
00258 
00259    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
00260    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
00261    swig errors code.
00262 
00263    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
00264    allows to return the 'cast rank', for example, if you have this
00265 
00266        int food(double)
00267        int fooi(int);
00268 
00269    and you call
00270  
00271       food(1)   // cast rank '1'  (1 -> 1.0)
00272       fooi(1)   // cast rank '0'
00273 
00274    just use the SWIG_AddCast()/SWIG_CheckState()
00275 
00276 
00277  */
00278 #define SWIG_OK                    (0) 
00279 #define SWIG_ERROR                 (-1)
00280 #define SWIG_IsOK(r)               (r >= 0)
00281 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
00282 
00283 /* The CastRankLimit says how many bits are used for the cast rank */
00284 #define SWIG_CASTRANKLIMIT         (1 << 8)
00285 /* The NewMask denotes the object was created (using new/malloc) */
00286 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
00287 /* The TmpMask is for in/out typemaps that use temporal objects */
00288 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
00289 /* Simple returning values */
00290 #define SWIG_BADOBJ                (SWIG_ERROR)
00291 #define SWIG_OLDOBJ                (SWIG_OK)
00292 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
00293 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
00294 /* Check, add and del mask methods */
00295 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
00296 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
00297 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
00298 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
00299 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
00300 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
00301 
00302 
00303 /* Cast-Rank Mode */
00304 #if defined(SWIG_CASTRANK_MODE)
00305 #  ifndef SWIG_TypeRank
00306 #    define SWIG_TypeRank             unsigned long
00307 #  endif
00308 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
00309 #    define SWIG_MAXCASTRANK          (2)
00310 #  endif
00311 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
00312 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
00313 SWIGINTERNINLINE int SWIG_AddCast(int r) { 
00314   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
00315 }
00316 SWIGINTERNINLINE int SWIG_CheckState(int r) { 
00317   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
00318 }
00319 #else /* no cast-rank mode */
00320 #  define SWIG_AddCast
00321 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
00322 #endif
00323 
00324 
00325 
00326 
00327 #include <string.h>
00328 
00329 #ifdef __cplusplus
00330 extern "C" {
00331 #endif
00332 
00333 typedef void *(*swig_converter_func)(void *, int *);
00334 typedef struct swig_type_info *(*swig_dycast_func)(void **);
00335 
00336 /* Structure to store information on one type */
00337 typedef struct swig_type_info {
00338   const char             *name;                  /* mangled name of this type */
00339   const char             *str;                   /* human readable name of this type */
00340   swig_dycast_func        dcast;          /* dynamic cast function down a hierarchy */
00341   struct swig_cast_info  *cast;                  /* linked list of types that can cast into this type */
00342   void                   *clientdata;            /* language specific type data */
00343   int                    owndata;         /* flag if the structure owns the clientdata */
00344 } swig_type_info;
00345 
00346 /* Structure to store a type and conversion function used for casting */
00347 typedef struct swig_cast_info {
00348   swig_type_info         *type;                  /* pointer to type that is equivalent to this type */
00349   swig_converter_func     converter;             /* function to cast the void pointers */
00350   struct swig_cast_info  *next;                  /* pointer to next cast in linked list */
00351   struct swig_cast_info  *prev;                  /* pointer to the previous cast */
00352 } swig_cast_info;
00353 
00354 /* Structure used to store module information
00355  * Each module generates one structure like this, and the runtime collects
00356  * all of these structures and stores them in a circularly linked list.*/
00357 typedef struct swig_module_info {
00358   swig_type_info         **types;         /* Array of pointers to swig_type_info structures that are in this module */
00359   size_t                 size;                    /* Number of types in this module */
00360   struct swig_module_info *next;          /* Pointer to next element in circularly linked list */
00361   swig_type_info         **type_initial;  /* Array of initially generated type structures */
00362   swig_cast_info         **cast_initial;  /* Array of initially generated casting structures */
00363   void                    *clientdata;           /* Language specific module data */
00364 } swig_module_info;
00365 
00366 /* 
00367   Compare two type names skipping the space characters, therefore
00368   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
00369 
00370   Return 0 when the two name types are equivalent, as in
00371   strncmp, but skipping ' '.
00372 */
00373 SWIGRUNTIME int
00374 SWIG_TypeNameComp(const char *f1, const char *l1,
00375                 const char *f2, const char *l2) {
00376   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
00377     while ((*f1 == ' ') && (f1 != l1)) ++f1;
00378     while ((*f2 == ' ') && (f2 != l2)) ++f2;
00379     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
00380   }
00381   return (int)((l1 - f1) - (l2 - f2));
00382 }
00383 
00384 /*
00385   Check type equivalence in a name list like <name1>|<name2>|...
00386   Return 0 if not equal, 1 if equal
00387 */
00388 SWIGRUNTIME int
00389 SWIG_TypeEquiv(const char *nb, const char *tb) {
00390   int equiv = 0;
00391   const char* te = tb + strlen(tb);
00392   const char* ne = nb;
00393   while (!equiv && *ne) {
00394     for (nb = ne; *ne; ++ne) {
00395       if (*ne == '|') break;
00396     }
00397     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00398     if (*ne) ++ne;
00399   }
00400   return equiv;
00401 }
00402 
00403 /*
00404   Check type equivalence in a name list like <name1>|<name2>|...
00405   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
00406 */
00407 SWIGRUNTIME int
00408 SWIG_TypeCompare(const char *nb, const char *tb) {
00409   int equiv = 0;
00410   const char* te = tb + strlen(tb);
00411   const char* ne = nb;
00412   while (!equiv && *ne) {
00413     for (nb = ne; *ne; ++ne) {
00414       if (*ne == '|') break;
00415     }
00416     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00417     if (*ne) ++ne;
00418   }
00419   return equiv;
00420 }
00421 
00422 
00423 /* think of this as a c++ template<> or a scheme macro */
00424 #define SWIG_TypeCheck_Template(comparison, ty)         \
00425   if (ty) {                                             \
00426     swig_cast_info *iter = ty->cast;                    \
00427     while (iter) {                                      \
00428       if (comparison) {                                 \
00429         if (iter == ty->cast) return iter;              \
00430         /* Move iter to the top of the linked list */   \
00431         iter->prev->next = iter->next;                  \
00432         if (iter->next)                                 \
00433           iter->next->prev = iter->prev;                \
00434         iter->next = ty->cast;                          \
00435         iter->prev = 0;                                 \
00436         if (ty->cast) ty->cast->prev = iter;            \
00437         ty->cast = iter;                                \
00438         return iter;                                    \
00439       }                                                 \
00440       iter = iter->next;                                \
00441     }                                                   \
00442   }                                                     \
00443   return 0
00444 
00445 /*
00446   Check the typename
00447 */
00448 SWIGRUNTIME swig_cast_info *
00449 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
00450   SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
00451 }
00452 
00453 /* Same as previous function, except strcmp is replaced with a pointer comparison */
00454 SWIGRUNTIME swig_cast_info *
00455 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
00456   SWIG_TypeCheck_Template(iter->type == from, into);
00457 }
00458 
00459 /*
00460   Cast a pointer up an inheritance hierarchy
00461 */
00462 SWIGRUNTIMEINLINE void *
00463 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
00464   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
00465 }
00466 
00467 /* 
00468    Dynamic pointer casting. Down an inheritance hierarchy
00469 */
00470 SWIGRUNTIME swig_type_info *
00471 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
00472   swig_type_info *lastty = ty;
00473   if (!ty || !ty->dcast) return ty;
00474   while (ty && (ty->dcast)) {
00475     ty = (*ty->dcast)(ptr);
00476     if (ty) lastty = ty;
00477   }
00478   return lastty;
00479 }
00480 
00481 /*
00482   Return the name associated with this type
00483 */
00484 SWIGRUNTIMEINLINE const char *
00485 SWIG_TypeName(const swig_type_info *ty) {
00486   return ty->name;
00487 }
00488 
00489 /*
00490   Return the pretty name associated with this type,
00491   that is an unmangled type name in a form presentable to the user.
00492 */
00493 SWIGRUNTIME const char *
00494 SWIG_TypePrettyName(const swig_type_info *type) {
00495   /* The "str" field contains the equivalent pretty names of the
00496      type, separated by vertical-bar characters.  We choose
00497      to print the last name, as it is often (?) the most
00498      specific. */
00499   if (!type) return NULL;
00500   if (type->str != NULL) {
00501     const char *last_name = type->str;
00502     const char *s;
00503     for (s = type->str; *s; s++)
00504       if (*s == '|') last_name = s+1;
00505     return last_name;
00506   }
00507   else
00508     return type->name;
00509 }
00510 
00511 /* 
00512    Set the clientdata field for a type
00513 */
00514 SWIGRUNTIME void
00515 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
00516   swig_cast_info *cast = ti->cast;
00517   /* if (ti->clientdata == clientdata) return; */
00518   ti->clientdata = clientdata;
00519   
00520   while (cast) {
00521     if (!cast->converter) {
00522       swig_type_info *tc = cast->type;
00523       if (!tc->clientdata) {
00524        SWIG_TypeClientData(tc, clientdata);
00525       }
00526     }    
00527     cast = cast->next;
00528   }
00529 }
00530 SWIGRUNTIME void
00531 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
00532   SWIG_TypeClientData(ti, clientdata);
00533   ti->owndata = 1;
00534 }
00535   
00536 /*
00537   Search for a swig_type_info structure only by mangled name
00538   Search is a O(log #types)
00539   
00540   We start searching at module start, and finish searching when start == end.  
00541   Note: if start == end at the beginning of the function, we go all the way around
00542   the circular list.
00543 */
00544 SWIGRUNTIME swig_type_info *
00545 SWIG_MangledTypeQueryModule(swig_module_info *start, 
00546                             swig_module_info *end, 
00547                           const char *name) {
00548   swig_module_info *iter = start;
00549   do {
00550     if (iter->size) {
00551       register size_t l = 0;
00552       register size_t r = iter->size - 1;
00553       do {
00554        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
00555        register size_t i = (l + r) >> 1; 
00556        const char *iname = iter->types[i]->name;
00557        if (iname) {
00558          register int compare = strcmp(name, iname);
00559          if (compare == 0) {           
00560            return iter->types[i];
00561          } else if (compare < 0) {
00562            if (i) {
00563              r = i - 1;
00564            } else {
00565              break;
00566            }
00567          } else if (compare > 0) {
00568            l = i + 1;
00569          }
00570        } else {
00571          break; /* should never happen */
00572        }
00573       } while (l <= r);
00574     }
00575     iter = iter->next;
00576   } while (iter != end);
00577   return 0;
00578 }
00579 
00580 /*
00581   Search for a swig_type_info structure for either a mangled name or a human readable name.
00582   It first searches the mangled names of the types, which is a O(log #types)
00583   If a type is not found it then searches the human readable names, which is O(#types).
00584   
00585   We start searching at module start, and finish searching when start == end.  
00586   Note: if start == end at the beginning of the function, we go all the way around
00587   the circular list.
00588 */
00589 SWIGRUNTIME swig_type_info *
00590 SWIG_TypeQueryModule(swig_module_info *start, 
00591                      swig_module_info *end, 
00592                    const char *name) {
00593   /* STEP 1: Search the name field using binary search */
00594   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
00595   if (ret) {
00596     return ret;
00597   } else {
00598     /* STEP 2: If the type hasn't been found, do a complete search
00599        of the str field (the human readable name) */
00600     swig_module_info *iter = start;
00601     do {
00602       register size_t i = 0;
00603       for (; i < iter->size; ++i) {
00604        if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
00605          return iter->types[i];
00606       }
00607       iter = iter->next;
00608     } while (iter != end);
00609   }
00610   
00611   /* neither found a match */
00612   return 0;
00613 }
00614 
00615 /* 
00616    Pack binary data into a string
00617 */
00618 SWIGRUNTIME char *
00619 SWIG_PackData(char *c, void *ptr, size_t sz) {
00620   static const char hex[17] = "0123456789abcdef";
00621   register const unsigned char *u = (unsigned char *) ptr;
00622   register const unsigned char *eu =  u + sz;
00623   for (; u != eu; ++u) {
00624     register unsigned char uu = *u;
00625     *(c++) = hex[(uu & 0xf0) >> 4];
00626     *(c++) = hex[uu & 0xf];
00627   }
00628   return c;
00629 }
00630 
00631 /* 
00632    Unpack binary data from a string
00633 */
00634 SWIGRUNTIME const char *
00635 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
00636   register unsigned char *u = (unsigned char *) ptr;
00637   register const unsigned char *eu = u + sz;
00638   for (; u != eu; ++u) {
00639     register char d = *(c++);
00640     register unsigned char uu;
00641     if ((d >= '0') && (d <= '9'))
00642       uu = ((d - '0') << 4);
00643     else if ((d >= 'a') && (d <= 'f'))
00644       uu = ((d - ('a'-10)) << 4);
00645     else 
00646       return (char *) 0;
00647     d = *(c++);
00648     if ((d >= '0') && (d <= '9'))
00649       uu |= (d - '0');
00650     else if ((d >= 'a') && (d <= 'f'))
00651       uu |= (d - ('a'-10));
00652     else 
00653       return (char *) 0;
00654     *u = uu;
00655   }
00656   return c;
00657 }
00658 
00659 /* 
00660    Pack 'void *' into a string buffer.
00661 */
00662 SWIGRUNTIME char *
00663 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
00664   char *r = buff;
00665   if ((2*sizeof(void *) + 2) > bsz) return 0;
00666   *(r++) = '_';
00667   r = SWIG_PackData(r,&ptr,sizeof(void *));
00668   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
00669   strcpy(r,name);
00670   return buff;
00671 }
00672 
00673 SWIGRUNTIME const char *
00674 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
00675   if (*c != '_') {
00676     if (strcmp(c,"NULL") == 0) {
00677       *ptr = (void *) 0;
00678       return name;
00679     } else {
00680       return 0;
00681     }
00682   }
00683   return SWIG_UnpackData(++c,ptr,sizeof(void *));
00684 }
00685 
00686 SWIGRUNTIME char *
00687 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
00688   char *r = buff;
00689   size_t lname = (name ? strlen(name) : 0);
00690   if ((2*sz + 2 + lname) > bsz) return 0;
00691   *(r++) = '_';
00692   r = SWIG_PackData(r,ptr,sz);
00693   if (lname) {
00694     strncpy(r,name,lname+1);
00695   } else {
00696     *r = 0;
00697   }
00698   return buff;
00699 }
00700 
00701 SWIGRUNTIME const char *
00702 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
00703   if (*c != '_') {
00704     if (strcmp(c,"NULL") == 0) {
00705       memset(ptr,0,sz);
00706       return name;
00707     } else {
00708       return 0;
00709     }
00710   }
00711   return SWIG_UnpackData(++c,ptr,sz);
00712 }
00713 
00714 #ifdef __cplusplus
00715 }
00716 #endif
00717 
00718 /*  Errors in SWIG */
00719 #define  SWIG_UnknownError            -1 
00720 #define  SWIG_IOError                 -2 
00721 #define  SWIG_RuntimeError            -3 
00722 #define  SWIG_IndexError              -4 
00723 #define  SWIG_TypeError               -5 
00724 #define  SWIG_DivisionByZero          -6 
00725 #define  SWIG_OverflowError           -7 
00726 #define  SWIG_SyntaxError             -8 
00727 #define  SWIG_ValueError              -9 
00728 #define  SWIG_SystemError             -10
00729 #define  SWIG_AttributeError          -11
00730 #define  SWIG_MemoryError             -12 
00731 #define  SWIG_NullReferenceError   -13
00732 
00733 
00734 
00735 
00736 /* Add PyOS_snprintf for old Pythons */
00737 #if PY_VERSION_HEX < 0x02020000
00738 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
00739 #  define PyOS_snprintf _snprintf
00740 # else
00741 #  define PyOS_snprintf snprintf
00742 # endif
00743 #endif
00744 
00745 /* A crude PyString_FromFormat implementation for old Pythons */
00746 #if PY_VERSION_HEX < 0x02020000
00747 
00748 #ifndef SWIG_PYBUFFER_SIZE
00749 # define SWIG_PYBUFFER_SIZE 1024
00750 #endif
00751 
00752 static PyObject *
00753 PyString_FromFormat(const char *fmt, ...) {
00754   va_list ap;
00755   char buf[SWIG_PYBUFFER_SIZE * 2];
00756   int res;
00757   va_start(ap, fmt);
00758   res = vsnprintf(buf, sizeof(buf), fmt, ap);
00759   va_end(ap);
00760   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
00761 }
00762 #endif
00763 
00764 /* Add PyObject_Del for old Pythons */
00765 #if PY_VERSION_HEX < 0x01060000
00766 # define PyObject_Del(op) PyMem_DEL((op))
00767 #endif
00768 #ifndef PyObject_DEL
00769 # define PyObject_DEL PyObject_Del
00770 #endif
00771 
00772 /* A crude PyExc_StopIteration exception for old Pythons */
00773 #if PY_VERSION_HEX < 0x02020000
00774 # ifndef PyExc_StopIteration
00775 #  define PyExc_StopIteration PyExc_RuntimeError
00776 # endif
00777 # ifndef PyObject_GenericGetAttr
00778 #  define PyObject_GenericGetAttr 0
00779 # endif
00780 #endif
00781 /* Py_NotImplemented is defined in 2.1 and up. */
00782 #if PY_VERSION_HEX < 0x02010000
00783 # ifndef Py_NotImplemented
00784 #  define Py_NotImplemented PyExc_RuntimeError
00785 # endif
00786 #endif
00787 
00788 
00789 /* A crude PyString_AsStringAndSize implementation for old Pythons */
00790 #if PY_VERSION_HEX < 0x02010000
00791 # ifndef PyString_AsStringAndSize
00792 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
00793 # endif
00794 #endif
00795 
00796 /* PySequence_Size for old Pythons */
00797 #if PY_VERSION_HEX < 0x02000000
00798 # ifndef PySequence_Size
00799 #  define PySequence_Size PySequence_Length
00800 # endif
00801 #endif
00802 
00803 
00804 /* PyBool_FromLong for old Pythons */
00805 #if PY_VERSION_HEX < 0x02030000
00806 static
00807 PyObject *PyBool_FromLong(long ok)
00808 {
00809   PyObject *result = ok ? Py_True : Py_False;
00810   Py_INCREF(result);
00811   return result;
00812 }
00813 #endif
00814 
00815 /* Py_ssize_t for old Pythons */
00816 /* This code is as recommended by: */
00817 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
00818 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
00819 typedef int Py_ssize_t;
00820 # define PY_SSIZE_T_MAX INT_MAX
00821 # define PY_SSIZE_T_MIN INT_MIN
00822 #endif
00823 
00824 /* -----------------------------------------------------------------------------
00825  * error manipulation
00826  * ----------------------------------------------------------------------------- */
00827 
00828 SWIGRUNTIME PyObject*
00829 SWIG_Python_ErrorType(int code) {
00830   PyObject* type = 0;
00831   switch(code) {
00832   case SWIG_MemoryError:
00833     type = PyExc_MemoryError;
00834     break;
00835   case SWIG_IOError:
00836     type = PyExc_IOError;
00837     break;
00838   case SWIG_RuntimeError:
00839     type = PyExc_RuntimeError;
00840     break;
00841   case SWIG_IndexError:
00842     type = PyExc_IndexError;
00843     break;
00844   case SWIG_TypeError:
00845     type = PyExc_TypeError;
00846     break;
00847   case SWIG_DivisionByZero:
00848     type = PyExc_ZeroDivisionError;
00849     break;
00850   case SWIG_OverflowError:
00851     type = PyExc_OverflowError;
00852     break;
00853   case SWIG_SyntaxError:
00854     type = PyExc_SyntaxError;
00855     break;
00856   case SWIG_ValueError:
00857     type = PyExc_ValueError;
00858     break;
00859   case SWIG_SystemError:
00860     type = PyExc_SystemError;
00861     break;
00862   case SWIG_AttributeError:
00863     type = PyExc_AttributeError;
00864     break;
00865   default:
00866     type = PyExc_RuntimeError;
00867   }
00868   return type;
00869 }
00870 
00871 
00872 SWIGRUNTIME void
00873 SWIG_Python_AddErrorMsg(const char* mesg)
00874 {
00875   PyObject *type = 0;
00876   PyObject *value = 0;
00877   PyObject *traceback = 0;
00878 
00879   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
00880   if (value) {
00881     PyObject *old_str = PyObject_Str(value);
00882     PyErr_Clear();
00883     Py_XINCREF(type);
00884     PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
00885     Py_DECREF(old_str);
00886     Py_DECREF(value);
00887   } else {
00888     PyErr_SetString(PyExc_RuntimeError, mesg);
00889   }
00890 }
00891 
00892 
00893 
00894 #if defined(SWIG_PYTHON_NO_THREADS)
00895 #  if defined(SWIG_PYTHON_THREADS)
00896 #    undef SWIG_PYTHON_THREADS
00897 #  endif
00898 #endif
00899 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
00900 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
00901 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
00902 #      define SWIG_PYTHON_USE_GIL
00903 #    endif
00904 #  endif
00905 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
00906 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
00907 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
00908 #    endif
00909 #    ifdef __cplusplus /* C++ code */
00910        class SWIG_Python_Thread_Block {
00911          bool status;
00912          PyGILState_STATE state;
00913        public:
00914          void end() { if (status) { PyGILState_Release(state); status = false;} }
00915          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
00916          ~SWIG_Python_Thread_Block() { end(); }
00917        };
00918        class SWIG_Python_Thread_Allow {
00919          bool status;
00920          PyThreadState *save;
00921        public:
00922          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
00923          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
00924          ~SWIG_Python_Thread_Allow() { end(); }
00925        };
00926 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
00927 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
00928 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
00929 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
00930 #    else /* C code */
00931 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
00932 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
00933 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
00934 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
00935 #    endif
00936 #  else /* Old thread way, not implemented, user must provide it */
00937 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
00938 #      define SWIG_PYTHON_INITIALIZE_THREADS
00939 #    endif
00940 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
00941 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
00942 #    endif
00943 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
00944 #      define SWIG_PYTHON_THREAD_END_BLOCK
00945 #    endif
00946 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
00947 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
00948 #    endif
00949 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
00950 #      define SWIG_PYTHON_THREAD_END_ALLOW
00951 #    endif
00952 #  endif
00953 #else /* No thread support */
00954 #  define SWIG_PYTHON_INITIALIZE_THREADS
00955 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
00956 #  define SWIG_PYTHON_THREAD_END_BLOCK
00957 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
00958 #  define SWIG_PYTHON_THREAD_END_ALLOW
00959 #endif
00960 
00961 /* -----------------------------------------------------------------------------
00962  * Python API portion that goes into the runtime
00963  * ----------------------------------------------------------------------------- */
00964 
00965 #ifdef __cplusplus
00966 extern "C" {
00967 #if 0
00968 } /* cc-mode */
00969 #endif
00970 #endif
00971 
00972 /* -----------------------------------------------------------------------------
00973  * Constant declarations
00974  * ----------------------------------------------------------------------------- */
00975 
00976 /* Constant Types */
00977 #define SWIG_PY_POINTER 4
00978 #define SWIG_PY_BINARY  5
00979 
00980 /* Constant information structure */
00981 typedef struct swig_const_info {
00982   int type;
00983   char *name;
00984   long lvalue;
00985   double dvalue;
00986   void   *pvalue;
00987   swig_type_info **ptype;
00988 } swig_const_info;
00989 
00990 #ifdef __cplusplus
00991 #if 0
00992 { /* cc-mode */
00993 #endif
00994 }
00995 #endif
00996 
00997 
00998 /* -----------------------------------------------------------------------------
00999  * See the LICENSE file for information on copyright, usage and redistribution
01000  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
01001  *
01002  * pyrun.swg
01003  *
01004  * This file contains the runtime support for Python modules
01005  * and includes code for managing global variables and pointer
01006  * type checking.
01007  *
01008  * ----------------------------------------------------------------------------- */
01009 
01010 /* Common SWIG API */
01011 
01012 /* for raw pointers */
01013 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
01014 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
01015 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
01016 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
01017 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
01018 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
01019 #define swig_owntype                                    int
01020 
01021 /* for raw packed data */
01022 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
01023 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
01024 
01025 /* for class or struct pointers */
01026 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
01027 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
01028 
01029 /* for C or C++ function pointers */
01030 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
01031 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
01032 
01033 /* for C++ member pointers, ie, member methods */
01034 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
01035 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
01036 
01037 
01038 /* Runtime API */
01039 
01040 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
01041 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
01042 #define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
01043 
01044 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
01045 #define SWIG_SetErrorMsg                         SWIG_Python_SetErrorMsg                             
01046 #define SWIG_ErrorType(code)                     SWIG_Python_ErrorType(code)                        
01047 #define SWIG_Error(code, msg)                    SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
01048 #define SWIG_fail                                goto fail                                    
01049 
01050 
01051 /* Runtime API implementation */
01052 
01053 /* Error manipulation */
01054 
01055 SWIGINTERN void 
01056 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
01057   SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
01058   PyErr_SetObject(errtype, obj);
01059   Py_DECREF(obj);
01060   SWIG_PYTHON_THREAD_END_BLOCK;
01061 }
01062 
01063 SWIGINTERN void 
01064 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
01065   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
01066   PyErr_SetString(errtype, (char *) msg);
01067   SWIG_PYTHON_THREAD_END_BLOCK;
01068 }
01069 
01070 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
01071 
01072 /* Set a constant value */
01073 
01074 SWIGINTERN void
01075 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
01076   PyDict_SetItemString(d, (char*) name, obj);
01077   Py_DECREF(obj);                            
01078 }
01079 
01080 /* Append a value to the result obj */
01081 
01082 SWIGINTERN PyObject*
01083 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
01084 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
01085   if (!result) {
01086     result = obj;
01087   } else if (result == Py_None) {
01088     Py_DECREF(result);
01089     result = obj;
01090   } else {
01091     if (!PyList_Check(result)) {
01092       PyObject *o2 = result;
01093       result = PyList_New(1);
01094       PyList_SetItem(result, 0, o2);
01095     }
01096     PyList_Append(result,obj);
01097     Py_DECREF(obj);
01098   }
01099   return result;
01100 #else
01101   PyObject*   o2;
01102   PyObject*   o3;
01103   if (!result) {
01104     result = obj;
01105   } else if (result == Py_None) {
01106     Py_DECREF(result);
01107     result = obj;
01108   } else {
01109     if (!PyTuple_Check(result)) {
01110       o2 = result;
01111       result = PyTuple_New(1);
01112       PyTuple_SET_ITEM(result, 0, o2);
01113     }
01114     o3 = PyTuple_New(1);
01115     PyTuple_SET_ITEM(o3, 0, obj);
01116     o2 = result;
01117     result = PySequence_Concat(o2, o3);
01118     Py_DECREF(o2);
01119     Py_DECREF(o3);
01120   }
01121   return result;
01122 #endif
01123 }
01124 
01125 /* Unpack the argument tuple */
01126 
01127 SWIGINTERN int
01128 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
01129 {
01130   if (!args) {
01131     if (!min && !max) {
01132       return 1;
01133     } else {
01134       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
01135                  name, (min == max ? "" : "at least "), (int)min);
01136       return 0;
01137     }
01138   }  
01139   if (!PyTuple_Check(args)) {
01140     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
01141     return 0;
01142   } else {
01143     register Py_ssize_t l = PyTuple_GET_SIZE(args);
01144     if (l < min) {
01145       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
01146                  name, (min == max ? "" : "at least "), (int)min, (int)l);
01147       return 0;
01148     } else if (l > max) {
01149       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
01150                  name, (min == max ? "" : "at most "), (int)max, (int)l);
01151       return 0;
01152     } else {
01153       register int i;
01154       for (i = 0; i < l; ++i) {
01155        objs[i] = PyTuple_GET_ITEM(args, i);
01156       }
01157       for (; l < max; ++l) {
01158        objs[l] = 0;
01159       }
01160       return i + 1;
01161     }    
01162   }
01163 }
01164 
01165 /* A functor is a function object with one single object argument */
01166 #if PY_VERSION_HEX >= 0x02020000
01167 #define SWIG_Python_CallFunctor(functor, obj)            PyObject_CallFunctionObjArgs(functor, obj, NULL);
01168 #else
01169 #define SWIG_Python_CallFunctor(functor, obj)            PyObject_CallFunction(functor, "O", obj);
01170 #endif
01171 
01172 /*
01173   Helper for static pointer initialization for both C and C++ code, for example
01174   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
01175 */
01176 #ifdef __cplusplus
01177 #define SWIG_STATIC_POINTER(var)  var
01178 #else
01179 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
01180 #endif
01181 
01182 /* -----------------------------------------------------------------------------
01183  * Pointer declarations
01184  * ----------------------------------------------------------------------------- */
01185 
01186 /* Flags for new pointer objects */
01187 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
01188 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
01189 
01190 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
01191 
01192 #ifdef __cplusplus
01193 extern "C" {
01194 #if 0
01195 } /* cc-mode */
01196 #endif
01197 #endif
01198 
01199 /*  How to access Py_None */
01200 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
01201 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
01202 #    ifndef SWIG_PYTHON_BUILD_NONE
01203 #      define SWIG_PYTHON_BUILD_NONE
01204 #    endif
01205 #  endif
01206 #endif
01207 
01208 #ifdef SWIG_PYTHON_BUILD_NONE
01209 #  ifdef Py_None
01210 #   undef Py_None
01211 #   define Py_None SWIG_Py_None()
01212 #  endif
01213 SWIGRUNTIMEINLINE PyObject * 
01214 _SWIG_Py_None(void)
01215 {
01216   PyObject *none = Py_BuildValue((char*)"");
01217   Py_DECREF(none);
01218   return none;
01219 }
01220 SWIGRUNTIME PyObject * 
01221 SWIG_Py_None(void)
01222 {
01223   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
01224   return none;
01225 }
01226 #endif
01227 
01228 /* The python void return value */
01229 
01230 SWIGRUNTIMEINLINE PyObject * 
01231 SWIG_Py_Void(void)
01232 {
01233   PyObject *none = Py_None;
01234   Py_INCREF(none);
01235   return none;
01236 }
01237 
01238 /* PySwigClientData */
01239 
01240 typedef struct {
01241   PyObject *klass;
01242   PyObject *newraw;
01243   PyObject *newargs;
01244   PyObject *destroy;
01245   int delargs;
01246   int implicitconv;
01247 } PySwigClientData;
01248 
01249 SWIGRUNTIMEINLINE int 
01250 SWIG_Python_CheckImplicit(swig_type_info *ty)
01251 {
01252   PySwigClientData *data = (PySwigClientData *)ty->clientdata;
01253   return data ? data->implicitconv : 0;
01254 }
01255 
01256 SWIGRUNTIMEINLINE PyObject *
01257 SWIG_Python_ExceptionType(swig_type_info *desc) {
01258   PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
01259   PyObject *klass = data ? data->klass : 0;
01260   return (klass ? klass : PyExc_RuntimeError);
01261 }
01262 
01263 
01264 SWIGRUNTIME PySwigClientData * 
01265 PySwigClientData_New(PyObject* obj)
01266 {
01267   if (!obj) {
01268     return 0;
01269   } else {
01270     PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
01271     /* the klass element */
01272     data->klass = obj;
01273     Py_INCREF(data->klass);
01274     /* the newraw method and newargs arguments used to create a new raw instance */
01275     if (PyClass_Check(obj)) {
01276       data->newraw = 0;
01277       data->newargs = obj;
01278       Py_INCREF(obj);
01279     } else {
01280 #if (PY_VERSION_HEX < 0x02020000)
01281       data->newraw = 0;
01282 #else
01283       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
01284 #endif
01285       if (data->newraw) {
01286        Py_INCREF(data->newraw);
01287        data->newargs = PyTuple_New(1);
01288        PyTuple_SetItem(data->newargs, 0, obj);
01289       } else {
01290        data->newargs = obj;
01291       }
01292       Py_INCREF(data->newargs);
01293     }
01294     /* the destroy method, aka as the C++ delete method */
01295     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
01296     if (PyErr_Occurred()) {
01297       PyErr_Clear();
01298       data->destroy = 0;
01299     }
01300     if (data->destroy) {
01301       int flags;
01302       Py_INCREF(data->destroy);
01303       flags = PyCFunction_GET_FLAGS(data->destroy);
01304 #ifdef METH_O
01305       data->delargs = !(flags & (METH_O));
01306 #else
01307       data->delargs = 0;
01308 #endif
01309     } else {
01310       data->delargs = 0;
01311     }
01312     data->implicitconv = 0;
01313     return data;
01314   }
01315 }
01316 
01317 SWIGRUNTIME void 
01318 PySwigClientData_Del(PySwigClientData* data)
01319 {
01320   Py_XDECREF(data->newraw);
01321   Py_XDECREF(data->newargs);
01322   Py_XDECREF(data->destroy);
01323 }
01324 
01325 /* =============== PySwigObject =====================*/
01326 
01327 typedef struct {
01328   PyObject_HEAD
01329   void *ptr;
01330   swig_type_info *ty;
01331   int own;
01332   PyObject *next;
01333 } PySwigObject;
01334 
01335 SWIGRUNTIME PyObject *
01336 PySwigObject_long(PySwigObject *v)
01337 {
01338   return PyLong_FromVoidPtr(v->ptr);
01339 }
01340 
01341 SWIGRUNTIME PyObject *
01342 PySwigObject_format(const char* fmt, PySwigObject *v)
01343 {
01344   PyObject *res = NULL;
01345   PyObject *args = PyTuple_New(1);
01346   if (args) {
01347     if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
01348       PyObject *ofmt = PyString_FromString(fmt);
01349       if (ofmt) {
01350        res = PyString_Format(ofmt,args);
01351        Py_DECREF(ofmt);
01352       }
01353       Py_DECREF(args);
01354     }
01355   }
01356   return res;
01357 }
01358 
01359 SWIGRUNTIME PyObject *
01360 PySwigObject_oct(PySwigObject *v)
01361 {
01362   return PySwigObject_format("%o",v);
01363 }
01364 
01365 SWIGRUNTIME PyObject *
01366 PySwigObject_hex(PySwigObject *v)
01367 {
01368   return PySwigObject_format("%x",v);
01369 }
01370 
01371 SWIGRUNTIME PyObject *
01372 #ifdef METH_NOARGS
01373 PySwigObject_repr(PySwigObject *v)
01374 #else
01375 PySwigObject_repr(PySwigObject *v, PyObject *args)
01376 #endif
01377 {
01378   const char *name = SWIG_TypePrettyName(v->ty);
01379   PyObject *hex = PySwigObject_hex(v);    
01380   PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
01381   Py_DECREF(hex);
01382   if (v->next) {
01383 #ifdef METH_NOARGS
01384     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
01385 #else
01386     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
01387 #endif
01388     PyString_ConcatAndDel(&repr,nrep);
01389   }
01390   return repr;  
01391 }
01392 
01393 SWIGRUNTIME int
01394 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
01395 {
01396 #ifdef METH_NOARGS
01397   PyObject *repr = PySwigObject_repr(v);
01398 #else
01399   PyObject *repr = PySwigObject_repr(v, NULL);
01400 #endif
01401   if (repr) {
01402     fputs(PyString_AsString(repr), fp);
01403     Py_DECREF(repr);
01404     return 0; 
01405   } else {
01406     return 1; 
01407   }
01408 }
01409 
01410 SWIGRUNTIME PyObject *
01411 PySwigObject_str(PySwigObject *v)
01412 {
01413   char result[SWIG_BUFFER_SIZE];
01414   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
01415     PyString_FromString(result) : 0;
01416 }
01417 
01418 SWIGRUNTIME int
01419 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
01420 {
01421   void *i = v->ptr;
01422   void *j = w->ptr;
01423   return (i < j) ? -1 : ((i > j) ? 1 : 0);
01424 }
01425 
01426 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
01427 
01428 SWIGRUNTIME PyTypeObject*
01429 PySwigObject_type(void) {
01430   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
01431   return type;
01432 }
01433 
01434 SWIGRUNTIMEINLINE int
01435 PySwigObject_Check(PyObject *op) {
01436   return ((op)->ob_type == PySwigObject_type())
01437     || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
01438 }
01439 
01440 SWIGRUNTIME PyObject *
01441 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
01442 
01443 SWIGRUNTIME void
01444 PySwigObject_dealloc(PyObject *v)
01445 {
01446   PySwigObject *sobj = (PySwigObject *) v;
01447   PyObject *next = sobj->next;
01448   if (sobj->own == SWIG_POINTER_OWN) {
01449     swig_type_info *ty = sobj->ty;
01450     PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
01451     PyObject *destroy = data ? data->destroy : 0;
01452     if (destroy) {
01453       /* destroy is always a VARARGS method */
01454       PyObject *res;
01455       if (data->delargs) {
01456        /* we need to create a temporal object to carry the destroy operation */
01457        PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
01458        res = SWIG_Python_CallFunctor(destroy, tmp);
01459        Py_DECREF(tmp);
01460       } else {
01461        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
01462        PyObject *mself = PyCFunction_GET_SELF(destroy);
01463        res = ((*meth)(mself, v));
01464       }
01465       Py_XDECREF(res);
01466     } 
01467 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
01468     else {
01469       const char *name = SWIG_TypePrettyName(ty);
01470       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
01471     }
01472 #endif
01473   } 
01474   Py_XDECREF(next);
01475   PyObject_DEL(v);
01476 }
01477 
01478 SWIGRUNTIME PyObject* 
01479 PySwigObject_append(PyObject* v, PyObject* next)
01480 {
01481   PySwigObject *sobj = (PySwigObject *) v;
01482 #ifndef METH_O
01483   PyObject *tmp = 0;
01484   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
01485   next = tmp;
01486 #endif
01487   if (!PySwigObject_Check(next)) {
01488     return NULL;
01489   }
01490   sobj->next = next;
01491   Py_INCREF(next);
01492   return SWIG_Py_Void();
01493 }
01494 
01495 SWIGRUNTIME PyObject* 
01496 #ifdef METH_NOARGS
01497 PySwigObject_next(PyObject* v)
01498 #else
01499 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01500 #endif
01501 {
01502   PySwigObject *sobj = (PySwigObject *) v;
01503   if (sobj->next) {    
01504     Py_INCREF(sobj->next);
01505     return sobj->next;
01506   } else {
01507     return SWIG_Py_Void();
01508   }
01509 }
01510 
01511 SWIGINTERN PyObject*
01512 #ifdef METH_NOARGS
01513 PySwigObject_disown(PyObject *v)
01514 #else
01515 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01516 #endif
01517 {
01518   PySwigObject *sobj = (PySwigObject *)v;
01519   sobj->own = 0;
01520   return SWIG_Py_Void();
01521 }
01522 
01523 SWIGINTERN PyObject*
01524 #ifdef METH_NOARGS
01525 PySwigObject_acquire(PyObject *v)
01526 #else
01527 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01528 #endif
01529 {
01530   PySwigObject *sobj = (PySwigObject *)v;
01531   sobj->own = SWIG_POINTER_OWN;
01532   return SWIG_Py_Void();
01533 }
01534 
01535 SWIGINTERN PyObject*
01536 PySwigObject_own(PyObject *v, PyObject *args)
01537 {
01538   PyObject *val = 0;
01539 #if (PY_VERSION_HEX < 0x02020000)
01540   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
01541 #else
01542   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
01543 #endif
01544     {
01545       return NULL;
01546     } 
01547   else
01548     {
01549       PySwigObject *sobj = (PySwigObject *)v;
01550       PyObject *obj = PyBool_FromLong(sobj->own);
01551       if (val) {
01552 #ifdef METH_NOARGS
01553        if (PyObject_IsTrue(val)) {
01554          PySwigObject_acquire(v);
01555        } else {
01556          PySwigObject_disown(v);
01557        }
01558 #else
01559        if (PyObject_IsTrue(val)) {
01560          PySwigObject_acquire(v,args);
01561        } else {
01562          PySwigObject_disown(v,args);
01563        }
01564 #endif
01565       } 
01566       return obj;
01567     }
01568 }
01569 
01570 #ifdef METH_O
01571 static PyMethodDef
01572 swigobject_methods[] = {
01573   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
01574   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
01575   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
01576   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
01577   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
01578   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
01579   {0, 0, 0, 0}  
01580 };
01581 #else
01582 static PyMethodDef
01583 swigobject_methods[] = {
01584   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
01585   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
01586   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
01587   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
01588   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
01589   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
01590   {0, 0, 0, 0}  
01591 };
01592 #endif
01593 
01594 #if PY_VERSION_HEX < 0x02020000
01595 SWIGINTERN PyObject *
01596 PySwigObject_getattr(PySwigObject *sobj,char *name)
01597 {
01598   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
01599 }
01600 #endif
01601 
01602 SWIGRUNTIME PyTypeObject*
01603 _PySwigObject_type(void) {
01604   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
01605   
01606   static PyNumberMethods PySwigObject_as_number = {
01607     (binaryfunc)0, /*nb_add*/
01608     (binaryfunc)0, /*nb_subtract*/
01609     (binaryfunc)0, /*nb_multiply*/
01610     (binaryfunc)0, /*nb_divide*/
01611     (binaryfunc)0, /*nb_remainder*/
01612     (binaryfunc)0, /*nb_divmod*/
01613     (ternaryfunc)0,/*nb_power*/
01614     (unaryfunc)0,  /*nb_negative*/
01615     (unaryfunc)0,  /*nb_positive*/
01616     (unaryfunc)0,  /*nb_absolute*/
01617     (inquiry)0,    /*nb_nonzero*/
01618     0,           /*nb_invert*/
01619     0,           /*nb_lshift*/
01620     0,           /*nb_rshift*/
01621     0,           /*nb_and*/
01622     0,           /*nb_xor*/
01623     0,           /*nb_or*/
01624     (coercion)0,   /*nb_coerce*/
01625     (unaryfunc)PySwigObject_long, /*nb_int*/
01626     (unaryfunc)PySwigObject_long, /*nb_long*/
01627     (unaryfunc)0,                 /*nb_float*/
01628     (unaryfunc)PySwigObject_oct,  /*nb_oct*/
01629     (unaryfunc)PySwigObject_hex,  /*nb_hex*/
01630 #if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
01631     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
01632 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
01633     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
01634 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
01635     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
01636 #endif
01637   };
01638 
01639   static PyTypeObject pyswigobject_type;  
01640   static int type_init = 0;
01641   if (!type_init) {
01642     const PyTypeObject tmp
01643       = {
01644        PyObject_HEAD_INIT(NULL)
01645        0,                              /* ob_size */
01646        (char *)"PySwigObject",                /* tp_name */
01647        sizeof(PySwigObject),                  /* tp_basicsize */
01648        0,                               /* tp_itemsize */
01649        (destructor)PySwigObject_dealloc,   /* tp_dealloc */
01650        (printfunc)PySwigObject_print,         /* tp_print */
01651 #if PY_VERSION_HEX < 0x02020000
01652        (getattrfunc)PySwigObject_getattr,  /* tp_getattr */ 
01653 #else
01654        (getattrfunc)0,                        /* tp_getattr */ 
01655 #endif
01656        (setattrfunc)0,                        /* tp_setattr */ 
01657        (cmpfunc)PySwigObject_compare,         /* tp_compare */ 
01658        (reprfunc)PySwigObject_repr,           /* tp_repr */    
01659        &PySwigObject_as_number,        /* tp_as_number */
01660        0,                              /* tp_as_sequence */
01661        0,                              /* tp_as_mapping */
01662        (hashfunc)0,                    /* tp_hash */
01663        (ternaryfunc)0,                        /* tp_call */
01664        (reprfunc)PySwigObject_str,     /* tp_str */
01665        PyObject_GenericGetAttr,            /* tp_getattro */
01666        0,                              /* tp_setattro */
01667        0,                                /* tp_as_buffer */
01668        Py_TPFLAGS_DEFAULT,              /* tp_flags */
01669        swigobject_doc,                  /* tp_doc */        
01670        0,                                  /* tp_traverse */
01671        0,                                  /* tp_clear */
01672        0,                                  /* tp_richcompare */
01673        0,                                  /* tp_weaklistoffset */
01674 #if PY_VERSION_HEX >= 0x02020000
01675        0,                                  /* tp_iter */
01676        0,                                  /* tp_iternext */
01677        swigobject_methods,             /* tp_methods */ 
01678        0,                               /* tp_members */
01679        0,                              /* tp_getset */         
01680        0,                               /* tp_base */           
01681        0,                              /* tp_dict */           
01682        0,                              /* tp_descr_get */      
01683        0,                              /* tp_descr_set */      
01684        0,                              /* tp_dictoffset */     
01685        0,                              /* tp_init */           
01686        0,                              /* tp_alloc */          
01687        0,                               /* tp_new */           
01688        0,                                 /* tp_free */    
01689         0,                                  /* tp_is_gc */  
01690        0,                              /* tp_bases */   
01691        0,                              /* tp_mro */
01692        0,                              /* tp_cache */   
01693        0,                              /* tp_subclasses */
01694        0,                              /* tp_weaklist */
01695 #endif
01696 #if PY_VERSION_HEX >= 0x02030000
01697        0,                                  /* tp_del */
01698 #endif
01699 #ifdef COUNT_ALLOCS
01700        0,0,0,0                             /* tp_alloc -> tp_next */
01701 #endif
01702       };
01703     pyswigobject_type = tmp;
01704     pyswigobject_type.ob_type = &PyType_Type;
01705     type_init = 1;
01706   }
01707   return &pyswigobject_type;
01708 }
01709 
01710 SWIGRUNTIME PyObject *
01711 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
01712 {
01713   PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
01714   if (sobj) {
01715     sobj->ptr  = ptr;
01716     sobj->ty   = ty;
01717     sobj->own  = own;
01718     sobj->next = 0;
01719   }
01720   return (PyObject *)sobj;
01721 }
01722 
01723 /* -----------------------------------------------------------------------------
01724  * Implements a simple Swig Packed type, and use it instead of string
01725  * ----------------------------------------------------------------------------- */
01726 
01727 typedef struct {
01728   PyObject_HEAD
01729   void *pack;
01730   swig_type_info *ty;
01731   size_t size;
01732 } PySwigPacked;
01733 
01734 SWIGRUNTIME int
01735 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
01736 {
01737   char result[SWIG_BUFFER_SIZE];
01738   fputs("<Swig Packed ", fp); 
01739   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01740     fputs("at ", fp); 
01741     fputs(result, fp); 
01742   }
01743   fputs(v->ty->name,fp); 
01744   fputs(">", fp);
01745   return 0; 
01746 }
01747   
01748 SWIGRUNTIME PyObject *
01749 PySwigPacked_repr(PySwigPacked *v)
01750 {
01751   char result[SWIG_BUFFER_SIZE];
01752   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01753     return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
01754   } else {
01755     return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
01756   }  
01757 }
01758 
01759 SWIGRUNTIME PyObject *
01760 PySwigPacked_str(PySwigPacked *v)
01761 {
01762   char result[SWIG_BUFFER_SIZE];
01763   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
01764     return PyString_FromFormat("%s%s", result, v->ty->name);
01765   } else {
01766     return PyString_FromString(v->ty->name);
01767   }  
01768 }
01769 
01770 SWIGRUNTIME int
01771 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
01772 {
01773   size_t i = v->size;
01774   size_t j = w->size;
01775   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
01776   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
01777 }
01778 
01779 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
01780 
01781 SWIGRUNTIME PyTypeObject*
01782 PySwigPacked_type(void) {
01783   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
01784   return type;
01785 }
01786 
01787 SWIGRUNTIMEINLINE int
01788 PySwigPacked_Check(PyObject *op) {
01789   return ((op)->ob_type == _PySwigPacked_type()) 
01790     || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
01791 }
01792 
01793 SWIGRUNTIME void
01794 PySwigPacked_dealloc(PyObject *v)
01795 {
01796   if (PySwigPacked_Check(v)) {
01797     PySwigPacked *sobj = (PySwigPacked *) v;
01798     free(sobj->pack);
01799   }
01800   PyObject_DEL(v);
01801 }
01802 
01803 SWIGRUNTIME PyTypeObject*
01804 _PySwigPacked_type(void) {
01805   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
01806   static PyTypeObject pyswigpacked_type;
01807   static int type_init = 0;  
01808   if (!type_init) {
01809     const PyTypeObject tmp
01810       = {
01811        PyObject_HEAD_INIT(NULL)
01812        0,                              /* ob_size */    
01813        (char *)"PySwigPacked",                /* tp_name */    
01814        sizeof(PySwigPacked),                  /* tp_basicsize */      
01815        0,                              /* tp_itemsize */       
01816        (destructor)PySwigPacked_dealloc,   /* tp_dealloc */    
01817        (printfunc)PySwigPacked_print,         /* tp_print */          
01818        (getattrfunc)0,                        /* tp_getattr */        
01819        (setattrfunc)0,                        /* tp_setattr */        
01820        (cmpfunc)PySwigPacked_compare,         /* tp_compare */        
01821        (reprfunc)PySwigPacked_repr,           /* tp_repr */           
01822        0,                                 /* tp_as_number */   
01823        0,                              /* tp_as_sequence */
01824        0,                              /* tp_as_mapping */     
01825        (hashfunc)0,                    /* tp_hash */    
01826        (ternaryfunc)0,                        /* tp_call */    
01827        (reprfunc)PySwigPacked_str,     /* tp_str */     
01828        PyObject_GenericGetAttr,            /* tp_getattro */
01829        0,                              /* tp_setattro */
01830        0,                                /* tp_as_buffer */
01831        Py_TPFLAGS_DEFAULT,              /* tp_flags */
01832        swigpacked_doc,                  /* tp_doc */
01833        0,                                  /* tp_traverse */
01834        0,                                  /* tp_clear */
01835        0,                                  /* tp_richcompare */
01836        0,                                  /* tp_weaklistoffset */
01837 #if PY_VERSION_HEX >= 0x02020000
01838        0,                                  /* tp_iter */
01839        0,                                  /* tp_iternext */
01840        0,                                /* tp_methods */ 
01841        0,                               /* tp_members */
01842        0,                              /* tp_getset */         
01843        0,                               /* tp_base */           
01844        0,                              /* tp_dict */           
01845        0,                              /* tp_descr_get */      
01846        0,                              /* tp_descr_set */      
01847        0,                              /* tp_dictoffset */     
01848        0,                              /* tp_init */           
01849        0,                              /* tp_alloc */          
01850        0,                               /* tp_new */           
01851        0,                                 /* tp_free */    
01852         0,                                  /* tp_is_gc */  
01853        0,                              /* tp_bases */   
01854        0,                              /* tp_mro */
01855        0,                              /* tp_cache */   
01856        0,                              /* tp_subclasses */
01857        0,                              /* tp_weaklist */
01858 #endif
01859 #if PY_VERSION_HEX >= 0x02030000
01860        0,                                  /* tp_del */
01861 #endif
01862 #ifdef COUNT_ALLOCS
01863        0,0,0,0                             /* tp_alloc -> tp_next */
01864 #endif
01865       };
01866     pyswigpacked_type = tmp;
01867     pyswigpacked_type.ob_type = &PyType_Type;
01868     type_init = 1;
01869   }
01870   return &pyswigpacked_type;
01871 }
01872 
01873 SWIGRUNTIME PyObject *
01874 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
01875 {
01876   PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
01877   if (sobj) {
01878     void *pack = malloc(size);
01879     if (pack) {
01880       memcpy(pack, ptr, size);
01881       sobj->pack = pack;
01882       sobj->ty   = ty;
01883       sobj->size = size;
01884     } else {
01885       PyObject_DEL((PyObject *) sobj);
01886       sobj = 0;
01887     }
01888   }
01889   return (PyObject *) sobj;
01890 }
01891 
01892 SWIGRUNTIME swig_type_info *
01893 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
01894 {
01895   if (PySwigPacked_Check(obj)) {
01896     PySwigPacked *sobj = (PySwigPacked *)obj;
01897     if (sobj->size != size) return 0;
01898     memcpy(ptr, sobj->pack, size);
01899     return sobj->ty;
01900   } else {
01901     return 0;
01902   }
01903 }
01904 
01905 /* -----------------------------------------------------------------------------
01906  * pointers/data manipulation
01907  * ----------------------------------------------------------------------------- */
01908 
01909 SWIGRUNTIMEINLINE PyObject *
01910 _SWIG_This(void)
01911 {
01912   return PyString_FromString("this");
01913 }
01914 
01915 SWIGRUNTIME PyObject *
01916 SWIG_This(void)
01917 {
01918   static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
01919   return swig_this;
01920 }
01921 
01922 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
01923 
01924 SWIGRUNTIME PySwigObject *
01925 SWIG_Python_GetSwigThis(PyObject *pyobj) 
01926 {
01927   if (PySwigObject_Check(pyobj)) {
01928     return (PySwigObject *) pyobj;
01929   } else {
01930     PyObject *obj = 0;
01931 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
01932     if (PyInstance_Check(pyobj)) {
01933       obj = _PyInstance_Lookup(pyobj, SWIG_This());      
01934     } else {
01935       PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
01936       if (dictptr != NULL) {
01937        PyObject *dict = *dictptr;
01938        obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
01939       } else {
01940 #ifdef PyWeakref_CheckProxy
01941        if (PyWeakref_CheckProxy(pyobj)) {
01942          PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
01943          return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
01944        }
01945 #endif
01946        obj = PyObject_GetAttr(pyobj,SWIG_This());
01947        if (obj) {
01948          Py_DECREF(obj);
01949        } else {
01950          if (PyErr_Occurred()) PyErr_Clear();
01951          return 0;
01952        }
01953       }
01954     }
01955 #else
01956     obj = PyObject_GetAttr(pyobj,SWIG_This());
01957     if (obj) {
01958       Py_DECREF(obj);
01959     } else {
01960       if (PyErr_Occurred()) PyErr_Clear();
01961       return 0;
01962     }
01963 #endif
01964     if (obj && !PySwigObject_Check(obj)) {
01965       /* a PyObject is called 'this', try to get the 'real this'
01966         PySwigObject from it */ 
01967       return SWIG_Python_GetSwigThis(obj);
01968     }
01969     return (PySwigObject *)obj;
01970   }
01971 }
01972 
01973 /* Acquire a pointer value */
01974 
01975 SWIGRUNTIME int
01976 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
01977   if (own == SWIG_POINTER_OWN) {
01978     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
01979     if (sobj) {
01980       int oldown = sobj->own;
01981       sobj->own = own;
01982       return oldown;
01983     }
01984   }
01985   return 0;
01986 }
01987 
01988 /* Convert a pointer value */
01989 
01990 SWIGRUNTIME int
01991 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
01992   if (!obj) return SWIG_ERROR;
01993   if (obj == Py_None) {
01994     if (ptr) *ptr = 0;
01995     return SWIG_OK;
01996   } else {
01997     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
01998     if (own)
01999       *own = 0;
02000     while (sobj) {
02001       void *vptr = sobj->ptr;
02002       if (ty) {
02003        swig_type_info *to = sobj->ty;
02004        if (to == ty) {
02005          /* no type cast needed */
02006          if (ptr) *ptr = vptr;
02007          break;
02008        } else {
02009          swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
02010          if (!tc) {
02011            sobj = (PySwigObject *)sobj->next;
02012          } else {
02013            if (ptr) {
02014               int newmemory = 0;
02015               *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
02016               if (newmemory == SWIG_CAST_NEW_MEMORY) {
02017                 assert(own);
02018                 if (own)
02019                   *own = *own | SWIG_CAST_NEW_MEMORY;
02020               }
02021             }
02022            break;
02023          }
02024        }
02025       } else {
02026        if (ptr) *ptr = vptr;
02027        break;
02028       }
02029     }
02030     if (sobj) {
02031       if (own)
02032         *own = *own | sobj->own;
02033       if (flags & SWIG_POINTER_DISOWN) {
02034        sobj->own = 0;
02035       }
02036       return SWIG_OK;
02037     } else {
02038       int res = SWIG_ERROR;
02039       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
02040        PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
02041        if (data && !data->implicitconv) {
02042          PyObject *klass = data->klass;
02043          if (klass) {
02044            PyObject *impconv;
02045            data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
02046            impconv = SWIG_Python_CallFunctor(klass, obj);
02047            data->implicitconv = 0;
02048            if (PyErr_Occurred()) {
02049              PyErr_Clear();
02050              impconv = 0;
02051            }
02052            if (impconv) {
02053              PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
02054              if (iobj) {
02055               void *vptr;
02056               res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
02057               if (SWIG_IsOK(res)) {
02058                 if (ptr) {
02059                   *ptr = vptr;
02060                   /* transfer the ownership to 'ptr' */
02061                   iobj->own = 0;
02062                   res = SWIG_AddCast(res);
02063                   res = SWIG_AddNewMask(res);
02064                 } else {
02065                   res = SWIG_AddCast(res);                  
02066                 }
02067               }
02068              }
02069              Py_DECREF(impconv);
02070            }
02071          }
02072        }
02073       }
02074       return res;
02075     }
02076   }
02077 }
02078 
02079 /* Convert a function ptr value */
02080 
02081 SWIGRUNTIME int
02082 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
02083   if (!PyCFunction_Check(obj)) {
02084     return SWIG_ConvertPtr(obj, ptr, ty, 0);
02085   } else {
02086     void *vptr = 0;
02087     
02088     /* here we get the method pointer for callbacks */
02089     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
02090     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
02091     if (desc) {
02092       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
02093       if (!desc) return SWIG_ERROR;
02094     }
02095     if (ty) {
02096       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
02097       if (tc) {
02098         int newmemory = 0;
02099         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
02100         assert(!newmemory); /* newmemory handling not yet implemented */
02101       } else {
02102         return SWIG_ERROR;
02103       }
02104     } else {
02105       *ptr = vptr;
02106     }
02107     return SWIG_OK;
02108   }
02109 }
02110 
02111 /* Convert a packed value value */
02112 
02113 SWIGRUNTIME int
02114 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
02115   swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
02116   if (!to) return SWIG_ERROR;
02117   if (ty) {
02118     if (to != ty) {
02119       /* check type cast? */
02120       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
02121       if (!tc) return SWIG_ERROR;
02122     }
02123   }
02124   return SWIG_OK;
02125 }  
02126 
02127 /* -----------------------------------------------------------------------------
02128  * Create a new pointer object
02129  * ----------------------------------------------------------------------------- */
02130 
02131 /*
02132   Create a new instance object, whitout calling __init__, and set the
02133   'this' attribute.
02134 */
02135 
02136 SWIGRUNTIME PyObject* 
02137 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
02138 {
02139 #if (PY_VERSION_HEX >= 0x02020000)
02140   PyObject *inst = 0;
02141   PyObject *newraw = data->newraw;
02142   if (newraw) {
02143     inst = PyObject_Call(newraw, data->newargs, NULL);
02144     if (inst) {
02145 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02146       PyObject **dictptr = _PyObject_GetDictPtr(inst);
02147       if (dictptr != NULL) {
02148        PyObject *dict = *dictptr;
02149        if (dict == NULL) {
02150          dict = PyDict_New();
02151          *dictptr = dict;
02152          PyDict_SetItem(dict, SWIG_This(), swig_this);
02153        }
02154       }
02155 #else
02156       PyObject *key = SWIG_This();
02157       PyObject_SetAttr(inst, key, swig_this);
02158 #endif
02159     }
02160   } else {
02161     PyObject *dict = PyDict_New();
02162     PyDict_SetItem(dict, SWIG_This(), swig_this);
02163     inst = PyInstance_NewRaw(data->newargs, dict);
02164     Py_DECREF(dict);
02165   }
02166   return inst;
02167 #else
02168 #if (PY_VERSION_HEX >= 0x02010000)
02169   PyObject *inst;
02170   PyObject *dict = PyDict_New();
02171   PyDict_SetItem(dict, SWIG_This(), swig_this);
02172   inst = PyInstance_NewRaw(data->newargs, dict);
02173   Py_DECREF(dict);
02174   return (PyObject *) inst;
02175 #else
02176   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
02177   if (inst == NULL) {
02178     return NULL;
02179   }
02180   inst->in_class = (PyClassObject *)data->newargs;
02181   Py_INCREF(inst->in_class);
02182   inst->in_dict = PyDict_New();
02183   if (inst->in_dict == NULL) {
02184     Py_DECREF(inst);
02185     return NULL;
02186   }
02187 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
02188   inst->in_weakreflist = NULL;
02189 #endif
02190 #ifdef Py_TPFLAGS_GC
02191   PyObject_GC_Init(inst);
02192 #endif
02193   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
02194   return (PyObject *) inst;
02195 #endif
02196 #endif
02197 }
02198 
02199 SWIGRUNTIME void
02200 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
02201 {
02202  PyObject *dict;
02203 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02204  PyObject **dictptr = _PyObject_GetDictPtr(inst);
02205  if (dictptr != NULL) {
02206    dict = *dictptr;
02207    if (dict == NULL) {
02208      dict = PyDict_New();
02209      *dictptr = dict;
02210    }
02211    PyDict_SetItem(dict, SWIG_This(), swig_this);
02212    return;
02213  }
02214 #endif
02215  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
02216  PyDict_SetItem(dict, SWIG_This(), swig_this);
02217  Py_DECREF(dict);
02218 } 
02219 
02220 
02221 SWIGINTERN PyObject *
02222 SWIG_Python_InitShadowInstance(PyObject *args) {
02223   PyObject *obj[2];
02224   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
02225     return NULL;
02226   } else {
02227     PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
02228     if (sthis) {
02229       PySwigObject_append((PyObject*) sthis, obj[1]);
02230     } else {
02231       SWIG_Python_SetSwigThis(obj[0], obj[1]);
02232     }
02233     return SWIG_Py_Void();
02234   }
02235 }
02236 
02237 /* Create a new pointer object */
02238 
02239 SWIGRUNTIME PyObject *
02240 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
02241   if (!ptr) {
02242     return SWIG_Py_Void();
02243   } else {
02244     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
02245     PyObject *robj = PySwigObject_New(ptr, type, own);
02246     PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
02247     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
02248       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
02249       if (inst) {
02250        Py_DECREF(robj);
02251        robj = inst;
02252       }
02253     }
02254     return robj;
02255   }
02256 }
02257 
02258 /* Create a new packed object */
02259 
02260 SWIGRUNTIMEINLINE PyObject *
02261 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
02262   return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
02263 }
02264 
02265 /* -----------------------------------------------------------------------------*
02266  *  Get type list 
02267  * -----------------------------------------------------------------------------*/
02268 
02269 #ifdef SWIG_LINK_RUNTIME
02270 void *SWIG_ReturnGlobalTypeList(void *);
02271 #endif
02272 
02273 SWIGRUNTIME swig_module_info *
02274 SWIG_Python_GetModule(void) {
02275   static void *type_pointer = (void *)0;
02276   /* first check if module already created */
02277   if (!type_pointer) {
02278 #ifdef SWIG_LINK_RUNTIME
02279     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
02280 #else
02281     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
02282                                 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
02283     if (PyErr_Occurred()) {
02284       PyErr_Clear();
02285       type_pointer = (void *)0;
02286     }
02287 #endif
02288   }
02289   return (swig_module_info *) type_pointer;
02290 }
02291 
02292 #if PY_MAJOR_VERSION < 2
02293 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
02294    is copied out of Python/modsupport.c in python version 2.3.4 */
02295 SWIGINTERN int
02296 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
02297 {
02298   PyObject *dict;
02299   if (!PyModule_Check(m)) {
02300     PyErr_SetString(PyExc_TypeError,
02301                   "PyModule_AddObject() needs module as first arg");
02302     return SWIG_ERROR;
02303   }
02304   if (!o) {
02305     PyErr_SetString(PyExc_TypeError,
02306                   "PyModule_AddObject() needs non-NULL value");
02307     return SWIG_ERROR;
02308   }
02309   
02310   dict = PyModule_GetDict(m);
02311   if (dict == NULL) {
02312     /* Internal error -- modules must have a dict! */
02313     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
02314                PyModule_GetName(m));
02315     return SWIG_ERROR;
02316   }
02317   if (PyDict_SetItemString(dict, name, o))
02318     return SWIG_ERROR;
02319   Py_DECREF(o);
02320   return SWIG_OK;
02321 }
02322 #endif
02323 
02324 SWIGRUNTIME void
02325 SWIG_Python_DestroyModule(void *vptr)
02326 {
02327   swig_module_info *swig_module = (swig_module_info *) vptr;
02328   swig_type_info **types = swig_module->types;
02329   size_t i;
02330   for (i =0; i < swig_module->size; ++i) {
02331     swig_type_info *ty = types[i];
02332     if (ty->owndata) {
02333       PySwigClientData *data = (PySwigClientData *) ty->clientdata;
02334       if (data) PySwigClientData_Del(data);
02335     }
02336   }
02337   Py_DECREF(SWIG_This());
02338 }
02339 
02340 SWIGRUNTIME void
02341 SWIG_Python_SetModule(swig_module_info *swig_module) {
02342   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
02343 
02344   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
02345                                swig_empty_runtime_method_table);
02346   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
02347   if (pointer && module) {
02348     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
02349   } else {
02350     Py_XDECREF(pointer);
02351   }
02352 }
02353 
02354 /* The python cached type query */
02355 SWIGRUNTIME PyObject *
02356 SWIG_Python_TypeCache(void) {
02357   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
02358   return cache;
02359 }
02360 
02361 SWIGRUNTIME swig_type_info *
02362 SWIG_Python_TypeQuery(const char *type)
02363 {
02364   PyObject *cache = SWIG_Python_TypeCache();
02365   PyObject *key = PyString_FromString(type); 
02366   PyObject *obj = PyDict_GetItem(cache, key);
02367   swig_type_info *descriptor;
02368   if (obj) {
02369     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
02370   } else {
02371     swig_module_info *swig_module = SWIG_Python_GetModule();
02372     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
02373     if (descriptor) {
02374       obj = PyCObject_FromVoidPtr(descriptor, NULL);
02375       PyDict_SetItem(cache, key, obj);
02376       Py_DECREF(obj);
02377     }
02378   }
02379   Py_DECREF(key);
02380   return descriptor;
02381 }
02382 
02383 /* 
02384    For backward compatibility only
02385 */
02386 #define SWIG_POINTER_EXCEPTION  0
02387 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
02388 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
02389 
02390 SWIGRUNTIME int
02391 SWIG_Python_AddErrMesg(const char* mesg, int infront)
02392 {
02393   if (PyErr_Occurred()) {
02394     PyObject *type = 0;
02395     PyObject *value = 0;
02396     PyObject *traceback = 0;
02397     PyErr_Fetch(&type, &value, &traceback);
02398     if (value) {
02399       PyObject *old_str = PyObject_Str(value);
02400       Py_XINCREF(type);
02401       PyErr_Clear();
02402       if (infront) {
02403        PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
02404       } else {
02405        PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
02406       }
02407       Py_DECREF(old_str);
02408     }
02409     return 1;
02410   } else {
02411     return 0;
02412   }
02413 }
02414   
02415 SWIGRUNTIME int
02416 SWIG_Python_ArgFail(int argnum)
02417 {
02418   if (PyErr_Occurred()) {
02419     /* add information about failing argument */
02420     char mesg[256];
02421     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
02422     return SWIG_Python_AddErrMesg(mesg, 1);
02423   } else {
02424     return 0;
02425   }
02426 }
02427 
02428 SWIGRUNTIMEINLINE const char *
02429 PySwigObject_GetDesc(PyObject *self)
02430 {
02431   PySwigObject *v = (PySwigObject *)self;
02432   swig_type_info *ty = v ? v->ty : 0;
02433   return ty ? ty->str : (char*)"";
02434 }
02435 
02436 SWIGRUNTIME void
02437 SWIG_Python_TypeError(const char *type, PyObject *obj)
02438 {
02439   if (type) {
02440 #if defined(SWIG_COBJECT_TYPES)
02441     if (obj && PySwigObject_Check(obj)) {
02442       const char *otype = (const char *) PySwigObject_GetDesc(obj);
02443       if (otype) {
02444        PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
02445                    type, otype);
02446        return;
02447       }
02448     } else 
02449 #endif      
02450     {
02451       const char *otype = (obj ? obj->ob_type->tp_name : 0); 
02452       if (otype) {
02453        PyObject *str = PyObject_Str(obj);
02454        const char *cstr = str ? PyString_AsString(str) : 0;
02455        if (cstr) {
02456          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
02457                      type, otype, cstr);
02458        } else {
02459          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
02460                      type, otype);
02461        }
02462        Py_XDECREF(str);
02463        return;
02464       }
02465     }   
02466     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
02467   } else {
02468     PyErr_Format(PyExc_TypeError, "unexpected type is received");
02469   }
02470 }
02471 
02472 
02473 /* Convert a pointer value, signal an exception on a type mismatch */
02474 SWIGRUNTIME void *
02475 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
02476   void *result;
02477   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
02478     PyErr_Clear();
02479     if (flags & SWIG_POINTER_EXCEPTION) {
02480       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
02481       SWIG_Python_ArgFail(argnum);
02482     }
02483   }
02484   return result;
02485 }
02486 
02487 
02488 #ifdef __cplusplus
02489 #if 0
02490 { /* cc-mode */
02491 #endif
02492 }
02493 #endif
02494 
02495 
02496 
02497 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
02498 
02499 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
02500 
02501 
02502 
02503   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 
02504 
02505 
02506 /* -------- TYPES TABLE (BEGIN) -------- */
02507 
02508 #define SWIGTYPE_p_ArcCredential__certType swig_types[0]
02509 #define SWIGTYPE_p_ArcSec__Evaluator swig_types[1]
02510 #define SWIGTYPE_p_ArcSec__EvaluatorLoader swig_types[2]
02511 #define SWIGTYPE_p_ArcSec__Policy swig_types[3]
02512 #define SWIGTYPE_p_ArcSec__Request swig_types[4]
02513 #define SWIGTYPE_p_ArcSec__Response swig_types[5]
02514 #define SWIGTYPE_p_ArcSec__ResponseItem swig_types[6]
02515 #define SWIGTYPE_p_ArcSec__ResponseList swig_types[7]
02516 #define SWIGTYPE_p_ArcSec__Result swig_types[8]
02517 #define SWIGTYPE_p_ArcSec__SecHandler swig_types[9]
02518 #define SWIGTYPE_p_ArcSec__Source swig_types[10]
02519 #define SWIGTYPE_p_ArcSec__SourceFile swig_types[11]
02520 #define SWIGTYPE_p_ArcSec__SourceURL swig_types[12]
02521 #define SWIGTYPE_p_Arc__ARCPolicyHandlerConfig swig_types[13]
02522 #define SWIGTYPE_p_Arc__ApplicationEnvironment swig_types[14]
02523 #define SWIGTYPE_p_Arc__ApplicationType swig_types[15]
02524 #define SWIGTYPE_p_Arc__ArcLocation swig_types[16]
02525 #define SWIGTYPE_p_Arc__AttrMap__const_iterator swig_types[17]
02526 #define SWIGTYPE_p_Arc__AttrMap__iterator swig_types[18]
02527 #define SWIGTYPE_p_Arc__AttributeIterator swig_types[19]
02528 #define SWIGTYPE_p_Arc__BaseConfig swig_types[20]
02529 #define SWIGTYPE_p_Arc__Broker swig_types[21]
02530 #define SWIGTYPE_p_Arc__BrokerLoader swig_types[22]
02531 #define SWIGTYPE_p_Arc__BrokerPluginArgument swig_types[23]
02532 #define SWIGTYPE_p_Arc__CacheParameters swig_types[24]
02533 #define SWIGTYPE_p_Arc__ChainContext swig_types[25]
02534 #define SWIGTYPE_p_Arc__CheckSum swig_types[26]
02535 #define SWIGTYPE_p_Arc__ClientHTTP swig_types[27]
02536 #define SWIGTYPE_p_Arc__ClientInterface swig_types[28]
02537 #define SWIGTYPE_p_Arc__ClientSOAP swig_types[29]
02538 #define SWIGTYPE_p_Arc__ClientTCP swig_types[30]
02539 #define SWIGTYPE_p_Arc__ClientX509Delegation swig_types[31]
02540 #define SWIGTYPE_p_Arc__Config swig_types[32]
02541 #define SWIGTYPE_p_Arc__Credential swig_types[33]
02542 #define SWIGTYPE_p_Arc__CredentialError swig_types[34]
02543 #define SWIGTYPE_p_Arc__Credformat swig_types[35]
02544 #define SWIGTYPE_p_Arc__DNListHandlerConfig swig_types[36]
02545 #define SWIGTYPE_p_Arc__DataBuffer swig_types[37]
02546 #define SWIGTYPE_p_Arc__DataCallback swig_types[38]
02547 #define SWIGTYPE_p_Arc__DataHandle swig_types[39]
02548 #define SWIGTYPE_p_Arc__DataMover swig_types[40]
02549 #define SWIGTYPE_p_Arc__DataPoint swig_types[41]
02550 #define SWIGTYPE_p_Arc__DataPointLoader swig_types[42]
02551 #define SWIGTYPE_p_Arc__DataPointPluginArgument swig_types[43]
02552 #define SWIGTYPE_p_Arc__DataSourceType swig_types[44]
02553 #define SWIGTYPE_p_Arc__DataSpeed swig_types[45]
02554 #define SWIGTYPE_p_Arc__DataStagingType swig_types[46]
02555 #define SWIGTYPE_p_Arc__DataStatus swig_types[47]
02556 #define SWIGTYPE_p_Arc__DataTargetType swig_types[48]
02557 #define SWIGTYPE_p_Arc__DataType swig_types[49]
02558 #define SWIGTYPE_p_Arc__DelegationConsumer swig_types[50]
02559 #define SWIGTYPE_p_Arc__DelegationConsumerSOAP swig_types[51]
02560 #define SWIGTYPE_p_Arc__DelegationContainerSOAP swig_types[52]
02561 #define SWIGTYPE_p_Arc__DelegationProvider swig_types[53]
02562 #define SWIGTYPE_p_Arc__DelegationProviderSOAP swig_types[54]
02563 #define SWIGTYPE_p_Arc__DirectoryType swig_types[55]
02564 #define SWIGTYPE_p_Arc__DiskSpaceRequirementType swig_types[56]
02565 #define SWIGTYPE_p_Arc__ExecutableType swig_types[57]
02566 #define SWIGTYPE_p_Arc__ExecutionTarget swig_types[58]
02567 #define SWIGTYPE_p_Arc__FileCache swig_types[59]
02568 #define SWIGTYPE_p_Arc__FileInfo swig_types[60]
02569 #define SWIGTYPE_p_Arc__FileType swig_types[61]
02570 #define SWIGTYPE_p_Arc__HTTPClientInfo swig_types[62]
02571 #define SWIGTYPE_p_Arc__IString swig_types[63]
02572 #define SWIGTYPE_p_Arc__Job swig_types[64]
02573 #define SWIGTYPE_p_Arc__JobController swig_types[65]
02574 #define SWIGTYPE_p_Arc__JobControllerLoader swig_types[66]
02575 #define SWIGTYPE_p_Arc__JobControllerPluginArgument swig_types[67]
02576 #define SWIGTYPE_p_Arc__JobDescription swig_types[68]
02577 #define SWIGTYPE_p_Arc__JobIdentificationType swig_types[69]
02578 #define SWIGTYPE_p_Arc__JobMetaType swig_types[70]
02579 #define SWIGTYPE_p_Arc__JobState swig_types[71]
02580 #define SWIGTYPE_p_Arc__JobSupervisor swig_types[72]
02581 #define SWIGTYPE_p_Arc__Loader swig_types[73]
02582 #define SWIGTYPE_p_Arc__LogDestination swig_types[74]
02583 #define SWIGTYPE_p_Arc__LogFile swig_types[75]
02584 #define SWIGTYPE_p_Arc__LogLevel swig_types[76]
02585 #define SWIGTYPE_p_Arc__LogMessage swig_types[77]
02586 #define SWIGTYPE_p_Arc__LogStream swig_types[78]
02587 #define SWIGTYPE_p_Arc__Logger swig_types[79]
02588 #define SWIGTYPE_p_Arc__LoggerFormat swig_types[80]
02589 #define SWIGTYPE_p_Arc__MCC swig_types[81]
02590 #define SWIGTYPE_p_Arc__MCCConfig swig_types[82]
02591 #define SWIGTYPE_p_Arc__MCCInterface swig_types[83]
02592 #define SWIGTYPE_p_Arc__MCCPluginArgument swig_types[84]
02593 #define SWIGTYPE_p_Arc__MCC_Status swig_types[85]
02594 #define SWIGTYPE_p_Arc__Message swig_types[86]
02595 #define SWIGTYPE_p_Arc__MessageAttributes swig_types[87]
02596 #define SWIGTYPE_p_Arc__MessageAuth swig_types[88]
02597 #define SWIGTYPE_p_Arc__MessageAuthContext swig_types[89]
02598 #define SWIGTYPE_p_Arc__MessageContext swig_types[90]
02599 #define SWIGTYPE_p_Arc__MessageContextElement swig_types[91]
02600 #define SWIGTYPE_p_Arc__MessagePayload swig_types[92]
02601 #define SWIGTYPE_p_Arc__MultiSecAttr swig_types[93]
02602 #define SWIGTYPE_p_Arc__NS swig_types[94]
02603 #define SWIGTYPE_p_Arc__NotificationType swig_types[95]
02604 #define SWIGTYPE_p_Arc__PathIterator swig_types[96]
02605 #define SWIGTYPE_p_Arc__PayloadRaw swig_types[97]
02606 #define SWIGTYPE_p_Arc__PayloadRawBuf swig_types[98]
02607 #define SWIGTYPE_p_Arc__PayloadRawInterface swig_types[99]
02608 #define SWIGTYPE_p_Arc__PayloadSOAP swig_types[100]
02609 #define SWIGTYPE_p_Arc__PayloadStream swig_types[101]
02610 #define SWIGTYPE_p_Arc__PayloadStreamInterface swig_types[102]
02611 #define SWIGTYPE_p_Arc__Period swig_types[103]
02612 #define SWIGTYPE_p_Arc__Plugin swig_types[104]
02613 #define SWIGTYPE_p_Arc__PluginArgument swig_types[105]
02614 #define SWIGTYPE_p_Arc__PrintFBase swig_types[106]
02615 #define SWIGTYPE_p_Arc__RangeT_int64_t_t swig_types[107]
02616 #define SWIGTYPE_p_Arc__RangeT_int_t swig_types[108]
02617 #define SWIGTYPE_p_Arc__ResourceSlotType swig_types[109]
02618 #define SWIGTYPE_p_Arc__ResourceTargetType swig_types[110]
02619 #define SWIGTYPE_p_Arc__ResourcesType swig_types[111]
02620 #define SWIGTYPE_p_Arc__SOAPEnvelope swig_types[112]
02621 #define SWIGTYPE_p_Arc__SOAPFault swig_types[113]
02622 #define SWIGTYPE_p_Arc__SOAPMessage swig_types[114]
02623 #define SWIGTYPE_p_Arc__ScalableTimeT_int_t swig_types[115]
02624 #define SWIGTYPE_p_Arc__SecAttr swig_types[116]
02625 #define SWIGTYPE_p_Arc__SecAttrFormat swig_types[117]
02626 #define SWIGTYPE_p_Arc__SecHandlerConfig swig_types[118]
02627 #define SWIGTYPE_p_Arc__Service swig_types[119]
02628 #define SWIGTYPE_p_Arc__ServicePluginArgument swig_types[120]
02629 #define SWIGTYPE_p_Arc__Software swig_types[121]
02630 #define SWIGTYPE_p_Arc__SoftwareRequirement swig_types[122]
02631 #define SWIGTYPE_p_Arc__Submitter swig_types[123]
02632 #define SWIGTYPE_p_Arc__SubmitterLoader swig_types[124]
02633 #define SWIGTYPE_p_Arc__SubmitterPluginArgument swig_types[125]
02634 #define SWIGTYPE_p_Arc__TargetGenerator swig_types[126]
02635 #define SWIGTYPE_p_Arc__TargetRetriever swig_types[127]
02636 #define SWIGTYPE_p_Arc__TargetRetrieverLoader swig_types[128]
02637 #define SWIGTYPE_p_Arc__TargetRetrieverPluginArgument swig_types[129]
02638 #define SWIGTYPE_p_Arc__Time swig_types[130]
02639 #define SWIGTYPE_p_Arc__URL swig_types[131]
02640 #define SWIGTYPE_p_Arc__URLLocation swig_types[132]
02641 #define SWIGTYPE_p_Arc__URLMap swig_types[133]
02642 #define SWIGTYPE_p_Arc__UserConfig swig_types[134]
02643 #define SWIGTYPE_p_Arc__XMLNode swig_types[135]
02644 #define SWIGTYPE_p_Arc__XMLNodeContainer swig_types[136]
02645 #define SWIGTYPE_p_Arc__initializeCredentialsType swig_types[137]
02646 #define SWIGTYPE_p_BIO swig_types[138]
02647 #define SWIGTYPE_p_CPyOstream swig_types[139]
02648 #define SWIGTYPE_p_CPyOutbuf swig_types[140]
02649 #define SWIGTYPE_p_ComparisonOperator swig_types[141]
02650 #define SWIGTYPE_p_EVP_PKEY swig_types[142]
02651 #define SWIGTYPE_p_SOAPFaultCode swig_types[143]
02652 #define SWIGTYPE_p_SOAPVersion swig_types[144]
02653 #define SWIGTYPE_p_Size_t swig_types[145]
02654 #define SWIGTYPE_p_X509 swig_types[146]
02655 #define SWIGTYPE_p_X509_REQ swig_types[147]
02656 #define SWIGTYPE_p_a_2__p_char swig_types[148]
02657 #define SWIGTYPE_p_allocator_type swig_types[149]
02658 #define SWIGTYPE_p_bool swig_types[150]
02659 #define SWIGTYPE_p_char swig_types[151]
02660 #define SWIGTYPE_p_const_reference swig_types[152]
02661 #define SWIGTYPE_p_difference_type swig_types[153]
02662 #define SWIGTYPE_p_f_p_Arc__DataMover_Arc__DataStatus_p_void__void swig_types[154]
02663 #define SWIGTYPE_p_f_p_FILE_p_q_const__char_unsigned_int_unsigned_long_long_unsigned_long_long_double_double__void swig_types[155]
02664 #define SWIGTYPE_p_gid_t swig_types[156]
02665 #define SWIGTYPE_p_initializeType swig_types[157]
02666 #define SWIGTYPE_p_int swig_types[158]
02667 #define SWIGTYPE_p_int64_t swig_types[159]
02668 #define SWIGTYPE_p_key_type swig_types[160]
02669 #define SWIGTYPE_p_mapped_type swig_types[161]
02670 #define SWIGTYPE_p_p_Arc__PayloadRaw swig_types[162]
02671 #define SWIGTYPE_p_p_Arc__PayloadRawInterface swig_types[163]
02672 #define SWIGTYPE_p_p_Arc__PayloadSOAP swig_types[164]
02673 #define SWIGTYPE_p_p_Arc__PayloadStream swig_types[165]
02674 #define SWIGTYPE_p_p_Arc__PayloadStreamInterface swig_types[166]
02675 #define SWIGTYPE_p_p_PyObject swig_types[167]
02676 #define SWIGTYPE_p_p_char swig_types[168]
02677 #define SWIGTYPE_p_reference swig_types[169]
02678 #define SWIGTYPE_p_sigc__slotT_char_const_p_t swig_types[170]
02679 #define SWIGTYPE_p_size_type swig_types[171]
02680 #define SWIGTYPE_p_std__invalid_argument swig_types[172]
02681 #define SWIGTYPE_p_std__istream swig_types[173]
02682 #define SWIGTYPE_p_std__lessT_std__string_t swig_types[174]
02683 #define SWIGTYPE_p_std__listT_Arc__ApplicationEnvironment_std__allocatorT_Arc__ApplicationEnvironment_t_t swig_types[175]
02684 #define SWIGTYPE_p_std__listT_Arc__ApplicationEnvironment_std__allocatorT_Arc__ApplicationEnvironment_t_t__allocator_type swig_types[176]
02685 #define SWIGTYPE_p_std__listT_Arc__ApplicationEnvironment_std__allocatorT_Arc__ApplicationEnvironment_t_t__value_type swig_types[177]
02686 #define SWIGTYPE_p_std__listT_Arc__Broker_p_std__allocatorT_Arc__Broker_p_t_t swig_types[178]
02687 #define SWIGTYPE_p_std__listT_Arc__DataSourceType_std__allocatorT_Arc__DataSourceType_t_t swig_types[179]
02688 #define SWIGTYPE_p_std__listT_Arc__DataSourceType_std__allocatorT_Arc__DataSourceType_t_t__allocator_type swig_types[180]
02689 #define SWIGTYPE_p_std__listT_Arc__DataSourceType_std__allocatorT_Arc__DataSourceType_t_t__value_type swig_types[181]
02690 #define SWIGTYPE_p_std__listT_Arc__DataTargetType_std__allocatorT_Arc__DataTargetType_t_t swig_types[182]
02691 #define SWIGTYPE_p_std__listT_Arc__DataTargetType_std__allocatorT_Arc__DataTargetType_t_t__allocator_type swig_types[183]
02692 #define SWIGTYPE_p_std__listT_Arc__DataTargetType_std__allocatorT_Arc__DataTargetType_t_t__value_type swig_types[184]
02693 #define SWIGTYPE_p_std__listT_Arc__DirectoryType_std__allocatorT_Arc__DirectoryType_t_t swig_types[185]
02694 #define SWIGTYPE_p_std__listT_Arc__DirectoryType_std__allocatorT_Arc__DirectoryType_t_t__allocator_type swig_types[186]
02695 #define SWIGTYPE_p_std__listT_Arc__DirectoryType_std__allocatorT_Arc__DirectoryType_t_t__value_type swig_types[187]
02696 #define SWIGTYPE_p_std__listT_Arc__ExecutionTarget_std__allocatorT_Arc__ExecutionTarget_t_t swig_types[188]
02697 #define SWIGTYPE_p_std__listT_Arc__ExecutionTarget_std__allocatorT_Arc__ExecutionTarget_t_t__allocator_type swig_types[189]
02698 #define SWIGTYPE_p_std__listT_Arc__ExecutionTarget_std__allocatorT_Arc__ExecutionTarget_t_t__value_type swig_types[190]
02699 #define SWIGTYPE_p_std__listT_Arc__FileInfo_std__allocatorT_Arc__FileInfo_t_t swig_types[191]
02700 #define SWIGTYPE_p_std__listT_Arc__FileType_std__allocatorT_Arc__FileType_t_t swig_types[192]
02701 #define SWIGTYPE_p_std__listT_Arc__FileType_std__allocatorT_Arc__FileType_t_t__allocator_type swig_types[193]
02702 #define SWIGTYPE_p_std__listT_Arc__FileType_std__allocatorT_Arc__FileType_t_t__value_type swig_types[194]
02703 #define SWIGTYPE_p_std__listT_Arc__JobController_p_std__allocatorT_Arc__JobController_p_t_t swig_types[195]
02704 #define SWIGTYPE_p_std__listT_Arc__JobController_p_std__allocatorT_Arc__JobController_p_t_t__allocator_type swig_types[196]
02705 #define SWIGTYPE_p_std__listT_Arc__JobState_std__allocatorT_Arc__JobState_t_t swig_types[197]
02706 #define SWIGTYPE_p_std__listT_Arc__JobState_std__allocatorT_Arc__JobState_t_t__allocator_type swig_types[198]
02707 #define SWIGTYPE_p_std__listT_Arc__JobState_std__allocatorT_Arc__JobState_t_t__value_type swig_types[199]
02708 #define SWIGTYPE_p_std__listT_Arc__Job_std__allocatorT_Arc__Job_t_t swig_types[200]
02709 #define SWIGTYPE_p_std__listT_Arc__Job_std__allocatorT_Arc__Job_t_t__allocator_type swig_types[201]
02710 #define SWIGTYPE_p_std__listT_Arc__Job_std__allocatorT_Arc__Job_t_t__value_type swig_types[202]
02711 #define SWIGTYPE_p_std__listT_Arc__NotificationType_std__allocatorT_Arc__NotificationType_t_t swig_types[203]
02712 #define SWIGTYPE_p_std__listT_Arc__ResourceTargetType_std__allocatorT_Arc__ResourceTargetType_t_t swig_types[204]
02713 #define SWIGTYPE_p_std__listT_Arc__ResourceTargetType_std__allocatorT_Arc__ResourceTargetType_t_t__allocator_type swig_types[205]
02714 #define SWIGTYPE_p_std__listT_Arc__ResourceTargetType_std__allocatorT_Arc__ResourceTargetType_t_t__value_type swig_types[206]
02715 #define SWIGTYPE_p_std__listT_Arc__SoftwareRequirement_std__allocatorT_Arc__SoftwareRequirement_t_t swig_types[207]
02716 #define SWIGTYPE_p_std__listT_Arc__SoftwareRequirement_std__allocatorT_Arc__SoftwareRequirement_t_t__allocator_type swig_types[208]
02717 #define SWIGTYPE_p_std__listT_Arc__SoftwareRequirement_std__allocatorT_Arc__SoftwareRequirement_t_t__value_type swig_types[209]
02718 #define SWIGTYPE_p_std__listT_Arc__Software_std__allocatorT_Arc__Software_t_t swig_types[210]
02719 #define SWIGTYPE_p_std__listT_Arc__Software_std__allocatorT_Arc__Software_t_t__allocator_type swig_types[211]
02720 #define SWIGTYPE_p_std__listT_Arc__Software_std__allocatorT_Arc__Software_t_t__value_type swig_types[212]
02721 #define SWIGTYPE_p_std__listT_Arc__Submitter_p_std__allocatorT_Arc__Submitter_p_t_t swig_types[213]
02722 #define SWIGTYPE_p_std__listT_Arc__TargetRetriever_p_std__allocatorT_Arc__TargetRetriever_p_t_t swig_types[214]
02723 #define SWIGTYPE_p_std__listT_Arc__URLLocation_std__allocatorT_Arc__URLLocation_t_t swig_types[215]
02724 #define SWIGTYPE_p_std__listT_Arc__URL_std__allocatorT_Arc__URL_t_t swig_types[216]
02725 #define SWIGTYPE_p_std__listT_Arc__URL_std__allocatorT_Arc__URL_t_t__allocator_type swig_types[217]
02726 #define SWIGTYPE_p_std__listT_Arc__URL_std__allocatorT_Arc__URL_t_t__value_type swig_types[218]
02727 #define SWIGTYPE_p_std__listT_Arc__XMLNode_p_std__allocatorT_Arc__XMLNode_p_t_t swig_types[219]
02728 #define SWIGTYPE_p_std__listT_Arc__XMLNode_std__allocatorT_Arc__XMLNode_t_t swig_types[220]
02729 #define SWIGTYPE_p_std__listT_Arc__XMLNode_std__allocatorT_Arc__XMLNode_t_t__allocator_type swig_types[221]
02730 #define SWIGTYPE_p_std__listT_Arc__XMLNode_std__allocatorT_Arc__XMLNode_t_t__value_type swig_types[222]
02731 #define SWIGTYPE_p_std__listT_bool_fSoftware__pconst_FfArc__Software_const_RF_std__allocatorT_bool_fSoftware__pconst_FfArc__Software_const_RF_t_t swig_types[223]
02732 #define SWIGTYPE_p_std__listT_std__pairT_std__string_std__string_t_std__allocatorT_std__pairT_std__string_std__string_t_t_t swig_types[224]
02733 #define SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t swig_types[225]
02734 #define SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t__allocator_type swig_types[226]
02735 #define SWIGTYPE_p_std__mapT_Arc__Period_int_std__lessT_Arc__Period_t_std__allocatorT_std__pairT_Arc__Period_const_int_t_t_t swig_types[227]
02736 #define SWIGTYPE_p_std__mapT_std__string_Arc__LoadableModuleDesciption_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Arc__LoadableModuleDesciption_t_t_t swig_types[228]
02737 #define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[229]
02738 #define SWIGTYPE_p_std__mapT_std__string_std__listT_Arc__URL_std__allocatorT_Arc__URL_t_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__listT_Arc__URL_std__allocatorT_Arc__URL_t_t_t_t_t swig_types[230]
02739 #define SWIGTYPE_p_std__mapT_std__string_std__listT_Arc__URL_std__allocatorT_Arc__URL_t_t_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__listT_Arc__URL_std__allocatorT_Arc__URL_t_t_t_t_t__allocator_type swig_types[231]
02740 #define SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t swig_types[232]
02741 #define SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t__allocator_type swig_types[233]
02742 #define SWIGTYPE_p_std__multimapT_std__string_std__string_t swig_types[234]
02743 #define SWIGTYPE_p_std__ostream swig_types[235]
02744 #define SWIGTYPE_p_std__pairT_std__string_double_t swig_types[236]
02745 #define SWIGTYPE_p_std__pairT_std__string_std__string_t swig_types[237]
02746 #define SWIGTYPE_p_std__runtime_error swig_types[238]
02747 #define SWIGTYPE_p_std__string swig_types[239]
02748 #define SWIGTYPE_p_std__vectorT_Arc__URL_std__allocatorT_Arc__URL_t_t swig_types[240]
02749 #define SWIGTYPE_p_std__vectorT_Arc__URL_std__allocatorT_Arc__URL_t_t__allocator_type swig_types[241]
02750 #define SWIGTYPE_p_std__vectorT_Arc__URL_std__allocatorT_Arc__URL_t_t__value_type swig_types[242]
02751 #define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[243]
02752 #define SWIGTYPE_p_swig__PySwigIterator swig_types[244]
02753 #define SWIGTYPE_p_time_t swig_types[245]
02754 #define SWIGTYPE_p_uid_t swig_types[246]
02755 #define SWIGTYPE_p_uint64_t swig_types[247]
02756 #define SWIGTYPE_p_unsigned_int swig_types[248]
02757 #define SWIGTYPE_p_unsigned_long_long swig_types[249]
02758 #define SWIGTYPE_p_value_type swig_types[250]
02759 #define SWIGTYPE_p_void swig_types[251]
02760 #define SWIGTYPE_std__listT_Arc__JobController_p_std__allocatorT_Arc__JobController_p_t_t__value_type swig_types[252]
02761 static swig_type_info *swig_types[254];
02762 static swig_module_info swig_module = {swig_types, 253, 0, 0, 0, 0};
02763 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
02764 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
02765 
02766 /* -------- TYPES TABLE (END) -------- */
02767 
02768 #if (PY_VERSION_HEX <= 0x02000000)
02769 # if !defined(SWIG_PYTHON_CLASSIC)
02770 #  error "This python version requires swig to be run with the '-classic' option"
02771 # endif
02772 #endif
02773 
02774 /*-----------------------------------------------
02775               @(target):= _arc.so
02776   ------------------------------------------------*/
02777 #define SWIG_init    init_arc
02778 
02779 #define SWIG_name    "_arc"
02780 
02781 #define SWIGVERSION 0x010336 
02782 #define SWIG_VERSION SWIGVERSION
02783 
02784 
02785 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
02786 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
02787 
02788 
02789 #include <stdexcept>
02790 
02791 
02792 namespace swig {
02793   class PyObject_ptr {
02794   protected:
02795     PyObject *_obj;
02796 
02797   public:
02798     PyObject_ptr() :_obj(0)
02799     {
02800     }
02801 
02802     PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
02803     {
02804       Py_XINCREF(_obj);      
02805     }
02806     
02807     PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
02808     {
02809       if (initial_ref) {
02810         Py_XINCREF(_obj);
02811       }
02812     }
02813     
02814     PyObject_ptr & operator=(const PyObject_ptr& item) 
02815     {
02816       Py_XINCREF(item._obj);
02817       Py_XDECREF(_obj);
02818       _obj = item._obj;
02819       return *this;      
02820     }
02821     
02822     ~PyObject_ptr() 
02823     {
02824       Py_XDECREF(_obj);
02825     }
02826     
02827     operator PyObject *() const
02828     {
02829       return _obj;
02830     }
02831 
02832     PyObject *operator->() const
02833     {
02834       return _obj;
02835     }
02836   };
02837 }
02838 
02839 
02840 namespace swig {
02841   struct PyObject_var : PyObject_ptr {
02842     PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
02843     
02844     PyObject_var & operator = (PyObject* obj)
02845     {
02846       Py_XDECREF(_obj);
02847       _obj = obj;
02848       return *this;      
02849     }
02850   };
02851 }
02852 
02853 
02854 #include <stdexcept>
02855 
02856 
02857 #if defined(__GNUC__)
02858 #  if __GNUC__ == 2 && __GNUC_MINOR <= 96
02859 #     define SWIG_STD_NOMODERN_STL
02860 #  endif
02861 #endif
02862 
02863 
02864 #include <string>
02865 #include <stdexcept>
02866 
02867 
02868 #include <string>
02869 
02870 
02871 #include <iostream>
02872 
02873   
02874 namespace swig {
02875   struct stop_iteration {
02876   };
02877 
02878   struct PySwigIterator {
02879   private:
02880     PyObject_ptr _seq;
02881 
02882   protected:
02883     PySwigIterator(PyObject *seq) : _seq(seq)
02884     {
02885     }
02886       
02887   public:
02888     virtual ~PySwigIterator() {}
02889 
02890     // Access iterator method, required by Python
02891     virtual PyObject *value() const = 0;
02892 
02893     // Forward iterator method, required by Python
02894     virtual PySwigIterator *incr(size_t n = 1) = 0;
02895     
02896     // Backward iterator method, very common in C++, but not required in Python
02897     virtual PySwigIterator *decr(size_t /*n*/ = 1)
02898     {
02899       throw stop_iteration();
02900     }
02901 
02902     // Random access iterator methods, but not required in Python
02903     virtual ptrdiff_t distance(const PySwigIterator &/*x*/) const
02904     {
02905       throw std::invalid_argument("operation not supported");
02906     }
02907 
02908     virtual bool equal (const PySwigIterator &/*x*/) const
02909     {
02910       throw std::invalid_argument("operation not supported");
02911     }
02912     
02913     // C++ common/needed methods
02914     virtual PySwigIterator *copy() const = 0;
02915 
02916     PyObject *next()     
02917     {
02918       SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
02919       PyObject *obj = value();
02920       incr();       
02921       SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
02922       return obj;     
02923     }
02924 
02925     PyObject *previous()
02926     {
02927       SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
02928       decr();
02929       PyObject *obj = value();
02930       SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
02931       return obj;
02932     }
02933 
02934     PySwigIterator *advance(ptrdiff_t n)
02935     {
02936       return  (n > 0) ?  incr(n) : decr(-n);
02937     }
02938       
02939     bool operator == (const PySwigIterator& x)  const
02940     {
02941       return equal(x);
02942     }
02943       
02944     bool operator != (const PySwigIterator& x) const
02945     {
02946       return ! operator==(x);
02947     }
02948       
02949     PySwigIterator& operator += (ptrdiff_t n)
02950     {
02951       return *advance(n);
02952     }
02953 
02954     PySwigIterator& operator -= (ptrdiff_t n)
02955     {
02956       return *advance(-n);
02957     }
02958       
02959     PySwigIterator* operator + (ptrdiff_t n) const
02960     {
02961       return copy()->advance(n);
02962     }
02963 
02964     PySwigIterator* operator - (ptrdiff_t n) const
02965     {
02966       return copy()->advance(-n);
02967     }
02968       
02969     ptrdiff_t operator - (const PySwigIterator& x) const
02970     {
02971       return x.distance(*this);
02972     }
02973       
02974     static swig_type_info* descriptor() {
02975       static int init = 0;
02976       static swig_type_info* desc = 0;
02977       if (!init) {
02978        desc = SWIG_TypeQuery("swig::PySwigIterator *");
02979        init = 1;
02980       }       
02981       return desc;
02982     }    
02983   };
02984 }
02985 
02986 
02987 SWIGINTERN int
02988 SWIG_AsVal_double (PyObject *obj, double *val)
02989 {
02990   int res = SWIG_TypeError;
02991   if (PyFloat_Check(obj)) {
02992     if (val) *val = PyFloat_AsDouble(obj);
02993     return SWIG_OK;
02994   } else if (PyInt_Check(obj)) {
02995     if (val) *val = PyInt_AsLong(obj);
02996     return SWIG_OK;
02997   } else if (PyLong_Check(obj)) {
02998     double v = PyLong_AsDouble(obj);
02999     if (!PyErr_Occurred()) {
03000       if (val) *val = v;
03001       return SWIG_OK;
03002     } else {
03003       PyErr_Clear();
03004     }
03005   }
03006 #ifdef SWIG_PYTHON_CAST_MODE
03007   {
03008     int dispatch = 0;
03009     double d = PyFloat_AsDouble(obj);
03010     if (!PyErr_Occurred()) {
03011       if (val) *val = d;
03012       return SWIG_AddCast(SWIG_OK);
03013     } else {
03014       PyErr_Clear();
03015     }
03016     if (!dispatch) {
03017       long v = PyLong_AsLong(obj);
03018       if (!PyErr_Occurred()) {
03019        if (val) *val = v;
03020        return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
03021       } else {
03022        PyErr_Clear();
03023       }
03024     }
03025   }
03026 #endif
03027   return res;
03028 }
03029 
03030 
03031 #include <float.h>
03032 
03033 
03034 #include <math.h>
03035 
03036 
03037 SWIGINTERNINLINE int
03038 SWIG_CanCastAsInteger(double *d, double min, double max) {
03039   double x = *d;
03040   if ((min <= x && x <= max)) {
03041    double fx = floor(x);
03042    double cx = ceil(x);
03043    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
03044    if ((errno == EDOM) || (errno == ERANGE)) {
03045      errno = 0;
03046    } else {
03047      double summ, reps, diff;
03048      if (rd < x) {
03049        diff = x - rd;
03050      } else if (rd > x) {
03051        diff = rd - x;
03052      } else {
03053        return 1;
03054      }
03055      summ = rd + x;
03056      reps = diff/summ;
03057      if (reps < 8*DBL_EPSILON) {
03058        *d = rd;
03059        return 1;
03060      }
03061    }
03062   }
03063   return 0;
03064 }
03065 
03066 
03067 SWIGINTERN int
03068 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
03069 {
03070   if (PyInt_Check(obj)) {
03071     long v = PyInt_AsLong(obj);
03072     if (v >= 0) {
03073       if (val) *val = v;
03074       return SWIG_OK;
03075     } else {
03076       return SWIG_OverflowError;
03077     }
03078   } else if (PyLong_Check(obj)) {
03079     unsigned long v = PyLong_AsUnsignedLong(obj);
03080     if (!PyErr_Occurred()) {
03081       if (val) *val = v;
03082       return SWIG_OK;
03083     } else {
03084       PyErr_Clear();
03085     }
03086   }
03087 #ifdef SWIG_PYTHON_CAST_MODE
03088   {
03089     int dispatch = 0;
03090     unsigned long v = PyLong_AsUnsignedLong(obj);
03091     if (!PyErr_Occurred()) {
03092       if (val) *val = v;
03093       return SWIG_AddCast(SWIG_OK);
03094     } else {
03095       PyErr_Clear();
03096     }
03097     if (!dispatch) {
03098       double d;
03099       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
03100       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
03101        if (val) *val = (unsigned long)(d);
03102        return res;
03103       }
03104     }
03105   }
03106 #endif
03107   return SWIG_TypeError;
03108 }
03109 
03110 
03111 SWIGINTERNINLINE int
03112 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
03113 {
03114   unsigned long v;
03115   int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
03116   if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
03117   return res;
03118 }
03119 
03120 
03121   #define SWIG_From_long   PyInt_FromLong 
03122 
03123 
03124 SWIGINTERNINLINE PyObject *
03125 SWIG_From_ptrdiff_t  (ptrdiff_t value)
03126 {    
03127   return SWIG_From_long  (static_cast< long >(value));
03128 }
03129 
03130 
03131 SWIGINTERNINLINE PyObject*
03132   SWIG_From_bool  (bool value)
03133 {
03134   return PyBool_FromLong(value ? 1 : 0);
03135 }
03136 
03137 
03138 SWIGINTERN int
03139 SWIG_AsVal_long (PyObject *obj, long* val)
03140 {
03141   if (PyInt_Check(obj)) {
03142     if (val) *val = PyInt_AsLong(obj);
03143     return SWIG_OK;
03144   } else if (PyLong_Check(obj)) {
03145     long v = PyLong_AsLong(obj);
03146     if (!PyErr_Occurred()) {
03147       if (val) *val = v;
03148       return SWIG_OK;
03149     } else {
03150       PyErr_Clear();
03151     }
03152   }
03153 #ifdef SWIG_PYTHON_CAST_MODE
03154   {
03155     int dispatch = 0;
03156     long v = PyInt_AsLong(obj);
03157     if (!PyErr_Occurred()) {
03158       if (val) *val = v;
03159       return SWIG_AddCast(SWIG_OK);
03160     } else {
03161       PyErr_Clear();
03162     }
03163     if (!dispatch) {
03164       double d;
03165       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
03166       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
03167        if (val) *val = (long)(d);
03168        return res;
03169       }
03170     }
03171   }
03172 #endif
03173   return SWIG_TypeError;
03174 }
03175 
03176 
03177 SWIGINTERNINLINE int
03178 SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
03179 {
03180   long v;
03181   int res = SWIG_AsVal_long (obj, val ? &v : 0);
03182   if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
03183   return res;
03184 }
03185 
03186 
03187 #include <stdexcept>
03188 
03189 
03190 #include <algorithm>
03191 
03192 
03193 #include <vector>
03194 
03195 
03196 #include <utility>
03197 
03198 
03199 #include <map>
03200 #include <algorithm>
03201 #include <stdexcept>
03202 
03203 
03204 #include <list>
03205 
03206 
03207 namespace swig {  
03208   template <class Type>
03209   struct noconst_traits {
03210     typedef Type noconst_type;
03211   };
03212 
03213   template <class Type>
03214   struct noconst_traits<const Type> {
03215     typedef Type noconst_type;
03216   };
03217 
03218   /*
03219     type categories
03220   */
03221   struct pointer_category { };  
03222   struct value_category { };
03223 
03224   /*
03225     General traits that provides type_name and type_info
03226   */
03227   template <class Type> struct traits { };
03228 
03229   template <class Type>
03230   inline const char* type_name() {
03231     return traits<typename noconst_traits<Type >::noconst_type >::type_name();
03232   }
03233 
03234   template <class Type> 
03235   struct traits_info {
03236     static swig_type_info *type_query(std::string name) {
03237       name += " *";
03238       return SWIG_TypeQuery(name.c_str());
03239     }    
03240     static swig_type_info *type_info() {
03241       static swig_type_info *info = type_query(type_name<Type>());
03242       return info;
03243     }
03244   };
03245 
03246   template <class Type>
03247   inline swig_type_info *type_info() {
03248     return traits_info<Type>::type_info();
03249   }
03250 
03251   /*
03252     Partial specialization for pointers
03253   */
03254   template <class Type> struct traits <Type *> {
03255     typedef pointer_category category;
03256     static std::string make_ptr_name(const char* name) {
03257       std::string ptrname = name;
03258       ptrname += " *";
03259       return ptrname;
03260     }    
03261     static const char* type_name() {
03262       static std::string name = make_ptr_name(swig::type_name<Type>());
03263       return name.c_str();
03264     }
03265   };
03266 
03267   template <class Type, class Category> 
03268   struct traits_as { };
03269  
03270   template <class Type, class Category> 
03271   struct traits_check { };
03272 
03273 }
03274 
03275 
03276 namespace swig {  
03277   /*
03278     Traits that provides the from method
03279   */
03280   template <class Type> struct traits_from_ptr {
03281     static PyObject *from(Type *val, int owner = 0) {
03282       return SWIG_NewPointerObj(val, type_info<Type>(), owner);
03283     }
03284   };
03285 
03286   template <class Type> struct traits_from {
03287     static PyObject *from(const Type& val) {
03288       return traits_from_ptr<Type>::from(new Type(val), 1);
03289     }
03290   };
03291 
03292   template <class Type> struct traits_from<Type *> {
03293     static PyObject *from(Type* val) {
03294       return traits_from_ptr<Type>::from(val, 0);
03295     }
03296   };
03297 
03298   template <class Type> struct traits_from<const Type *> {
03299     static PyObject *from(const Type* val) {
03300       return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
03301     }
03302   };
03303 
03304 
03305   template <class Type>
03306   inline PyObject *from(const Type& val) {
03307     return traits_from<Type>::from(val);
03308   }
03309 
03310   template <class Type>
03311   inline PyObject *from_ptr(Type* val, int owner) {
03312     return traits_from_ptr<Type>::from(val, owner);
03313   }
03314 
03315   /*
03316     Traits that provides the asval/as/check method
03317   */
03318   template <class Type>
03319   struct traits_asptr {   
03320     static int asptr(PyObject *obj, Type **val) {
03321       Type *p;
03322       int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
03323       if (SWIG_IsOK(res)) {
03324        if (val) *val = p;
03325       }
03326       return res;
03327     }
03328   }; 
03329 
03330   template <class Type>
03331   inline int asptr(PyObject *obj, Type **vptr) {
03332     return traits_asptr<Type>::asptr(obj, vptr);
03333   }
03334 
03335   template <class Type> 
03336   struct traits_asval {
03337     static int asval(PyObject *obj, Type *val) {
03338       if (val) {
03339        Type *p = 0;
03340        int res = traits_asptr<Type>::asptr(obj, &p);
03341        if (!SWIG_IsOK(res)) return res;   
03342        if (p) {
03343          typedef typename noconst_traits<Type>::noconst_type noconst_type;
03344          *(const_cast<noconst_type*>(val)) = *p;
03345          if (SWIG_IsNewObj(res)){
03346            delete p;
03347            res = SWIG_DelNewMask(res);
03348          }
03349          return res;
03350        } else {
03351          return SWIG_ERROR;
03352        }
03353       } else {
03354        return traits_asptr<Type>::asptr(obj, (Type **)(0));
03355       }
03356     }
03357   };
03358 
03359   template <class Type> struct traits_asval<Type*> {
03360     static int asval(PyObject *obj, Type **val) {
03361       if (val) {
03362         typedef typename noconst_traits<Type>::noconst_type noconst_type;
03363         noconst_type *p = 0;
03364         int res = traits_asptr<noconst_type>::asptr(obj,  &p);
03365         if (SWIG_IsOK(res)) {
03366           *(const_cast<noconst_type**>(val)) = p;
03367        }
03368        return res;
03369       } else {
03370        return traits_asptr<Type>::asptr(obj, (Type **)(0));
03371       }
03372     }
03373   };
03374   
03375   template <class Type>
03376   inline int asval(PyObject *obj, Type *val) {
03377     return traits_asval<Type>::asval(obj, val);
03378   }
03379 
03380   template <class Type> 
03381   struct traits_as<Type, value_category> {
03382     static Type as(PyObject *obj, bool throw_error) {
03383       Type v;
03384       int res = asval(obj, &v);
03385       if (!obj || !SWIG_IsOK(res)) {
03386        if (!PyErr_Occurred()) {
03387          ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
03388        }
03389        if (throw_error) throw std::invalid_argument("bad type");
03390       }
03391       return v;
03392     }
03393   };
03394 
03395   template <class Type> 
03396   struct traits_as<Type, pointer_category> {
03397     static Type as(PyObject *obj, bool throw_error) {
03398       Type *v = 0;      
03399       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
03400       if (SWIG_IsOK(res) && v) {
03401        if (SWIG_IsNewObj(res)) {
03402          Type r(*v);
03403          delete v;
03404          return r;
03405        } else {
03406          return *v;
03407        }
03408       } else {
03409        // Uninitialized return value, no Type() constructor required.
03410        static Type *v_def = (Type*) malloc(sizeof(Type));
03411        if (!PyErr_Occurred()) {
03412          SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
03413        }
03414        if (throw_error) throw std::invalid_argument("bad type");
03415        memset(v_def,0,sizeof(Type));
03416        return *v_def;
03417       }
03418     }
03419   };
03420 
03421   template <class Type> 
03422   struct traits_as<Type*, pointer_category> {
03423     static Type* as(PyObject *obj, bool throw_error) {
03424       Type *v = 0;      
03425       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
03426       if (SWIG_IsOK(res)) {
03427        return v;
03428       } else {
03429        if (!PyErr_Occurred()) {
03430          SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
03431        }
03432        if (throw_error) throw std::invalid_argument("bad type");
03433        return 0;
03434       }
03435     }
03436   };
03437     
03438   template <class Type>
03439   inline Type as(PyObject *obj, bool te = false) {
03440     return traits_as<Type, typename traits<Type>::category>::as(obj, te);
03441   }
03442 
03443   template <class Type> 
03444   struct traits_check<Type, value_category> {
03445     static bool check(PyObject *obj) {
03446       int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
03447       return SWIG_IsOK(res) ? true : false;
03448     }
03449   };
03450 
03451   template <class Type> 
03452   struct traits_check<Type, pointer_category> {
03453     static bool check(PyObject *obj) {
03454       int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
03455       return SWIG_IsOK(res) ? true : false;
03456     }
03457   };
03458 
03459   template <class Type>
03460   inline bool check(PyObject *obj) {
03461     return traits_check<Type, typename traits<Type>::category>::check(obj);
03462   }
03463 }
03464 
03465 
03466 #include <functional>
03467 
03468 namespace std {
03469   template <>
03470   struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
03471   {
03472     bool
03473     operator()(PyObject * v, PyObject *w) const
03474     { 
03475       bool res;
03476       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
03477       res = PyObject_Compare(v, w) < 0;
03478       SWIG_PYTHON_THREAD_END_BLOCK;
03479       return res;
03480     }
03481   };
03482 
03483   template <>
03484   struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
03485   {
03486     bool
03487     operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
03488     {
03489       return std::less<PyObject *>()(v, w);
03490     }
03491   };
03492 
03493   template <>
03494   struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
03495   {
03496     bool
03497     operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
03498     {
03499       return std::less<PyObject *>()(v, w);
03500     }
03501   };
03502 
03503 }
03504 
03505 namespace swig {
03506   template <> struct traits<PyObject *> {
03507     typedef value_category category;
03508     static const char* type_name() { return "PyObject *"; }
03509   };  
03510 
03511   template <>  struct traits_asval<PyObject * > {   
03512     typedef PyObject * value_type;
03513     static int asval(PyObject *obj, value_type *val) {
03514       if (val) *val = obj;
03515       return SWIG_OK;
03516     }
03517   };
03518 
03519   template <> 
03520   struct traits_check<PyObject *, value_category> {
03521     static bool check(PyObject *) {
03522       return true;
03523     }
03524   };
03525 
03526   template <>  struct traits_from<PyObject *> {
03527     typedef PyObject * value_type;
03528     static PyObject *from(const value_type& val) {
03529       Py_XINCREF(val);
03530       return val;
03531     }
03532   };
03533   
03534 }
03535 
03536 namespace swig {
03537   inline size_t
03538   check_index(ptrdiff_t i, size_t size, bool insert = false) {
03539     if ( i < 0 ) {
03540       if ((size_t) (-i) <= size)
03541        return (size_t) (i + size);
03542     } else if ( (size_t) i < size ) {
03543       return (size_t) i;
03544     } else if (insert && ((size_t) i == size)) {
03545       return size;
03546     }
03547     
03548     throw std::out_of_range("index out of range");
03549   }
03550 
03551   inline size_t
03552   slice_index(ptrdiff_t i, size_t size) {
03553     if ( i < 0 ) {
03554       if ((size_t) (-i) <= size) {
03555        return (size_t) (i + size);
03556       } else {
03557        throw std::out_of_range("index out of range");
03558       }
03559     } else {
03560       return ( (size_t) i < size ) ? ((size_t) i) : size;
03561     }
03562   }
03563 
03564   template <class Sequence, class Difference>
03565   inline typename Sequence::iterator
03566   getpos(Sequence* self, Difference i)  {
03567     typename Sequence::iterator pos = self->begin();
03568     std::advance(pos, check_index(i,self->size()));
03569     return pos;
03570   }
03571 
03572   template <class Sequence, class Difference>
03573   inline typename Sequence::const_iterator
03574   cgetpos(const Sequence* self, Difference i)  {
03575     typename Sequence::const_iterator pos = self->begin();
03576     std::advance(pos, check_index(i,self->size()));
03577     return pos;
03578   }
03579 
03580   template <class Sequence, class Difference>
03581   inline Sequence*
03582   getslice(const Sequence* self, Difference i, Difference j) {
03583     typename Sequence::size_type size = self->size();
03584     typename Sequence::size_type ii = swig::check_index(i, size);
03585     typename Sequence::size_type jj = swig::slice_index(j, size);
03586 
03587     if (jj > ii) {
03588       typename Sequence::const_iterator vb = self->begin();
03589       typename Sequence::const_iterator ve = self->begin();
03590       std::advance(vb,ii);
03591       std::advance(ve,jj);
03592       return new Sequence(vb, ve);
03593     } else {
03594       return new Sequence();
03595     }
03596   }
03597 
03598   template <class Sequence, class Difference, class InputSeq>
03599   inline void
03600   setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
03601     typename Sequence::size_type size = self->size();
03602     typename Sequence::size_type ii = swig::check_index(i, size, true);
03603     typename Sequence::size_type jj = swig::slice_index(j, size);
03604     if (jj < ii) jj = ii;
03605     size_t ssize = jj - ii;
03606     if (ssize <= v.size()) {
03607       typename Sequence::iterator sb = self->begin();
03608       typename InputSeq::const_iterator vmid = v.begin();
03609       std::advance(sb,ii);
03610       std::advance(vmid, jj - ii);
03611       self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
03612     } else {
03613       typename Sequence::iterator sb = self->begin();
03614       typename Sequence::iterator se = self->begin();
03615       std::advance(sb,ii);
03616       std::advance(se,jj);
03617       self->erase(sb,se);
03618       self->insert(sb, v.begin(), v.end());
03619     }
03620   }
03621 
03622   template <class Sequence, class Difference>
03623   inline void
03624   delslice(Sequence* self, Difference i, Difference j) {
03625     typename Sequence::size_type size = self->size();
03626     typename Sequence::size_type ii = swig::check_index(i, size, true);
03627     typename Sequence::size_type jj = swig::slice_index(j, size);
03628     if (jj > ii) {
03629       typename Sequence::iterator sb = self->begin();
03630       typename Sequence::iterator se = self->begin();
03631       std::advance(sb,ii);
03632       std::advance(se,jj);
03633       self->erase(sb,se);
03634     }
03635   }
03636 }
03637 
03638 
03639 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
03640 #  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
03641 #    define SWIG_STD_NOITERATOR_TRAITS_STL
03642 #  endif
03643 #endif
03644 
03645 #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
03646 #include <iterator>
03647 #else
03648 namespace std {
03649   template <class Iterator>
03650   struct iterator_traits {
03651     typedef ptrdiff_t difference_type;
03652     typedef typename Iterator::value_type value_type;
03653   };
03654 
03655   template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
03656   struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
03657     typedef Distance difference_type;
03658     typedef T value_type;
03659   };
03660 
03661   template <class T>
03662   struct iterator_traits<T*> {
03663     typedef T value_type;
03664     typedef ptrdiff_t difference_type;
03665   };
03666 
03667   template<typename _InputIterator>
03668   inline typename iterator_traits<_InputIterator>::difference_type
03669   distance(_InputIterator __first, _InputIterator __last)
03670   {
03671     typename iterator_traits<_InputIterator>::difference_type __n = 0;
03672     while (__first != __last) {
03673       ++__first; ++__n;
03674     }
03675     return __n;
03676   }
03677 }
03678 #endif
03679 
03680 
03681 namespace swig {
03682   template<typename OutIterator>
03683   class PySwigIterator_T :  public PySwigIterator
03684   {
03685   public:
03686     typedef OutIterator out_iterator;
03687     typedef typename std::iterator_traits<out_iterator>::value_type value_type;    
03688     typedef PySwigIterator_T<out_iterator> self_type;
03689 
03690     PySwigIterator_T(out_iterator curr, PyObject *seq)
03691       : PySwigIterator(seq), current(curr)
03692     {
03693     }
03694 
03695     const out_iterator& get_current() const
03696     {
03697       return current;
03698     }
03699 
03700     
03701     bool equal (const PySwigIterator &iter) const
03702     {
03703       const self_type *iters = dynamic_cast<const self_type *>(&iter);
03704       if (iters) {
03705        return (current == iters->get_current());
03706       } else {
03707        throw std::invalid_argument("bad iterator type");
03708       }
03709     }
03710     
03711     ptrdiff_t distance(const PySwigIterator &iter) const
03712     {
03713       const self_type *iters = dynamic_cast<const self_type *>(&iter);
03714       if (iters) {
03715        return std::distance(current, iters->get_current());
03716       } else {
03717        throw std::invalid_argument("bad iterator type");
03718       }
03719     }    
03720     
03721   protected:
03722     out_iterator current;
03723   };
03724   
03725   template <class ValueType>
03726   struct from_oper 
03727   {
03728     typedef const ValueType& argument_type;
03729     typedef PyObject *result_type;
03730     result_type operator()(argument_type v) const
03731     {
03732       return swig::from(v);
03733     }
03734   };
03735 
03736   template<typename OutIterator, 
03737           typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
03738           typename FromOper = from_oper<ValueType> >
03739   class PySwigIteratorOpen_T :  public PySwigIterator_T<OutIterator>
03740   {
03741   public:
03742     FromOper from;
03743     typedef OutIterator out_iterator;
03744     typedef ValueType value_type;
03745     typedef PySwigIterator_T<out_iterator>  base;
03746     typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
03747     
03748     PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
03749       : PySwigIterator_T<OutIterator>(curr, seq)
03750     {
03751     }
03752     
03753     PyObject *value() const {
03754       return from(static_cast<const value_type&>(*(base::current)));
03755     }
03756     
03757     PySwigIterator *copy() const
03758     {
03759       return new self_type(*this);
03760     }
03761 
03762     PySwigIterator *incr(size_t n = 1)
03763     {
03764       while (n--) {
03765        ++base::current;
03766       }
03767       return this;
03768     }
03769 
03770     PySwigIterator *decr(size_t n = 1)
03771     {
03772       while (n--) {
03773        --base::current;
03774       }
03775       return this;
03776     }
03777   };
03778 
03779   template<typename OutIterator, 
03780           typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
03781           typename FromOper = from_oper<ValueType> >
03782   class PySwigIteratorClosed_T :  public PySwigIterator_T<OutIterator>
03783   {
03784   public:
03785     FromOper from;
03786     typedef OutIterator out_iterator;
03787     typedef ValueType value_type;
03788     typedef PySwigIterator_T<out_iterator>  base;    
03789     typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
03790     
03791     PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
03792       : PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
03793     {
03794     }
03795     
03796     PyObject *value() const {
03797       if (base::current == end) {
03798        throw stop_iteration();
03799       } else {
03800        return from(static_cast<const value_type&>(*(base::current)));
03801       }
03802     }
03803     
03804     PySwigIterator *copy() const
03805     {
03806       return new self_type(*this);
03807     }
03808 
03809     PySwigIterator *incr(size_t n = 1)
03810     {
03811       while (n--) {
03812        if (base::current == end) {
03813          throw stop_iteration();
03814        } else {
03815          ++base::current;
03816        }
03817       }
03818       return this;
03819     }
03820 
03821     PySwigIterator *decr(size_t n = 1)
03822     {
03823       while (n--) {
03824        if (base::current == begin) {
03825          throw stop_iteration();
03826        } else {
03827          --base::current;
03828        }
03829       }
03830       return this;
03831     }
03832 
03833   private:
03834     out_iterator begin;
03835     out_iterator end;
03836   };
03837 
03838   template<typename OutIter>
03839   inline PySwigIterator*
03840   make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
03841   {
03842     return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
03843   }
03844 
03845   template<typename OutIter>
03846   inline PySwigIterator*
03847   make_output_iterator(const OutIter& current, PyObject *seq = 0)
03848   {
03849     return new PySwigIteratorOpen_T<OutIter>(current, seq);
03850   }
03851 }
03852 
03853 
03854 namespace swig
03855 {
03856   template <class T>
03857   struct PySequence_Ref
03858   {
03859     PySequence_Ref(PyObject* seq, int index)
03860       : _seq(seq), _index(index)
03861     {
03862     }
03863     
03864     operator T () const
03865     {
03866       swig::PyObject_var item = PySequence_GetItem(_seq, _index);
03867       try {
03868        return swig::as<T>(item, true);
03869       } catch (std::exception& e) {
03870        char msg[1024];
03871        sprintf(msg, "in sequence element %d ", _index);
03872        if (!PyErr_Occurred()) {
03873          ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
03874        }
03875        SWIG_Python_AddErrorMsg(msg);
03876        SWIG_Python_AddErrorMsg(e.what());
03877        throw;
03878       }
03879     }
03880 
03881     PySequence_Ref& operator=(const T& v)
03882     {
03883       PySequence_SetItem(_seq, _index, swig::from<T>(v));
03884       return *this;
03885     }
03886 
03887   private:
03888     PyObject* _seq;
03889     int _index;
03890   };
03891 
03892   template <class T>
03893   struct PySequence_ArrowProxy
03894   {
03895     PySequence_ArrowProxy(const T& x): m_value(x) {}
03896     const T* operator->() const { return &m_value; }
03897     operator const T*() const { return &m_value; }
03898     T m_value;
03899   };
03900 
03901   template <class T, class Reference >
03902   struct PySequence_InputIterator
03903   {
03904     typedef PySequence_InputIterator<T, Reference > self;
03905 
03906     typedef std::random_access_iterator_tag iterator_category;
03907     typedef Reference reference;
03908     typedef T value_type;
03909     typedef T* pointer;
03910     typedef int difference_type;
03911 
03912     PySequence_InputIterator()
03913     {
03914     }
03915 
03916     PySequence_InputIterator(PyObject* seq, int index)
03917       : _seq(seq), _index(index)
03918     {
03919     }
03920 
03921     reference operator*() const
03922     {
03923       return reference(_seq, _index);
03924     }
03925 
03926     PySequence_ArrowProxy<T>
03927     operator->() const {
03928       return PySequence_ArrowProxy<T>(operator*());
03929     }
03930 
03931     bool operator==(const self& ri) const
03932     {
03933       return (_index == ri._index) && (_seq == ri._seq);
03934     }
03935 
03936     bool operator!=(const self& ri) const
03937     {
03938       return !(operator==(ri));
03939     }
03940 
03941     self& operator ++ ()
03942     {
03943       ++_index;
03944       return *this;
03945     }
03946 
03947     self& operator -- ()
03948     {
03949       --_index;
03950       return *this;
03951     }
03952 
03953     self& operator += (difference_type n)
03954     {
03955       _index += n;
03956       return *this;
03957     }
03958 
03959     self operator +(difference_type n) const
03960     {
03961       return self(_seq, _index + n);
03962     }
03963 
03964     self& operator -= (difference_type n)
03965     {
03966       _index -= n;
03967       return *this;
03968     }
03969 
03970     self operator -(difference_type n) const
03971     {
03972       return self(_seq, _index - n);
03973     }
03974 
03975     difference_type operator - (const self& ri) const
03976     {
03977       return _index - ri._index;
03978     }
03979 
03980     bool operator < (const self& ri) const
03981     {
03982       return _index < ri._index;
03983     }
03984 
03985     reference
03986     operator[](difference_type n) const
03987     {
03988       return reference(_seq, _index + n);
03989     }
03990 
03991   private:
03992     PyObject* _seq;
03993     difference_type _index;
03994   };
03995 
03996   template <class T>
03997   struct PySequence_Cont
03998   {
03999     typedef PySequence_Ref<T> reference;
04000     typedef const PySequence_Ref<T> const_reference;
04001     typedef T value_type;
04002     typedef T* pointer;
04003     typedef int difference_type;
04004     typedef int size_type;
04005     typedef const pointer const_pointer;
04006     typedef PySequence_InputIterator<T, reference> iterator;
04007     typedef PySequence_InputIterator<T, const_reference> const_iterator;
04008 
04009     PySequence_Cont(PyObject* seq) : _seq(0)
04010     {
04011       if (!PySequence_Check(seq)) {
04012        throw std::invalid_argument("a sequence is expected");
04013       }
04014       _seq = seq;
04015       Py_INCREF(_seq);
04016     }
04017 
04018     ~PySequence_Cont()
04019     {
04020       Py_XDECREF(_seq);
04021     }
04022 
04023     size_type size() const
04024     {
04025       return static_cast<size_type>(PySequence_Size(_seq));
04026     }
04027 
04028     bool empty() const
04029     {
04030       return size() == 0;
04031     }
04032 
04033     iterator begin()
04034     {
04035       return iterator(_seq, 0);
04036     }
04037 
04038     const_iterator begin() const
04039     {
04040       return const_iterator(_seq, 0);
04041     }
04042 
04043     iterator end()
04044     {
04045       return iterator(_seq, size());
04046     }
04047 
04048     const_iterator end() const
04049     {
04050       return const_iterator(_seq, size());
04051     }
04052 
04053     reference operator[](difference_type n)
04054     {
04055       return reference(_seq, n);
04056     }
04057 
04058     const_reference operator[](difference_type n)  const
04059     {
04060       return const_reference(_seq, n);
04061     }
04062 
04063     bool check(bool set_err = true) const
04064     {
04065       int s = size();
04066       for (int i = 0; i < s; ++i) {
04067        swig::PyObject_var item = PySequence_GetItem(_seq, i);
04068        if (!swig::check<value_type>(item)) {
04069          if (set_err) {
04070            char msg[1024];
04071            sprintf(msg, "in sequence element %d", i);
04072            SWIG_Error(SWIG_RuntimeError, msg);
04073          }
04074          return false;
04075        }
04076       }
04077       return true;
04078     }
04079 
04080   private:
04081     PyObject* _seq;
04082   };
04083 
04084 }
04085 
04086 
04087 SWIGINTERN swig_type_info*
04088 SWIG_pchar_descriptor(void)
04089 {
04090   static int init = 0;
04091   static swig_type_info* info = 0;
04092   if (!init) {
04093     info = SWIG_TypeQuery("_p_char");
04094     init = 1;
04095   }
04096   return info;
04097 }
04098 
04099 
04100 SWIGINTERN int
04101 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
04102 {
04103   if (PyString_Check(obj)) {
04104     char *cstr; Py_ssize_t len;
04105     PyString_AsStringAndSize(obj, &cstr, &len);
04106     if (cptr)  {
04107       if (alloc) {
04108        /* 
04109           In python the user should not be able to modify the inner
04110           string representation. To warranty that, if you define
04111           SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
04112           buffer is always returned.
04113 
04114           The default behavior is just to return the pointer value,
04115           so, be careful.
04116        */ 
04117 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
04118        if (*alloc != SWIG_OLDOBJ) 
04119 #else
04120        if (*alloc == SWIG_NEWOBJ) 
04121 #endif
04122          {
04123            *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
04124            *alloc = SWIG_NEWOBJ;
04125          }
04126        else {
04127          *cptr = cstr;
04128          *alloc = SWIG_OLDOBJ;
04129        }
04130       } else {
04131        *cptr = PyString_AsString(obj);
04132       }
04133     }
04134     if (psize) *psize = len + 1;
04135     return SWIG_OK;
04136   } else {
04137     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
04138     if (pchar_descriptor) {
04139       void* vptr = 0;
04140       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
04141        if (cptr) *cptr = (char *) vptr;
04142        if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
04143        if (alloc) *alloc = SWIG_OLDOBJ;
04144        return SWIG_OK;
04145       }
04146     }
04147   }
04148   return SWIG_TypeError;
04149 }
04150 
04151 
04152 SWIGINTERN int
04153 SWIG_AsPtr_std_string (PyObject * obj, std::string **val) 
04154 {
04155   char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
04156   if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
04157     if (buf) {
04158       if (val) *val = new std::string(buf, size - 1);
04159       if (alloc == SWIG_NEWOBJ) delete[] buf;
04160       return SWIG_NEWOBJ;
04161     } else {
04162       if (val) *val = 0;
04163       return SWIG_OLDOBJ;
04164     }
04165   } else {
04166     static int init = 0;
04167     static swig_type_info* descriptor = 0;
04168     if (!init) {
04169       descriptor = SWIG_TypeQuery("std::string" " *");
04170       init = 1;
04171     }
04172     if (descriptor) {
04173       std::string *vptr;
04174       int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
04175       if (SWIG_IsOK(res) && val) *val = vptr;
04176       return res;
04177     }
04178   }
04179   return SWIG_ERROR;
04180 }
04181 
04182 
04183 SWIGINTERN int
04184 SWIG_AsVal_std_string (PyObject * obj, std::string *val)
04185 {
04186   std::string* v = (std::string *) 0;
04187   int res = SWIG_AsPtr_std_string (obj, &v);
04188   if (!SWIG_IsOK(res)) return res;
04189   if (v) {
04190     if (val) *val = *v;
04191     if (SWIG_IsNewObj(res)) {
04192       delete v;
04193       res = SWIG_DelNewMask(res);
04194     }
04195     return res;
04196   }
04197   return SWIG_ERROR;
04198 }
04199 
04200 
04201 SWIGINTERNINLINE PyObject *
04202 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
04203 {
04204   if (carray) {
04205     if (size > INT_MAX) {
04206       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
04207       return pchar_descriptor ? 
04208        SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
04209     } else {
04210       return PyString_FromStringAndSize(carray, static_cast< int >(size));
04211     }
04212   } else {
04213     return SWIG_Py_Void();
04214   }
04215 }
04216 
04217 
04218 SWIGINTERNINLINE PyObject *
04219 SWIG_From_std_string  (const std::string& s)
04220 {
04221   if (s.size()) {
04222     return SWIG_FromCharPtrAndSize(s.data(), s.size());
04223   } else {
04224     return SWIG_FromCharPtrAndSize(s.c_str(), 0);
04225   }
04226 }
04227 
04228 
04229 namespace swig {
04230   template <> struct traits<std::string > {
04231     typedef value_category category;
04232     static const char* type_name() { return"std::string"; }
04233   };  
04234   template <>  struct traits_asval<std::string > {   
04235     typedef std::string value_type;
04236     static int asval(PyObject *obj, value_type *val) { 
04237       return SWIG_AsVal_std_string (obj, val);
04238     }
04239   };
04240   template <>  struct traits_from<std::string > {
04241     typedef std::string value_type;
04242     static PyObject *from(const value_type& val) {
04243       return SWIG_From_std_string  (val);
04244     }
04245   };
04246 }
04247 
04248 
04249 namespace swig {
04250   template <class PySeq, class Seq>
04251   inline void
04252   assign(const PySeq& pyseq, Seq* seq) {
04253     // seq->assign(pyseq.begin(), pyseq.end()); // not used as not always implemented
04254     typedef typename PySeq::value_type value_type;
04255     typename PySeq::const_iterator it = pyseq.begin();
04256     for (;it != pyseq.end(); ++it) {
04257       seq->insert(seq->end(),(value_type)(*it));
04258     }
04259   }
04260 
04261   template <class Seq, class T = typename Seq::value_type >
04262   struct traits_asptr_stdseq {
04263     typedef Seq sequence;
04264     typedef T value_type;
04265 
04266     static int asptr(PyObject *obj, sequence **seq) {
04267       if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
04268        sequence *p;
04269        if (::SWIG_ConvertPtr(obj,(void**)&p,
04270                            swig::type_info<sequence>(),0) == SWIG_OK) {
04271          if (seq) *seq = p;
04272          return SWIG_OLDOBJ;
04273        }
04274       } else if (PySequence_Check(obj)) {
04275        try {
04276          PySequence_Cont<value_type> pyseq(obj);
04277          if (seq) {
04278            sequence *pseq = new sequence();
04279            assign(pyseq, pseq);
04280            *seq = pseq;
04281            return SWIG_NEWOBJ;
04282          } else {
04283            return pyseq.check() ? SWIG_OK : SWIG_ERROR;
04284          }
04285        } catch (std::exception& e) {
04286          if (seq) {
04287            if (!PyErr_Occurred()) {
04288              PyErr_SetString(PyExc_TypeError, e.what());
04289            }
04290          }
04291          return SWIG_ERROR;
04292        }
04293       }
04294       return SWIG_ERROR;
04295     }
04296   };
04297 
04298   template <class Seq, class T = typename Seq::value_type >
04299   struct traits_from_stdseq {
04300     typedef Seq sequence;
04301     typedef T value_type;
04302     typedef typename Seq::size_type size_type;
04303     typedef typename sequence::const_iterator const_iterator;
04304 
04305     static PyObject *from(const sequence& seq) {
04306 #ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
04307       swig_type_info *desc = swig::type_info<sequence>();
04308       if (desc && desc->clientdata) {
04309        return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
04310       }
04311 #endif
04312       size_type size = seq.size();
04313       if (size <= (size_type)INT_MAX) {
04314        PyObject *obj = PyTuple_New((int)size);
04315        int i = 0;
04316        for (const_iterator it = seq.begin();
04317             it != seq.end(); ++it, ++i) {
04318          PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
04319        }
04320        return obj;
04321       } else {
04322        PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
04323        return NULL;
04324       }
04325     }
04326   };
04327 }
04328 
04329 
04330   namespace swig {
04331     template <class T >
04332     struct traits_asptr<std::list<T> >  {
04333       static int asptr(PyObject *obj, std::list<T> **lis) {
04334        return traits_asptr_stdseq<std::list<T> >::asptr(obj, lis);
04335       }
04336     };
04337 
04338     template <class T>
04339     struct traits_from<std::list<T> > {
04340       static PyObject *from(const std::list<T> & vec) {
04341        return traits_from_stdseq<std::list<T> >::from(vec);
04342       }
04343     };
04344   }
04345 
04346 
04347       namespace swig {
04348        template <>  struct traits<std::list<std::string, std::allocator< std::string > > > {
04349          typedef pointer_category category;
04350          static const char* type_name() {
04351            return "std::list<" "std::string" ", " "std::allocator< std::string >" " >";
04352          }
04353        };
04354       }
04355     
04356 SWIGINTERN swig::PySwigIterator *std_list_Sl_std_string_Sg__iterator(std::list< std::string > *self,PyObject **PYTHON_SELF){
04357       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
04358     }
04359 SWIGINTERN bool std_list_Sl_std_string_Sg____nonzero__(std::list< std::string > const *self){
04360       return !(self->empty());
04361     }
04362 SWIGINTERN std::list< std::string >::size_type std_list_Sl_std_string_Sg____len__(std::list< std::string > const *self){
04363       return self->size();
04364     }
04365 
04366 SWIGINTERNINLINE PyObject* 
04367 SWIG_From_unsigned_SS_long  (unsigned long value)
04368 {
04369   return (value > LONG_MAX) ?
04370     PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value)); 
04371 }
04372 
04373 
04374 SWIGINTERNINLINE PyObject *
04375 SWIG_From_size_t  (size_t value)
04376 {    
04377   return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
04378 }
04379 
04380 SWIGINTERN std::list< std::string >::value_type std_list_Sl_std_string_Sg__pop(std::list< std::string > *self){
04381       if (self->size() == 0)
04382        throw std::out_of_range("pop from empty container");
04383       std::list<std::string,std::allocator< std::string > >::value_type x = self->back();
04384       self->pop_back();
04385       return x;
04386     }
04387 SWIGINTERN std::list< std::string,std::allocator< std::string > > *std_list_Sl_std_string_Sg____getslice__(std::list< std::string > *self,std::list< std::string >::difference_type i,std::list< std::string >::difference_type j){
04388       return swig::getslice(self, i, j);
04389     }
04390 SWIGINTERN void std_list_Sl_std_string_Sg____setslice__(std::list< std::string > *self,std::list< std::string >::difference_type i,std::list< std::string >::difference_type j,std::list< std::string,std::allocator< std::string > > const &v){
04391       swig::setslice(self, i, j, v);
04392     }
04393 SWIGINTERN void std_list_Sl_std_string_Sg____delslice__(std::list< std::string > *self,std::list< std::string >::difference_type i,std::list< std::string >::difference_type j){
04394       swig::delslice(self, i, j);
04395     }
04396 SWIGINTERN void std_list_Sl_std_string_Sg____delitem__(std::list< std::string > *self,std::list< std::string >::difference_type i){
04397       self->erase(swig::getpos(self,i));
04398     }
04399 SWIGINTERN std::list< std::string >::value_type const &std_list_Sl_std_string_Sg____getitem__(std::list< std::string > const *self,std::list< std::string >::difference_type i){
04400       return *(swig::cgetpos(self, i));
04401     }
04402 SWIGINTERN void std_list_Sl_std_string_Sg____setitem__(std::list< std::string > *self,std::list< std::string >::difference_type i,std::list< std::string >::value_type const &x){
04403       *(swig::getpos(self,i)) = x;
04404     }
04405 SWIGINTERN void std_list_Sl_std_string_Sg__append(std::list< std::string > *self,std::list< std::string >::value_type const &x){
04406       self->push_back(x);
04407     }
04408 
04409   namespace swig {
04410 
04411 
04412 
04413 
04414 
04415 
04416 
04417 
04418 
04419 
04420 
04421 
04422 
04423 
04424 
04425 
04426 
04427 
04428 
04429 
04430 
04431 
04432 
04433 
04434 
04435 
04436 
04437 
04438 
04439 
04440 
04441 
04442 
04443 
04444 
04445 
04446 
04447 
04448 
04449 
04450 
04451 
04452 
04453 
04454 
04455 
04456 
04457 
04458 
04459     template <class T, class U >
04460     struct traits_asptr<std::pair<T,U> >  {
04461       typedef std::pair<T,U> value_type;
04462 
04463       static int get_pair(PyObject* first, PyObject* second,
04464                        std::pair<T,U> **val) 
04465       {
04466        if (val) {
04467          value_type *vp = (new std::pair<T,U>);
04468          T *pfirst = &(vp->first);
04469          int res1 = swig::asval((PyObject*)first, pfirst);
04470          if (!SWIG_IsOK(res1)) return res1;
04471          U *psecond = &(vp->second);
04472          int res2 = swig::asval((PyObject*)second, psecond);
04473          if (!SWIG_IsOK(res2)) return res2;
04474          *val = vp;
04475          return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
04476        } else {
04477          T *pfirst = 0;
04478          int res1 = swig::asval((PyObject*)first, pfirst);
04479          if (!SWIG_IsOK(res1)) return res1;
04480          U *psecond = 0;
04481          int res2 = swig::asval((PyObject*)second, psecond);
04482          if (!SWIG_IsOK(res2)) return res2;
04483          return res1 > res2 ? res1 : res2;
04484        }      
04485       }
04486 
04487       static int asptr(PyObject *obj, std::pair<T,U> **val) {
04488        int res = SWIG_ERROR;
04489        if (PyTuple_Check(obj)) {
04490          if (PyTuple_GET_SIZE(obj) == 2) {
04491            res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
04492          }
04493        } else if (PySequence_Check(obj)) {
04494          if (PySequence_Size(obj) == 2) {
04495            swig::PyObject_var first = PySequence_GetItem(obj,0);
04496            swig::PyObject_var second = PySequence_GetItem(obj,1);
04497            res = get_pair(first, second, val);
04498          }
04499        } else {
04500          value_type *p;
04501          res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
04502          if (SWIG_IsOK(res) && val)  *val = p;
04503        }
04504        return res;
04505       }
04506     };
04507 
04508 
04509     template <class T, class U >
04510     struct traits_from<std::pair<T,U> >   {
04511       static PyObject *from(const std::pair<T,U>& val) {
04512        PyObject* obj = PyTuple_New(2);
04513        PyTuple_SetItem(obj,0,swig::from(val.first));
04514        PyTuple_SetItem(obj,1,swig::from(val.second));
04515        return obj;
04516       }
04517     };
04518   }
04519 
04520 
04521       namespace swig {
04522        template <>  struct traits<std::pair< std::string, std::string > > {
04523          typedef pointer_category category;
04524          static const char* type_name() {
04525            return "std::pair<" "std::string" "," "std::string" " >";
04526          }
04527        };
04528       }
04529     
04530 
04531   namespace swig {
04532     template <class PySeq, class K, class T >
04533     inline void
04534     assign(const PySeq& pyseq, std::map<K,T > *map) {
04535       typedef typename std::map<K,T>::value_type value_type;
04536       typename PySeq::const_iterator it = pyseq.begin();
04537       for (;it != pyseq.end(); ++it) {
04538        map->insert(value_type(it->first, it->second));
04539       }
04540     }
04541 
04542     template <class K, class T>
04543     struct traits_asptr<std::map<K,T> >  {
04544       typedef std::map<K,T> map_type;
04545       static int asptr(PyObject *obj, map_type **val) {
04546        int res = SWIG_ERROR;
04547        if (PyDict_Check(obj)) {
04548          PyObject_var items = PyObject_CallMethod(obj,(char *)"items",NULL);
04549          res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
04550        } else {
04551          map_type *p;
04552          res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
04553          if (SWIG_IsOK(res) && val)  *val = p;
04554        }
04555        return res;
04556       }      
04557     };
04558       
04559     template <class K, class T >
04560     struct traits_from<std::map<K,T> >  {
04561       typedef std::map<K,T> map_type;
04562       typedef typename map_type::const_iterator const_iterator;
04563       typedef typename map_type::size_type size_type;
04564             
04565       static PyObject *from(const map_type& map) {
04566        swig_type_info *desc = swig::type_info<map_type>();
04567        if (desc && desc->clientdata) {
04568          return SWIG_NewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
04569        } else {
04570          size_type size = map.size();
04571          int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
04572          if (pysize < 0) {
04573            SWIG_PYTHON_THREAD_BEGIN_BLOCK;
04574            PyErr_SetString(PyExc_OverflowError,
04575                          "map size not valid in python");
04576            SWIG_PYTHON_THREAD_END_BLOCK;
04577            return NULL;
04578          }
04579          PyObject *obj = PyDict_New();
04580          for (const_iterator i= map.begin(); i!= map.end(); ++i) {
04581            swig::PyObject_var key = swig::from(i->first);
04582            swig::PyObject_var val = swig::from(i->second);
04583            PyDict_SetItem(obj, key, val);
04584          }
04585          return obj;
04586        }
04587       }
04588     };
04589 
04590     template <class ValueType>
04591     struct from_key_oper 
04592     {
04593       typedef const ValueType& argument_type;
04594       typedef  PyObject *result_type;
04595       result_type operator()(argument_type v) const
04596       {
04597        return swig::from(v.first);
04598       }
04599     };
04600 
04601     template <class ValueType>
04602     struct from_value_oper 
04603     {
04604       typedef const ValueType& argument_type;
04605       typedef  PyObject *result_type;
04606       result_type operator()(argument_type v) const
04607       {
04608        return swig::from(v.second);
04609       }
04610     };
04611 
04612     template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
04613     struct PyMapIterator_T : PySwigIteratorClosed_T<OutIterator, ValueType, FromOper>
04614     {
04615       PyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
04616        : PySwigIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
04617       {
04618       }
04619     };
04620 
04621 
04622     template<class OutIterator,
04623             class FromOper = from_key_oper<typename OutIterator::value_type> >
04624     struct PyMapKeyIterator_T : PyMapIterator_T<OutIterator, FromOper>
04625     {
04626       PyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
04627        : PyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
04628       {
04629       }
04630     };
04631 
04632     template<typename OutIter>
04633     inline PySwigIterator*
04634     make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
04635     {
04636       return new PyMapKeyIterator_T<OutIter>(current, begin, end, seq);
04637     }
04638 
04639     template<class OutIterator,
04640             class FromOper = from_value_oper<typename OutIterator::value_type> >
04641     struct PyMapValueIterator_T : PyMapIterator_T<OutIterator, FromOper>
04642     {
04643       PyMapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
04644        : PyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
04645       {
04646       }
04647     };
04648     
04649 
04650     template<typename OutIter>
04651     inline PySwigIterator*
04652     make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
04653     {
04654       return new PyMapValueIterator_T<OutIter>(current, begin, end, seq);
04655     }
04656   }
04657 
04658 
04659       namespace swig {
04660        template <>  struct traits<std::map<std::string, std::string, std::less< std::string >, std::allocator< std::pair< std::string const,std::string > > > > {
04661          typedef pointer_category category;
04662          static const char* type_name() {
04663            return "std::map<" "std::string" "," "std::string" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,std::string > >" " >";
04664          }
04665        };
04666       }
04667     
04668 SWIGINTERN swig::PySwigIterator *std_map_Sl_std_string_Sc_std_string_Sg__iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
04669       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
04670     }
04671 SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____nonzero__(std::map< std::string,std::string > const *self){
04672       return !(self->empty());
04673     }
04674 SWIGINTERN std::map< std::string,std::string >::size_type std_map_Sl_std_string_Sc_std_string_Sg____len__(std::map< std::string,std::string > const *self){
04675       return self->size();
04676     }
04677 SWIGINTERN std::map< std::string,std::string >::mapped_type std_map_Sl_std_string_Sc_std_string_Sg____getitem__(std::map< std::string,std::string > const *self,std::map< std::string,std::string >::key_type const &key){
04678       std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->find(key);
04679       if (i != self->end())
04680        return i->second;
04681       else
04682        throw std::out_of_range("key not found");
04683     }
04684 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____delitem__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
04685       std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::iterator i = self->find(key);
04686       if (i != self->end())
04687        self->erase(i);
04688       else
04689        throw std::out_of_range("key not found");
04690     }
04691 SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__has_key(std::map< std::string,std::string > const *self,std::map< std::string,std::string >::key_type const &key){
04692       std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->find(key);
04693       return i != self->end();
04694     }
04695 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__keys(std::map< std::string,std::string > *self){
04696       std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
04697       int pysize = (size <= (std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (int) size : -1;
04698       if (pysize < 0) {
04699        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
04700        PyErr_SetString(PyExc_OverflowError,
04701                      "map size not valid in python");
04702        SWIG_PYTHON_THREAD_END_BLOCK;
04703        return NULL;
04704       }
04705       PyObject* keyList = PyList_New(pysize);
04706       std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
04707       for (int j = 0; j < pysize; ++i, ++j) {
04708        PyList_SET_ITEM(keyList, j, swig::from(i->first));
04709       }
04710       return keyList;
04711     }
04712 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__values(std::map< std::string,std::string > *self){
04713       std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
04714       int pysize = (size <= (std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (int) size : -1;
04715       if (pysize < 0) {
04716        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
04717        PyErr_SetString(PyExc_OverflowError,
04718                      "map size not valid in python");
04719        SWIG_PYTHON_THREAD_END_BLOCK;
04720        return NULL;
04721       }
04722       PyObject* valList = PyList_New(pysize);
04723       std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
04724       for (int j = 0; j < pysize; ++i, ++j) {
04725        PyList_SET_ITEM(valList, j, swig::from(i->second));
04726       }
04727       return valList;
04728     }
04729 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__items(std::map< std::string,std::string > *self){
04730       std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
04731       int pysize = (size <= (std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (int) size : -1;
04732       if (pysize < 0) {
04733        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
04734        PyErr_SetString(PyExc_OverflowError,
04735                      "map size not valid in python");
04736        SWIG_PYTHON_THREAD_END_BLOCK;
04737        return NULL;
04738       }    
04739       PyObject* itemList = PyList_New(pysize);
04740       std::map<std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
04741       for (int j = 0; j < pysize; ++i, ++j) {
04742        PyList_SET_ITEM(itemList, j, swig::from(*i));
04743       }
04744       return itemList;
04745     }
04746 SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____contains__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
04747       return self->find(key) != self->end();
04748     }
04749 SWIGINTERN swig::PySwigIterator *std_map_Sl_std_string_Sc_std_string_Sg__key_iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
04750       return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
04751     }
04752 SWIGINTERN swig::PySwigIterator *std_map_Sl_std_string_Sc_std_string_Sg__value_iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
04753       return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
04754     }
04755 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____setitem__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key,std::map< std::string,std::string >::mapped_type const &x){
04756       (*self)[key] = x;
04757     }
04758 
04759 #include <arc/XMLNode.h>
04760 #include <arc/ArcConfig.h>
04761 #include <arc/ArcLocation.h>
04762 #include <arc/IString.h>
04763 #include <arc/Logger.h>
04764 #include <arc/DateTime.h>
04765 #include <arc/URL.h>
04766 #include <arc/UserConfig.h>
04767 #include <arc/GUID.h>
04768 
04769 
04770   namespace swig {
04771     template <>  struct traits<Arc::XMLNode > {
04772       typedef pointer_category category;
04773       static const char* type_name() { return"Arc::XMLNode"; }
04774     };
04775   }
04776 
04777 
04778       namespace swig {
04779        template <>  struct traits<std::list<Arc::XMLNode, std::allocator< Arc::XMLNode > > > {
04780          typedef pointer_category category;
04781          static const char* type_name() {
04782            return "std::list<" "Arc::XMLNode" ", " "std::allocator< Arc::XMLNode >" " >";
04783          }
04784        };
04785       }
04786     
04787 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_XMLNode_Sg__iterator(std::list< Arc::XMLNode > *self,PyObject **PYTHON_SELF){
04788       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
04789     }
04790 SWIGINTERN bool std_list_Sl_Arc_XMLNode_Sg____nonzero__(std::list< Arc::XMLNode > const *self){
04791       return !(self->empty());
04792     }
04793 SWIGINTERN std::list< Arc::XMLNode >::size_type std_list_Sl_Arc_XMLNode_Sg____len__(std::list< Arc::XMLNode > const *self){
04794       return self->size();
04795     }
04796 SWIGINTERN std::list< Arc::XMLNode >::value_type std_list_Sl_Arc_XMLNode_Sg__pop(std::list< Arc::XMLNode > *self){
04797       if (self->size() == 0)
04798        throw std::out_of_range("pop from empty container");
04799       std::list<Arc::XMLNode,std::allocator< Arc::XMLNode > >::value_type x = self->back();
04800       self->pop_back();
04801       return x;
04802     }
04803 SWIGINTERN std::list< Arc::XMLNode,std::allocator< Arc::XMLNode > > *std_list_Sl_Arc_XMLNode_Sg____getslice__(std::list< Arc::XMLNode > *self,std::list< Arc::XMLNode >::difference_type i,std::list< Arc::XMLNode >::difference_type j){
04804       return swig::getslice(self, i, j);
04805     }
04806 SWIGINTERN void std_list_Sl_Arc_XMLNode_Sg____setslice__(std::list< Arc::XMLNode > *self,std::list< Arc::XMLNode >::difference_type i,std::list< Arc::XMLNode >::difference_type j,std::list< Arc::XMLNode,std::allocator< Arc::XMLNode > > const &v){
04807       swig::setslice(self, i, j, v);
04808     }
04809 SWIGINTERN void std_list_Sl_Arc_XMLNode_Sg____delslice__(std::list< Arc::XMLNode > *self,std::list< Arc::XMLNode >::difference_type i,std::list< Arc::XMLNode >::difference_type j){
04810       swig::delslice(self, i, j);
04811     }
04812 SWIGINTERN void std_list_Sl_Arc_XMLNode_Sg____delitem__(std::list< Arc::XMLNode > *self,std::list< Arc::XMLNode >::difference_type i){
04813       self->erase(swig::getpos(self,i));
04814     }
04815 SWIGINTERN std::list< Arc::XMLNode >::value_type const &std_list_Sl_Arc_XMLNode_Sg____getitem__(std::list< Arc::XMLNode > const *self,std::list< Arc::XMLNode >::difference_type i){
04816       return *(swig::cgetpos(self, i));
04817     }
04818 SWIGINTERN void std_list_Sl_Arc_XMLNode_Sg____setitem__(std::list< Arc::XMLNode > *self,std::list< Arc::XMLNode >::difference_type i,std::list< Arc::XMLNode >::value_type const &x){
04819       *(swig::getpos(self,i)) = x;
04820     }
04821 SWIGINTERN void std_list_Sl_Arc_XMLNode_Sg__append(std::list< Arc::XMLNode > *self,std::list< Arc::XMLNode >::value_type const &x){
04822       self->push_back(x);
04823     }
04824 
04825   namespace swig {
04826     template <>  struct traits<Arc::URL > {
04827       typedef pointer_category category;
04828       static const char* type_name() { return"Arc::URL"; }
04829     };
04830   }
04831 
04832 
04833       namespace swig {
04834        template <>  struct traits<std::list<Arc::URL, std::allocator< Arc::URL > > > {
04835          typedef pointer_category category;
04836          static const char* type_name() {
04837            return "std::list<" "Arc::URL" ", " "std::allocator< Arc::URL >" " >";
04838          }
04839        };
04840       }
04841     
04842 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_URL_Sg__iterator(std::list< Arc::URL > *self,PyObject **PYTHON_SELF){
04843       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
04844     }
04845 SWIGINTERN bool std_list_Sl_Arc_URL_Sg____nonzero__(std::list< Arc::URL > const *self){
04846       return !(self->empty());
04847     }
04848 SWIGINTERN std::list< Arc::URL >::size_type std_list_Sl_Arc_URL_Sg____len__(std::list< Arc::URL > const *self){
04849       return self->size();
04850     }
04851 SWIGINTERN std::list< Arc::URL >::value_type std_list_Sl_Arc_URL_Sg__pop(std::list< Arc::URL > *self){
04852       if (self->size() == 0)
04853        throw std::out_of_range("pop from empty container");
04854       std::list<Arc::URL,std::allocator< Arc::URL > >::value_type x = self->back();
04855       self->pop_back();
04856       return x;
04857     }
04858 SWIGINTERN std::list< Arc::URL,std::allocator< Arc::URL > > *std_list_Sl_Arc_URL_Sg____getslice__(std::list< Arc::URL > *self,std::list< Arc::URL >::difference_type i,std::list< Arc::URL >::difference_type j){
04859       return swig::getslice(self, i, j);
04860     }
04861 SWIGINTERN void std_list_Sl_Arc_URL_Sg____setslice__(std::list< Arc::URL > *self,std::list< Arc::URL >::difference_type i,std::list< Arc::URL >::difference_type j,std::list< Arc::URL,std::allocator< Arc::URL > > const &v){
04862       swig::setslice(self, i, j, v);
04863     }
04864 SWIGINTERN void std_list_Sl_Arc_URL_Sg____delslice__(std::list< Arc::URL > *self,std::list< Arc::URL >::difference_type i,std::list< Arc::URL >::difference_type j){
04865       swig::delslice(self, i, j);
04866     }
04867 SWIGINTERN void std_list_Sl_Arc_URL_Sg____delitem__(std::list< Arc::URL > *self,std::list< Arc::URL >::difference_type i){
04868       self->erase(swig::getpos(self,i));
04869     }
04870 SWIGINTERN std::list< Arc::URL >::value_type const &std_list_Sl_Arc_URL_Sg____getitem__(std::list< Arc::URL > const *self,std::list< Arc::URL >::difference_type i){
04871       return *(swig::cgetpos(self, i));
04872     }
04873 SWIGINTERN void std_list_Sl_Arc_URL_Sg____setitem__(std::list< Arc::URL > *self,std::list< Arc::URL >::difference_type i,std::list< Arc::URL >::value_type const &x){
04874       *(swig::getpos(self,i)) = x;
04875     }
04876 SWIGINTERN void std_list_Sl_Arc_URL_Sg__append(std::list< Arc::URL > *self,std::list< Arc::URL >::value_type const &x){
04877       self->push_back(x);
04878     }
04879 
04880   namespace swig {
04881     template <class T>
04882     struct traits_asptr<std::vector<T> >  {
04883       static int asptr(PyObject *obj, std::vector<T> **vec) {
04884        return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
04885       }
04886     };
04887     
04888     template <class T>
04889     struct traits_from<std::vector<T> > {
04890       static PyObject *from(const std::vector<T>& vec) {
04891        return traits_from_stdseq<std::vector<T> >::from(vec);
04892       }
04893     };
04894   }
04895 
04896 
04897       namespace swig {
04898        template <>  struct traits<std::vector<Arc::URL, std::allocator< Arc::URL > > > {
04899          typedef pointer_category category;
04900          static const char* type_name() {
04901            return "std::vector<" "Arc::URL" "," "std::allocator< Arc::URL >" " >";
04902          }
04903        };
04904       }
04905     
04906 SWIGINTERN swig::PySwigIterator *std_vector_Sl_Arc_URL_Sg__iterator(std::vector< Arc::URL > *self,PyObject **PYTHON_SELF){
04907       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
04908     }
04909 SWIGINTERN bool std_vector_Sl_Arc_URL_Sg____nonzero__(std::vector< Arc::URL > const *self){
04910       return !(self->empty());
04911     }
04912 SWIGINTERN std::vector< Arc::URL >::size_type std_vector_Sl_Arc_URL_Sg____len__(std::vector< Arc::URL > const *self){
04913       return self->size();
04914     }
04915 SWIGINTERN std::vector< Arc::URL >::value_type std_vector_Sl_Arc_URL_Sg__pop(std::vector< Arc::URL > *self){
04916       if (self->size() == 0)
04917        throw std::out_of_range("pop from empty container");
04918       std::vector<Arc::URL,std::allocator< Arc::URL > >::value_type x = self->back();
04919       self->pop_back();
04920       return x;
04921     }
04922 SWIGINTERN std::vector< Arc::URL,std::allocator< Arc::URL > > *std_vector_Sl_Arc_URL_Sg____getslice__(std::vector< Arc::URL > *self,std::vector< Arc::URL >::difference_type i,std::vector< Arc::URL >::difference_type j){
04923       return swig::getslice(self, i, j);
04924     }
04925 SWIGINTERN void std_vector_Sl_Arc_URL_Sg____setslice__(std::vector< Arc::URL > *self,std::vector< Arc::URL >::difference_type i,std::vector< Arc::URL >::difference_type j,std::vector< Arc::URL,std::allocator< Arc::URL > > const &v){
04926       swig::setslice(self, i, j, v);
04927     }
04928 SWIGINTERN void std_vector_Sl_Arc_URL_Sg____delslice__(std::vector< Arc::URL > *self,std::vector< Arc::URL >::difference_type i,std::vector< Arc::URL >::difference_type j){
04929       swig::delslice(self, i, j);
04930     }
04931 SWIGINTERN void std_vector_Sl_Arc_URL_Sg____delitem__(std::vector< Arc::URL > *self,std::vector< Arc::URL >::difference_type i){
04932       self->erase(swig::getpos(self,i));
04933     }
04934 SWIGINTERN std::vector< Arc::URL >::value_type const &std_vector_Sl_Arc_URL_Sg____getitem__(std::vector< Arc::URL > const *self,std::vector< Arc::URL >::difference_type i){
04935       return *(swig::cgetpos(self, i));
04936     }
04937 SWIGINTERN void std_vector_Sl_Arc_URL_Sg____setitem__(std::vector< Arc::URL > *self,std::vector< Arc::URL >::difference_type i,std::vector< Arc::URL >::value_type const &x){
04938       *(swig::getpos(self,i)) = x;
04939     }
04940 SWIGINTERN void std_vector_Sl_Arc_URL_Sg__append(std::vector< Arc::URL > *self,std::vector< Arc::URL >::value_type const &x){
04941       self->push_back(x);
04942     }
04943 
04944       namespace swig {
04945        template <>  struct traits<std::pair< std::string, std::list< Arc::URL,std::allocator< Arc::URL > > > > {
04946          typedef pointer_category category;
04947          static const char* type_name() {
04948            return "std::pair<" "std::string" "," "std::list< Arc::URL,std::allocator< Arc::URL > >" " >";
04949          }
04950        };
04951       }
04952     
04953 
04954       namespace swig {
04955        template <>  struct traits<std::map<std::string, std::list< Arc::URL,std::allocator< Arc::URL > >, std::less< std::string >, std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > > > {
04956          typedef pointer_category category;
04957          static const char* type_name() {
04958            return "std::map<" "std::string" "," "std::list< Arc::URL,std::allocator< Arc::URL > >" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > >" " >";
04959          }
04960        };
04961       }
04962     
04963 SWIGINTERN swig::PySwigIterator *std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg__iterator(std::map< std::string,std::list< Arc::URL > > *self,PyObject **PYTHON_SELF){
04964       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
04965     }
04966 SWIGINTERN bool std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg____nonzero__(std::map< std::string,std::list< Arc::URL > > const *self){
04967       return !(self->empty());
04968     }
04969 SWIGINTERN std::map< std::string,std::list< Arc::URL > >::size_type std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg____len__(std::map< std::string,std::list< Arc::URL > > const *self){
04970       return self->size();
04971     }
04972 SWIGINTERN std::map< std::string,std::list< Arc::URL > >::mapped_type std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg____getitem__(std::map< std::string,std::list< Arc::URL > > const *self,std::map< std::string,std::list< Arc::URL > >::key_type const &key){
04973       std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::const_iterator i = self->find(key);
04974       if (i != self->end())
04975        return i->second;
04976       else
04977        throw std::out_of_range("key not found");
04978     }
04979 SWIGINTERN void std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg____delitem__(std::map< std::string,std::list< Arc::URL > > *self,std::map< std::string,std::list< Arc::URL > >::key_type const &key){
04980       std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::iterator i = self->find(key);
04981       if (i != self->end())
04982        self->erase(i);
04983       else
04984        throw std::out_of_range("key not found");
04985     }
04986 SWIGINTERN bool std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg__has_key(std::map< std::string,std::list< Arc::URL > > const *self,std::map< std::string,std::list< Arc::URL > >::key_type const &key){
04987       std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::const_iterator i = self->find(key);
04988       return i != self->end();
04989     }
04990 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg__keys(std::map< std::string,std::list< Arc::URL > > *self){
04991       std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::size_type size = self->size();
04992       int pysize = (size <= (std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::size_type) INT_MAX) ? (int) size : -1;
04993       if (pysize < 0) {
04994        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
04995        PyErr_SetString(PyExc_OverflowError,
04996                      "map size not valid in python");
04997        SWIG_PYTHON_THREAD_END_BLOCK;
04998        return NULL;
04999       }
05000       PyObject* keyList = PyList_New(pysize);
05001       std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::const_iterator i = self->begin();
05002       for (int j = 0; j < pysize; ++i, ++j) {
05003        PyList_SET_ITEM(keyList, j, swig::from(i->first));
05004       }
05005       return keyList;
05006     }
05007 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg__values(std::map< std::string,std::list< Arc::URL > > *self){
05008       std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::size_type size = self->size();
05009       int pysize = (size <= (std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::size_type) INT_MAX) ? (int) size : -1;
05010       if (pysize < 0) {
05011        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
05012        PyErr_SetString(PyExc_OverflowError,
05013                      "map size not valid in python");
05014        SWIG_PYTHON_THREAD_END_BLOCK;
05015        return NULL;
05016       }
05017       PyObject* valList = PyList_New(pysize);
05018       std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::const_iterator i = self->begin();
05019       for (int j = 0; j < pysize; ++i, ++j) {
05020        PyList_SET_ITEM(valList, j, swig::from(i->second));
05021       }
05022       return valList;
05023     }
05024 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg__items(std::map< std::string,std::list< Arc::URL > > *self){
05025       std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::size_type size = self->size();
05026       int pysize = (size <= (std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::size_type) INT_MAX) ? (int) size : -1;
05027       if (pysize < 0) {
05028        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
05029        PyErr_SetString(PyExc_OverflowError,
05030                      "map size not valid in python");
05031        SWIG_PYTHON_THREAD_END_BLOCK;
05032        return NULL;
05033       }    
05034       PyObject* itemList = PyList_New(pysize);
05035       std::map<std::string,std::list< Arc::URL,std::allocator< Arc::URL > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::list< Arc::URL,std::allocator< Arc::URL > > > > >::const_iterator i = self->begin();
05036       for (int j = 0; j < pysize; ++i, ++j) {
05037        PyList_SET_ITEM(itemList, j, swig::from(*i));
05038       }
05039       return itemList;
05040     }
05041 SWIGINTERN bool std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg____contains__(std::map< std::string,std::list< Arc::URL > > *self,std::map< std::string,std::list< Arc::URL > >::key_type const &key){
05042       return self->find(key) != self->end();
05043     }
05044 SWIGINTERN swig::PySwigIterator *std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg__key_iterator(std::map< std::string,std::list< Arc::URL > > *self,PyObject **PYTHON_SELF){
05045       return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05046     }
05047 SWIGINTERN swig::PySwigIterator *std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg__value_iterator(std::map< std::string,std::list< Arc::URL > > *self,PyObject **PYTHON_SELF){
05048       return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05049     }
05050 SWIGINTERN void std_map_Sl_std_string_Sc_std_list_Sl_Arc_URL_Sg__Sg____setitem__(std::map< std::string,std::list< Arc::URL > > *self,std::map< std::string,std::list< Arc::URL > >::key_type const &key,std::map< std::string,std::list< Arc::URL > >::mapped_type const &x){
05051       (*self)[key] = x;
05052     }
05053 
05054 
05055 
05056 
05057 #include <limits.h>
05058 #if !defined(SWIG_NO_LLONG_MAX)
05059 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
05060 #   define LLONG_MAX __LONG_LONG_MAX__
05061 #   define LLONG_MIN (-LLONG_MAX - 1LL)
05062 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
05063 # endif
05064 #endif
05065 
05066 
05067 SWIGINTERN int
05068 SWIG_AsVal_int (PyObject * obj, int *val)
05069 {
05070   long v;
05071   int res = SWIG_AsVal_long (obj, &v);
05072   if (SWIG_IsOK(res)) {
05073     if ((v < INT_MIN || v > INT_MAX)) {
05074       return SWIG_OverflowError;
05075     } else {
05076       if (val) *val = static_cast< int >(v);
05077     }
05078   }  
05079   return res;
05080 }
05081 
05082 
05083 SWIGINTERN int
05084 SWIG_AsVal_bool (PyObject *obj, bool *val)
05085 {
05086   int r = PyObject_IsTrue(obj);
05087   if (r == -1)
05088     return SWIG_ERROR;
05089   if (val) *val = r ? true : false;
05090   return SWIG_OK;
05091 }
05092 
05093 
05094 SWIGINTERNINLINE PyObject *
05095 SWIG_From_int  (int value)
05096 {    
05097   return SWIG_From_long  (value);
05098 }
05099 
05100 
05101 SWIGINTERNINLINE PyObject * 
05102 SWIG_FromCharPtr(const char *cptr)
05103 { 
05104   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
05105 }
05106 
05107 
05108 SWIGINTERN int
05109 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
05110 { 
05111   char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
05112   int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
05113   if (SWIG_IsOK(res)) {
05114     if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
05115     if (csize <= size) {
05116       if (val) {
05117        if (csize) memcpy(val, cptr, csize*sizeof(char));
05118        if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
05119       }
05120       if (alloc == SWIG_NEWOBJ) {
05121        delete[] cptr;
05122        res = SWIG_DelNewMask(res);
05123       }      
05124       return res;
05125     }
05126     if (alloc == SWIG_NEWOBJ) delete[] cptr;
05127   }
05128   return SWIG_TypeError;
05129 }
05130 
05131 
05132 SWIGINTERN int
05133 SWIG_AsVal_char (PyObject * obj, char *val)
05134 {    
05135   int res = SWIG_AsCharArray(obj, val, 1);
05136   if (!SWIG_IsOK(res)) {
05137     long v;
05138     res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
05139     if (SWIG_IsOK(res)) {
05140       if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
05141        if (val) *val = static_cast< char >(v);
05142       } else {
05143        res = SWIG_OverflowError;
05144       }
05145     }
05146   }
05147   return res;
05148 }
05149 
05150 
05151 class CPyOutbuf : public std::streambuf
05152 {
05153 public:
05154      CPyOutbuf(PyObject* obj) {
05155          m_PyObj = obj;
05156          Py_INCREF(m_PyObj);
05157      }
05158      ~CPyOutbuf() {
05159          Py_DECREF(m_PyObj);
05160      }
05161 protected:
05162      int_type overflow(int_type c) {
05163          // Call to PyGILState_Ensure ensures there is Python
05164          // thread state created/assigned.
05165          PyGILState_STATE gstate = PyGILState_Ensure();
05166          PyObject_CallMethod(m_PyObj, (char*) "write", (char*) "c", c);
05167          PyGILState_Release(gstate);
05168          return c;
05169      }
05170      std::streamsize xsputn(const char* s, std::streamsize count) {
05171          // Call to PyGILState_Ensure ensures there is Python
05172          // thread state created/assigned.
05173          PyGILState_STATE gstate = PyGILState_Ensure();
05174          PyObject_CallMethod(m_PyObj, (char*) "write", (char*) "s#", s, int(count));
05175          PyGILState_Release(gstate);
05176          return count;
05177      }
05178      PyObject* m_PyObj;
05179 };
05180 
05181 class CPyOstream : public std::ostream
05182 {
05183 public:
05184      CPyOstream(PyObject* obj) : m_Buf(obj), std::ostream(&m_Buf) {}
05185 private:
05186      CPyOutbuf m_Buf;
05187 };
05188 
05189 
05190 
05191 #include <arc/message/MCC.h>
05192 #include <arc/message/MCC_Status.h>
05193 #include <arc/message/MessageAttributes.h>
05194 #include <arc/message/SecAttr.h> 
05195 #include <arc/message/MessageAuth.h>
05196 #include <arc/message/Message.h>
05197 #include <arc/message/PayloadRaw.h>
05198 #include <arc/message/SOAPEnvelope.h>
05199 #include <arc/message/SOAPMessage.h>
05200 #include <arc/message/PayloadSOAP.h>
05201 #include <arc/message/PayloadStream.h>
05202 #include <arc/message/Service.h> 
05203 
05204 
05205 SWIGINTERN int
05206 SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
05207 {
05208   int res = SWIG_TypeError;
05209   if (PyLong_Check(obj)) {
05210     long long v = PyLong_AsLongLong(obj);
05211     if (!PyErr_Occurred()) {
05212       if (val) *val = v;
05213       return SWIG_OK;
05214     } else {
05215       PyErr_Clear();
05216     }
05217   } else {
05218     long v;
05219     res = SWIG_AsVal_long (obj,&v);
05220     if (SWIG_IsOK(res)) {
05221       if (val) *val = v;
05222       return res;
05223     }
05224   }
05225 #ifdef SWIG_PYTHON_CAST_MODE
05226   {
05227     const double mant_max = 1LL << DBL_MANT_DIG;
05228     const double mant_min = -mant_max;
05229     double d;
05230     res = SWIG_AsVal_double (obj,&d);
05231     if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
05232       if (val) *val = (long long)(d);
05233       return SWIG_AddCast(res);
05234     }
05235     res = SWIG_TypeError;
05236   }
05237 #endif
05238   return res;
05239 }
05240 
05241 
05242 SWIGINTERNINLINE PyObject* 
05243 SWIG_From_long_SS_long  (long long value)
05244 {
05245   return ((value < LONG_MIN) || (value > LONG_MAX)) ?
05246     PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value)); 
05247 }
05248 
05249 
05250 SWIGINTERN int
05251 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
05252 {
05253   unsigned long v;
05254   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
05255   if (SWIG_IsOK(res)) {
05256     if ((v > UINT_MAX)) {
05257       return SWIG_OverflowError;
05258     } else {
05259       if (val) *val = static_cast< unsigned int >(v);
05260     }
05261   }  
05262   return res;
05263 }
05264 
05265 
05266 #include <arc/client/ClientInterface.h>
05267 #include <arc/client/ClientX509Delegation.h>
05268 #include <arc/client/Submitter.h>
05269 #include <arc/client/Software.h>
05270 #include <arc/client/ExecutionTarget.h>
05271 #include <arc/client/JobState.h>
05272 #include <arc/client/Job.h>
05273 #include <arc/client/TargetGenerator.h>
05274 #include <arc/client/Broker.h>
05275 #include <arc/client/JobController.h>
05276 #include <arc/client/JobDescription.h>
05277 #include <arc/client/JobSupervisor.h>
05278 #include <arc/client/TargetRetriever.h>
05279 
05280 
05281   namespace swig {
05282     template <>  struct traits<Arc::ExecutionTarget > {
05283       typedef pointer_category category;
05284       static const char* type_name() { return"Arc::ExecutionTarget"; }
05285     };
05286   }
05287 
05288 
05289       namespace swig {
05290        template <>  struct traits<std::list<Arc::ExecutionTarget, std::allocator< Arc::ExecutionTarget > > > {
05291          typedef pointer_category category;
05292          static const char* type_name() {
05293            return "std::list<" "Arc::ExecutionTarget" ", " "std::allocator< Arc::ExecutionTarget >" " >";
05294          }
05295        };
05296       }
05297     
05298 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_ExecutionTarget_Sg__iterator(std::list< Arc::ExecutionTarget > *self,PyObject **PYTHON_SELF){
05299       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05300     }
05301 SWIGINTERN bool std_list_Sl_Arc_ExecutionTarget_Sg____nonzero__(std::list< Arc::ExecutionTarget > const *self){
05302       return !(self->empty());
05303     }
05304 SWIGINTERN std::list< Arc::ExecutionTarget >::size_type std_list_Sl_Arc_ExecutionTarget_Sg____len__(std::list< Arc::ExecutionTarget > const *self){
05305       return self->size();
05306     }
05307 SWIGINTERN std::list< Arc::ExecutionTarget >::value_type std_list_Sl_Arc_ExecutionTarget_Sg__pop(std::list< Arc::ExecutionTarget > *self){
05308       if (self->size() == 0)
05309        throw std::out_of_range("pop from empty container");
05310       std::list<Arc::ExecutionTarget,std::allocator< Arc::ExecutionTarget > >::value_type x = self->back();
05311       self->pop_back();
05312       return x;
05313     }
05314 SWIGINTERN std::list< Arc::ExecutionTarget,std::allocator< Arc::ExecutionTarget > > *std_list_Sl_Arc_ExecutionTarget_Sg____getslice__(std::list< Arc::ExecutionTarget > *self,std::list< Arc::ExecutionTarget >::difference_type i,std::list< Arc::ExecutionTarget >::difference_type j){
05315       return swig::getslice(self, i, j);
05316     }
05317 SWIGINTERN void std_list_Sl_Arc_ExecutionTarget_Sg____setslice__(std::list< Arc::ExecutionTarget > *self,std::list< Arc::ExecutionTarget >::difference_type i,std::list< Arc::ExecutionTarget >::difference_type j,std::list< Arc::ExecutionTarget,std::allocator< Arc::ExecutionTarget > > const &v){
05318       swig::setslice(self, i, j, v);
05319     }
05320 SWIGINTERN void std_list_Sl_Arc_ExecutionTarget_Sg____delslice__(std::list< Arc::ExecutionTarget > *self,std::list< Arc::ExecutionTarget >::difference_type i,std::list< Arc::ExecutionTarget >::difference_type j){
05321       swig::delslice(self, i, j);
05322     }
05323 SWIGINTERN void std_list_Sl_Arc_ExecutionTarget_Sg____delitem__(std::list< Arc::ExecutionTarget > *self,std::list< Arc::ExecutionTarget >::difference_type i){
05324       self->erase(swig::getpos(self,i));
05325     }
05326 SWIGINTERN std::list< Arc::ExecutionTarget >::value_type const &std_list_Sl_Arc_ExecutionTarget_Sg____getitem__(std::list< Arc::ExecutionTarget > const *self,std::list< Arc::ExecutionTarget >::difference_type i){
05327       return *(swig::cgetpos(self, i));
05328     }
05329 SWIGINTERN void std_list_Sl_Arc_ExecutionTarget_Sg____setitem__(std::list< Arc::ExecutionTarget > *self,std::list< Arc::ExecutionTarget >::difference_type i,std::list< Arc::ExecutionTarget >::value_type const &x){
05330       *(swig::getpos(self,i)) = x;
05331     }
05332 SWIGINTERN void std_list_Sl_Arc_ExecutionTarget_Sg__append(std::list< Arc::ExecutionTarget > *self,std::list< Arc::ExecutionTarget >::value_type const &x){
05333       self->push_back(x);
05334     }
05335 
05336   namespace swig {
05337     template <>  struct traits<Arc::JobController > {
05338       typedef pointer_category category;
05339       static const char* type_name() { return"Arc::JobController"; }
05340     };
05341   }
05342 
05343 
05344       namespace swig {
05345        template <>  struct traits<std::list<Arc::JobController*, std::allocator< Arc::JobController * > > > {
05346          typedef value_category category;
05347          static const char* type_name() {
05348            return "std::list<" "Arc::JobController" " *," "std::allocator< Arc::JobController * >" " >";
05349          }
05350        };
05351       }
05352     
05353 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_JobController_Sm__Sg__iterator(std::list< Arc::JobController * > *self,PyObject **PYTHON_SELF){
05354       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05355     }
05356 SWIGINTERN bool std_list_Sl_Arc_JobController_Sm__Sg____nonzero__(std::list< Arc::JobController * > const *self){
05357       return !(self->empty());
05358     }
05359 SWIGINTERN std::list< Arc::JobController * >::size_type std_list_Sl_Arc_JobController_Sm__Sg____len__(std::list< Arc::JobController * > const *self){
05360       return self->size();
05361     }
05362 SWIGINTERN std::list< Arc::JobController * >::value_type std_list_Sl_Arc_JobController_Sm__Sg__pop(std::list< Arc::JobController * > *self){
05363       if (self->size() == 0)
05364        throw std::out_of_range("pop from empty container");
05365       std::list<Arc::JobController*,std::allocator< Arc::JobController * > >::value_type x = self->back();
05366       self->pop_back();
05367       return x;
05368     }
05369 SWIGINTERN std::list< Arc::JobController *,std::allocator< Arc::JobController * > > *std_list_Sl_Arc_JobController_Sm__Sg____getslice__(std::list< Arc::JobController * > *self,std::list< Arc::JobController * >::difference_type i,std::list< Arc::JobController * >::difference_type j){
05370       return swig::getslice(self, i, j);
05371     }
05372 SWIGINTERN void std_list_Sl_Arc_JobController_Sm__Sg____setslice__(std::list< Arc::JobController * > *self,std::list< Arc::JobController * >::difference_type i,std::list< Arc::JobController * >::difference_type j,std::list< Arc::JobController *,std::allocator< Arc::JobController * > > const &v){
05373       swig::setslice(self, i, j, v);
05374     }
05375 SWIGINTERN void std_list_Sl_Arc_JobController_Sm__Sg____delslice__(std::list< Arc::JobController * > *self,std::list< Arc::JobController * >::difference_type i,std::list< Arc::JobController * >::difference_type j){
05376       swig::delslice(self, i, j);
05377     }
05378 SWIGINTERN void std_list_Sl_Arc_JobController_Sm__Sg____delitem__(std::list< Arc::JobController * > *self,std::list< Arc::JobController * >::difference_type i){
05379       self->erase(swig::getpos(self,i));
05380     }
05381 SWIGINTERN std::list< Arc::JobController * >::value_type std_list_Sl_Arc_JobController_Sm__Sg____getitem__(std::list< Arc::JobController * > *self,std::list< Arc::JobController * >::difference_type i){
05382       return *(swig::cgetpos(self, i));
05383     }
05384 SWIGINTERN void std_list_Sl_Arc_JobController_Sm__Sg____setitem__(std::list< Arc::JobController * > *self,std::list< Arc::JobController * >::difference_type i,std::list< Arc::JobController * >::value_type x){
05385       *(swig::getpos(self,i)) = x;
05386     }
05387 SWIGINTERN void std_list_Sl_Arc_JobController_Sm__Sg__append(std::list< Arc::JobController * > *self,std::list< Arc::JobController * >::value_type x){
05388       self->push_back(x);
05389     }
05390 
05391   namespace swig {
05392     template <>  struct traits<Arc::Job > {
05393       typedef pointer_category category;
05394       static const char* type_name() { return"Arc::Job"; }
05395     };
05396   }
05397 
05398 
05399       namespace swig {
05400        template <>  struct traits<std::list<Arc::Job, std::allocator< Arc::Job > > > {
05401          typedef pointer_category category;
05402          static const char* type_name() {
05403            return "std::list<" "Arc::Job" ", " "std::allocator< Arc::Job >" " >";
05404          }
05405        };
05406       }
05407     
05408 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_Job_Sg__iterator(std::list< Arc::Job > *self,PyObject **PYTHON_SELF){
05409       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05410     }
05411 SWIGINTERN bool std_list_Sl_Arc_Job_Sg____nonzero__(std::list< Arc::Job > const *self){
05412       return !(self->empty());
05413     }
05414 SWIGINTERN std::list< Arc::Job >::size_type std_list_Sl_Arc_Job_Sg____len__(std::list< Arc::Job > const *self){
05415       return self->size();
05416     }
05417 SWIGINTERN std::list< Arc::Job >::value_type std_list_Sl_Arc_Job_Sg__pop(std::list< Arc::Job > *self){
05418       if (self->size() == 0)
05419        throw std::out_of_range("pop from empty container");
05420       std::list<Arc::Job,std::allocator< Arc::Job > >::value_type x = self->back();
05421       self->pop_back();
05422       return x;
05423     }
05424 SWIGINTERN std::list< Arc::Job,std::allocator< Arc::Job > > *std_list_Sl_Arc_Job_Sg____getslice__(std::list< Arc::Job > *self,std::list< Arc::Job >::difference_type i,std::list< Arc::Job >::difference_type j){
05425       return swig::getslice(self, i, j);
05426     }
05427 SWIGINTERN void std_list_Sl_Arc_Job_Sg____setslice__(std::list< Arc::Job > *self,std::list< Arc::Job >::difference_type i,std::list< Arc::Job >::difference_type j,std::list< Arc::Job,std::allocator< Arc::Job > > const &v){
05428       swig::setslice(self, i, j, v);
05429     }
05430 SWIGINTERN void std_list_Sl_Arc_Job_Sg____delslice__(std::list< Arc::Job > *self,std::list< Arc::Job >::difference_type i,std::list< Arc::Job >::difference_type j){
05431       swig::delslice(self, i, j);
05432     }
05433 SWIGINTERN void std_list_Sl_Arc_Job_Sg____delitem__(std::list< Arc::Job > *self,std::list< Arc::Job >::difference_type i){
05434       self->erase(swig::getpos(self,i));
05435     }
05436 SWIGINTERN std::list< Arc::Job >::value_type const &std_list_Sl_Arc_Job_Sg____getitem__(std::list< Arc::Job > const *self,std::list< Arc::Job >::difference_type i){
05437       return *(swig::cgetpos(self, i));
05438     }
05439 SWIGINTERN void std_list_Sl_Arc_Job_Sg____setitem__(std::list< Arc::Job > *self,std::list< Arc::Job >::difference_type i,std::list< Arc::Job >::value_type const &x){
05440       *(swig::getpos(self,i)) = x;
05441     }
05442 SWIGINTERN void std_list_Sl_Arc_Job_Sg__append(std::list< Arc::Job > *self,std::list< Arc::Job >::value_type const &x){
05443       self->push_back(x);
05444     }
05445 
05446   namespace swig {
05447     template <>  struct traits<Arc::JobState > {
05448       typedef pointer_category category;
05449       static const char* type_name() { return"Arc::JobState"; }
05450     };
05451   }
05452 
05453 
05454       namespace swig {
05455        template <>  struct traits<std::list<Arc::JobState, std::allocator< Arc::JobState > > > {
05456          typedef pointer_category category;
05457          static const char* type_name() {
05458            return "std::list<" "Arc::JobState" ", " "std::allocator< Arc::JobState >" " >";
05459          }
05460        };
05461       }
05462     
05463 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_JobState_Sg__iterator(std::list< Arc::JobState > *self,PyObject **PYTHON_SELF){
05464       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05465     }
05466 SWIGINTERN bool std_list_Sl_Arc_JobState_Sg____nonzero__(std::list< Arc::JobState > const *self){
05467       return !(self->empty());
05468     }
05469 SWIGINTERN std::list< Arc::JobState >::size_type std_list_Sl_Arc_JobState_Sg____len__(std::list< Arc::JobState > const *self){
05470       return self->size();
05471     }
05472 SWIGINTERN std::list< Arc::JobState >::value_type std_list_Sl_Arc_JobState_Sg__pop(std::list< Arc::JobState > *self){
05473       if (self->size() == 0)
05474        throw std::out_of_range("pop from empty container");
05475       std::list<Arc::JobState,std::allocator< Arc::JobState > >::value_type x = self->back();
05476       self->pop_back();
05477       return x;
05478     }
05479 SWIGINTERN std::list< Arc::JobState,std::allocator< Arc::JobState > > *std_list_Sl_Arc_JobState_Sg____getslice__(std::list< Arc::JobState > *self,std::list< Arc::JobState >::difference_type i,std::list< Arc::JobState >::difference_type j){
05480       return swig::getslice(self, i, j);
05481     }
05482 SWIGINTERN void std_list_Sl_Arc_JobState_Sg____setslice__(std::list< Arc::JobState > *self,std::list< Arc::JobState >::difference_type i,std::list< Arc::JobState >::difference_type j,std::list< Arc::JobState,std::allocator< Arc::JobState > > const &v){
05483       swig::setslice(self, i, j, v);
05484     }
05485 SWIGINTERN void std_list_Sl_Arc_JobState_Sg____delslice__(std::list< Arc::JobState > *self,std::list< Arc::JobState >::difference_type i,std::list< Arc::JobState >::difference_type j){
05486       swig::delslice(self, i, j);
05487     }
05488 SWIGINTERN void std_list_Sl_Arc_JobState_Sg____delitem__(std::list< Arc::JobState > *self,std::list< Arc::JobState >::difference_type i){
05489       self->erase(swig::getpos(self,i));
05490     }
05491 SWIGINTERN std::list< Arc::JobState >::value_type const &std_list_Sl_Arc_JobState_Sg____getitem__(std::list< Arc::JobState > const *self,std::list< Arc::JobState >::difference_type i){
05492       return *(swig::cgetpos(self, i));
05493     }
05494 SWIGINTERN void std_list_Sl_Arc_JobState_Sg____setitem__(std::list< Arc::JobState > *self,std::list< Arc::JobState >::difference_type i,std::list< Arc::JobState >::value_type const &x){
05495       *(swig::getpos(self,i)) = x;
05496     }
05497 SWIGINTERN void std_list_Sl_Arc_JobState_Sg__append(std::list< Arc::JobState > *self,std::list< Arc::JobState >::value_type const &x){
05498       self->push_back(x);
05499     }
05500 
05501   namespace swig {
05502     template <>  struct traits<Arc::DataSourceType > {
05503       typedef pointer_category category;
05504       static const char* type_name() { return"Arc::DataSourceType"; }
05505     };
05506   }
05507 
05508 
05509       namespace swig {
05510        template <>  struct traits<std::list<Arc::DataSourceType, std::allocator< Arc::DataSourceType > > > {
05511          typedef pointer_category category;
05512          static const char* type_name() {
05513            return "std::list<" "Arc::DataSourceType" ", " "std::allocator< Arc::DataSourceType >" " >";
05514          }
05515        };
05516       }
05517     
05518 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_DataSourceType_Sg__iterator(std::list< Arc::DataSourceType > *self,PyObject **PYTHON_SELF){
05519       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05520     }
05521 SWIGINTERN bool std_list_Sl_Arc_DataSourceType_Sg____nonzero__(std::list< Arc::DataSourceType > const *self){
05522       return !(self->empty());
05523     }
05524 SWIGINTERN std::list< Arc::DataSourceType >::size_type std_list_Sl_Arc_DataSourceType_Sg____len__(std::list< Arc::DataSourceType > const *self){
05525       return self->size();
05526     }
05527 SWIGINTERN std::list< Arc::DataSourceType >::value_type std_list_Sl_Arc_DataSourceType_Sg__pop(std::list< Arc::DataSourceType > *self){
05528       if (self->size() == 0)
05529        throw std::out_of_range("pop from empty container");
05530       std::list<Arc::DataSourceType,std::allocator< Arc::DataSourceType > >::value_type x = self->back();
05531       self->pop_back();
05532       return x;
05533     }
05534 SWIGINTERN std::list< Arc::DataSourceType,std::allocator< Arc::DataSourceType > > *std_list_Sl_Arc_DataSourceType_Sg____getslice__(std::list< Arc::DataSourceType > *self,std::list< Arc::DataSourceType >::difference_type i,std::list< Arc::DataSourceType >::difference_type j){
05535       return swig::getslice(self, i, j);
05536     }
05537 SWIGINTERN void std_list_Sl_Arc_DataSourceType_Sg____setslice__(std::list< Arc::DataSourceType > *self,std::list< Arc::DataSourceType >::difference_type i,std::list< Arc::DataSourceType >::difference_type j,std::list< Arc::DataSourceType,std::allocator< Arc::DataSourceType > > const &v){
05538       swig::setslice(self, i, j, v);
05539     }
05540 SWIGINTERN void std_list_Sl_Arc_DataSourceType_Sg____delslice__(std::list< Arc::DataSourceType > *self,std::list< Arc::DataSourceType >::difference_type i,std::list< Arc::DataSourceType >::difference_type j){
05541       swig::delslice(self, i, j);
05542     }
05543 SWIGINTERN void std_list_Sl_Arc_DataSourceType_Sg____delitem__(std::list< Arc::DataSourceType > *self,std::list< Arc::DataSourceType >::difference_type i){
05544       self->erase(swig::getpos(self,i));
05545     }
05546 SWIGINTERN std::list< Arc::DataSourceType >::value_type const &std_list_Sl_Arc_DataSourceType_Sg____getitem__(std::list< Arc::DataSourceType > const *self,std::list< Arc::DataSourceType >::difference_type i){
05547       return *(swig::cgetpos(self, i));
05548     }
05549 SWIGINTERN void std_list_Sl_Arc_DataSourceType_Sg____setitem__(std::list< Arc::DataSourceType > *self,std::list< Arc::DataSourceType >::difference_type i,std::list< Arc::DataSourceType >::value_type const &x){
05550       *(swig::getpos(self,i)) = x;
05551     }
05552 SWIGINTERN void std_list_Sl_Arc_DataSourceType_Sg__append(std::list< Arc::DataSourceType > *self,std::list< Arc::DataSourceType >::value_type const &x){
05553       self->push_back(x);
05554     }
05555 
05556   namespace swig {
05557     template <>  struct traits<Arc::DataTargetType > {
05558       typedef pointer_category category;
05559       static const char* type_name() { return"Arc::DataTargetType"; }
05560     };
05561   }
05562 
05563 
05564       namespace swig {
05565        template <>  struct traits<std::list<Arc::DataTargetType, std::allocator< Arc::DataTargetType > > > {
05566          typedef pointer_category category;
05567          static const char* type_name() {
05568            return "std::list<" "Arc::DataTargetType" ", " "std::allocator< Arc::DataTargetType >" " >";
05569          }
05570        };
05571       }
05572     
05573 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_DataTargetType_Sg__iterator(std::list< Arc::DataTargetType > *self,PyObject **PYTHON_SELF){
05574       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05575     }
05576 SWIGINTERN bool std_list_Sl_Arc_DataTargetType_Sg____nonzero__(std::list< Arc::DataTargetType > const *self){
05577       return !(self->empty());
05578     }
05579 SWIGINTERN std::list< Arc::DataTargetType >::size_type std_list_Sl_Arc_DataTargetType_Sg____len__(std::list< Arc::DataTargetType > const *self){
05580       return self->size();
05581     }
05582 SWIGINTERN std::list< Arc::DataTargetType >::value_type std_list_Sl_Arc_DataTargetType_Sg__pop(std::list< Arc::DataTargetType > *self){
05583       if (self->size() == 0)
05584        throw std::out_of_range("pop from empty container");
05585       std::list<Arc::DataTargetType,std::allocator< Arc::DataTargetType > >::value_type x = self->back();
05586       self->pop_back();
05587       return x;
05588     }
05589 SWIGINTERN std::list< Arc::DataTargetType,std::allocator< Arc::DataTargetType > > *std_list_Sl_Arc_DataTargetType_Sg____getslice__(std::list< Arc::DataTargetType > *self,std::list< Arc::DataTargetType >::difference_type i,std::list< Arc::DataTargetType >::difference_type j){
05590       return swig::getslice(self, i, j);
05591     }
05592 SWIGINTERN void std_list_Sl_Arc_DataTargetType_Sg____setslice__(std::list< Arc::DataTargetType > *self,std::list< Arc::DataTargetType >::difference_type i,std::list< Arc::DataTargetType >::difference_type j,std::list< Arc::DataTargetType,std::allocator< Arc::DataTargetType > > const &v){
05593       swig::setslice(self, i, j, v);
05594     }
05595 SWIGINTERN void std_list_Sl_Arc_DataTargetType_Sg____delslice__(std::list< Arc::DataTargetType > *self,std::list< Arc::DataTargetType >::difference_type i,std::list< Arc::DataTargetType >::difference_type j){
05596       swig::delslice(self, i, j);
05597     }
05598 SWIGINTERN void std_list_Sl_Arc_DataTargetType_Sg____delitem__(std::list< Arc::DataTargetType > *self,std::list< Arc::DataTargetType >::difference_type i){
05599       self->erase(swig::getpos(self,i));
05600     }
05601 SWIGINTERN std::list< Arc::DataTargetType >::value_type const &std_list_Sl_Arc_DataTargetType_Sg____getitem__(std::list< Arc::DataTargetType > const *self,std::list< Arc::DataTargetType >::difference_type i){
05602       return *(swig::cgetpos(self, i));
05603     }
05604 SWIGINTERN void std_list_Sl_Arc_DataTargetType_Sg____setitem__(std::list< Arc::DataTargetType > *self,std::list< Arc::DataTargetType >::difference_type i,std::list< Arc::DataTargetType >::value_type const &x){
05605       *(swig::getpos(self,i)) = x;
05606     }
05607 SWIGINTERN void std_list_Sl_Arc_DataTargetType_Sg__append(std::list< Arc::DataTargetType > *self,std::list< Arc::DataTargetType >::value_type const &x){
05608       self->push_back(x);
05609     }
05610 
05611   namespace swig {
05612     template <>  struct traits<Arc::FileType > {
05613       typedef pointer_category category;
05614       static const char* type_name() { return"Arc::FileType"; }
05615     };
05616   }
05617 
05618 
05619       namespace swig {
05620        template <>  struct traits<std::list<Arc::FileType, std::allocator< Arc::FileType > > > {
05621          typedef pointer_category category;
05622          static const char* type_name() {
05623            return "std::list<" "Arc::FileType" ", " "std::allocator< Arc::FileType >" " >";
05624          }
05625        };
05626       }
05627     
05628 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_FileType_Sg__iterator(std::list< Arc::FileType > *self,PyObject **PYTHON_SELF){
05629       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05630     }
05631 SWIGINTERN bool std_list_Sl_Arc_FileType_Sg____nonzero__(std::list< Arc::FileType > const *self){
05632       return !(self->empty());
05633     }
05634 SWIGINTERN std::list< Arc::FileType >::size_type std_list_Sl_Arc_FileType_Sg____len__(std::list< Arc::FileType > const *self){
05635       return self->size();
05636     }
05637 SWIGINTERN std::list< Arc::FileType >::value_type std_list_Sl_Arc_FileType_Sg__pop(std::list< Arc::FileType > *self){
05638       if (self->size() == 0)
05639        throw std::out_of_range("pop from empty container");
05640       std::list<Arc::FileType,std::allocator< Arc::FileType > >::value_type x = self->back();
05641       self->pop_back();
05642       return x;
05643     }
05644 SWIGINTERN std::list< Arc::FileType,std::allocator< Arc::FileType > > *std_list_Sl_Arc_FileType_Sg____getslice__(std::list< Arc::FileType > *self,std::list< Arc::FileType >::difference_type i,std::list< Arc::FileType >::difference_type j){
05645       return swig::getslice(self, i, j);
05646     }
05647 SWIGINTERN void std_list_Sl_Arc_FileType_Sg____setslice__(std::list< Arc::FileType > *self,std::list< Arc::FileType >::difference_type i,std::list< Arc::FileType >::difference_type j,std::list< Arc::FileType,std::allocator< Arc::FileType > > const &v){
05648       swig::setslice(self, i, j, v);
05649     }
05650 SWIGINTERN void std_list_Sl_Arc_FileType_Sg____delslice__(std::list< Arc::FileType > *self,std::list< Arc::FileType >::difference_type i,std::list< Arc::FileType >::difference_type j){
05651       swig::delslice(self, i, j);
05652     }
05653 SWIGINTERN void std_list_Sl_Arc_FileType_Sg____delitem__(std::list< Arc::FileType > *self,std::list< Arc::FileType >::difference_type i){
05654       self->erase(swig::getpos(self,i));
05655     }
05656 SWIGINTERN std::list< Arc::FileType >::value_type const &std_list_Sl_Arc_FileType_Sg____getitem__(std::list< Arc::FileType > const *self,std::list< Arc::FileType >::difference_type i){
05657       return *(swig::cgetpos(self, i));
05658     }
05659 SWIGINTERN void std_list_Sl_Arc_FileType_Sg____setitem__(std::list< Arc::FileType > *self,std::list< Arc::FileType >::difference_type i,std::list< Arc::FileType >::value_type const &x){
05660       *(swig::getpos(self,i)) = x;
05661     }
05662 SWIGINTERN void std_list_Sl_Arc_FileType_Sg__append(std::list< Arc::FileType > *self,std::list< Arc::FileType >::value_type const &x){
05663       self->push_back(x);
05664     }
05665 
05666   namespace swig {
05667     template <>  struct traits<Arc::DirectoryType > {
05668       typedef pointer_category category;
05669       static const char* type_name() { return"Arc::DirectoryType"; }
05670     };
05671   }
05672 
05673 
05674       namespace swig {
05675        template <>  struct traits<std::list<Arc::DirectoryType, std::allocator< Arc::DirectoryType > > > {
05676          typedef pointer_category category;
05677          static const char* type_name() {
05678            return "std::list<" "Arc::DirectoryType" ", " "std::allocator< Arc::DirectoryType >" " >";
05679          }
05680        };
05681       }
05682     
05683 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_DirectoryType_Sg__iterator(std::list< Arc::DirectoryType > *self,PyObject **PYTHON_SELF){
05684       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05685     }
05686 SWIGINTERN bool std_list_Sl_Arc_DirectoryType_Sg____nonzero__(std::list< Arc::DirectoryType > const *self){
05687       return !(self->empty());
05688     }
05689 SWIGINTERN std::list< Arc::DirectoryType >::size_type std_list_Sl_Arc_DirectoryType_Sg____len__(std::list< Arc::DirectoryType > const *self){
05690       return self->size();
05691     }
05692 SWIGINTERN std::list< Arc::DirectoryType >::value_type std_list_Sl_Arc_DirectoryType_Sg__pop(std::list< Arc::DirectoryType > *self){
05693       if (self->size() == 0)
05694        throw std::out_of_range("pop from empty container");
05695       std::list<Arc::DirectoryType,std::allocator< Arc::DirectoryType > >::value_type x = self->back();
05696       self->pop_back();
05697       return x;
05698     }
05699 SWIGINTERN std::list< Arc::DirectoryType,std::allocator< Arc::DirectoryType > > *std_list_Sl_Arc_DirectoryType_Sg____getslice__(std::list< Arc::DirectoryType > *self,std::list< Arc::DirectoryType >::difference_type i,std::list< Arc::DirectoryType >::difference_type j){
05700       return swig::getslice(self, i, j);
05701     }
05702 SWIGINTERN void std_list_Sl_Arc_DirectoryType_Sg____setslice__(std::list< Arc::DirectoryType > *self,std::list< Arc::DirectoryType >::difference_type i,std::list< Arc::DirectoryType >::difference_type j,std::list< Arc::DirectoryType,std::allocator< Arc::DirectoryType > > const &v){
05703       swig::setslice(self, i, j, v);
05704     }
05705 SWIGINTERN void std_list_Sl_Arc_DirectoryType_Sg____delslice__(std::list< Arc::DirectoryType > *self,std::list< Arc::DirectoryType >::difference_type i,std::list< Arc::DirectoryType >::difference_type j){
05706       swig::delslice(self, i, j);
05707     }
05708 SWIGINTERN void std_list_Sl_Arc_DirectoryType_Sg____delitem__(std::list< Arc::DirectoryType > *self,std::list< Arc::DirectoryType >::difference_type i){
05709       self->erase(swig::getpos(self,i));
05710     }
05711 SWIGINTERN std::list< Arc::DirectoryType >::value_type const &std_list_Sl_Arc_DirectoryType_Sg____getitem__(std::list< Arc::DirectoryType > const *self,std::list< Arc::DirectoryType >::difference_type i){
05712       return *(swig::cgetpos(self, i));
05713     }
05714 SWIGINTERN void std_list_Sl_Arc_DirectoryType_Sg____setitem__(std::list< Arc::DirectoryType > *self,std::list< Arc::DirectoryType >::difference_type i,std::list< Arc::DirectoryType >::value_type const &x){
05715       *(swig::getpos(self,i)) = x;
05716     }
05717 SWIGINTERN void std_list_Sl_Arc_DirectoryType_Sg__append(std::list< Arc::DirectoryType > *self,std::list< Arc::DirectoryType >::value_type const &x){
05718       self->push_back(x);
05719     }
05720 
05721   namespace swig {
05722     template <>  struct traits<Arc::ApplicationEnvironment > {
05723       typedef pointer_category category;
05724       static const char* type_name() { return"Arc::ApplicationEnvironment"; }
05725     };
05726   }
05727 
05728 
05729       namespace swig {
05730        template <>  struct traits<std::list<Arc::ApplicationEnvironment, std::allocator< Arc::ApplicationEnvironment > > > {
05731          typedef pointer_category category;
05732          static const char* type_name() {
05733            return "std::list<" "Arc::ApplicationEnvironment" ", " "std::allocator< Arc::ApplicationEnvironment >" " >";
05734          }
05735        };
05736       }
05737     
05738 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_ApplicationEnvironment_Sg__iterator(std::list< Arc::ApplicationEnvironment > *self,PyObject **PYTHON_SELF){
05739       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05740     }
05741 SWIGINTERN bool std_list_Sl_Arc_ApplicationEnvironment_Sg____nonzero__(std::list< Arc::ApplicationEnvironment > const *self){
05742       return !(self->empty());
05743     }
05744 SWIGINTERN std::list< Arc::ApplicationEnvironment >::size_type std_list_Sl_Arc_ApplicationEnvironment_Sg____len__(std::list< Arc::ApplicationEnvironment > const *self){
05745       return self->size();
05746     }
05747 SWIGINTERN std::list< Arc::ApplicationEnvironment >::value_type std_list_Sl_Arc_ApplicationEnvironment_Sg__pop(std::list< Arc::ApplicationEnvironment > *self){
05748       if (self->size() == 0)
05749        throw std::out_of_range("pop from empty container");
05750       std::list<Arc::ApplicationEnvironment,std::allocator< Arc::ApplicationEnvironment > >::value_type x = self->back();
05751       self->pop_back();
05752       return x;
05753     }
05754 SWIGINTERN std::list< Arc::ApplicationEnvironment,std::allocator< Arc::ApplicationEnvironment > > *std_list_Sl_Arc_ApplicationEnvironment_Sg____getslice__(std::list< Arc::ApplicationEnvironment > *self,std::list< Arc::ApplicationEnvironment >::difference_type i,std::list< Arc::ApplicationEnvironment >::difference_type j){
05755       return swig::getslice(self, i, j);
05756     }
05757 SWIGINTERN void std_list_Sl_Arc_ApplicationEnvironment_Sg____setslice__(std::list< Arc::ApplicationEnvironment > *self,std::list< Arc::ApplicationEnvironment >::difference_type i,std::list< Arc::ApplicationEnvironment >::difference_type j,std::list< Arc::ApplicationEnvironment,std::allocator< Arc::ApplicationEnvironment > > const &v){
05758       swig::setslice(self, i, j, v);
05759     }
05760 SWIGINTERN void std_list_Sl_Arc_ApplicationEnvironment_Sg____delslice__(std::list< Arc::ApplicationEnvironment > *self,std::list< Arc::ApplicationEnvironment >::difference_type i,std::list< Arc::ApplicationEnvironment >::difference_type j){
05761       swig::delslice(self, i, j);
05762     }
05763 SWIGINTERN void std_list_Sl_Arc_ApplicationEnvironment_Sg____delitem__(std::list< Arc::ApplicationEnvironment > *self,std::list< Arc::ApplicationEnvironment >::difference_type i){
05764       self->erase(swig::getpos(self,i));
05765     }
05766 SWIGINTERN std::list< Arc::ApplicationEnvironment >::value_type const &std_list_Sl_Arc_ApplicationEnvironment_Sg____getitem__(std::list< Arc::ApplicationEnvironment > const *self,std::list< Arc::ApplicationEnvironment >::difference_type i){
05767       return *(swig::cgetpos(self, i));
05768     }
05769 SWIGINTERN void std_list_Sl_Arc_ApplicationEnvironment_Sg____setitem__(std::list< Arc::ApplicationEnvironment > *self,std::list< Arc::ApplicationEnvironment >::difference_type i,std::list< Arc::ApplicationEnvironment >::value_type const &x){
05770       *(swig::getpos(self,i)) = x;
05771     }
05772 SWIGINTERN void std_list_Sl_Arc_ApplicationEnvironment_Sg__append(std::list< Arc::ApplicationEnvironment > *self,std::list< Arc::ApplicationEnvironment >::value_type const &x){
05773       self->push_back(x);
05774     }
05775 
05776   namespace swig {
05777     template <>  struct traits<Arc::Software > {
05778       typedef pointer_category category;
05779       static const char* type_name() { return"Arc::Software"; }
05780     };
05781   }
05782 
05783 
05784       namespace swig {
05785        template <>  struct traits<std::list<Arc::Software, std::allocator< Arc::Software > > > {
05786          typedef pointer_category category;
05787          static const char* type_name() {
05788            return "std::list<" "Arc::Software" ", " "std::allocator< Arc::Software >" " >";
05789          }
05790        };
05791       }
05792     
05793 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_Software_Sg__iterator(std::list< Arc::Software > *self,PyObject **PYTHON_SELF){
05794       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05795     }
05796 SWIGINTERN bool std_list_Sl_Arc_Software_Sg____nonzero__(std::list< Arc::Software > const *self){
05797       return !(self->empty());
05798     }
05799 SWIGINTERN std::list< Arc::Software >::size_type std_list_Sl_Arc_Software_Sg____len__(std::list< Arc::Software > const *self){
05800       return self->size();
05801     }
05802 SWIGINTERN std::list< Arc::Software >::value_type std_list_Sl_Arc_Software_Sg__pop(std::list< Arc::Software > *self){
05803       if (self->size() == 0)
05804        throw std::out_of_range("pop from empty container");
05805       std::list<Arc::Software,std::allocator< Arc::Software > >::value_type x = self->back();
05806       self->pop_back();
05807       return x;
05808     }
05809 SWIGINTERN std::list< Arc::Software,std::allocator< Arc::Software > > *std_list_Sl_Arc_Software_Sg____getslice__(std::list< Arc::Software > *self,std::list< Arc::Software >::difference_type i,std::list< Arc::Software >::difference_type j){
05810       return swig::getslice(self, i, j);
05811     }
05812 SWIGINTERN void std_list_Sl_Arc_Software_Sg____setslice__(std::list< Arc::Software > *self,std::list< Arc::Software >::difference_type i,std::list< Arc::Software >::difference_type j,std::list< Arc::Software,std::allocator< Arc::Software > > const &v){
05813       swig::setslice(self, i, j, v);
05814     }
05815 SWIGINTERN void std_list_Sl_Arc_Software_Sg____delslice__(std::list< Arc::Software > *self,std::list< Arc::Software >::difference_type i,std::list< Arc::Software >::difference_type j){
05816       swig::delslice(self, i, j);
05817     }
05818 SWIGINTERN void std_list_Sl_Arc_Software_Sg____delitem__(std::list< Arc::Software > *self,std::list< Arc::Software >::difference_type i){
05819       self->erase(swig::getpos(self,i));
05820     }
05821 SWIGINTERN std::list< Arc::Software >::value_type const &std_list_Sl_Arc_Software_Sg____getitem__(std::list< Arc::Software > const *self,std::list< Arc::Software >::difference_type i){
05822       return *(swig::cgetpos(self, i));
05823     }
05824 SWIGINTERN void std_list_Sl_Arc_Software_Sg____setitem__(std::list< Arc::Software > *self,std::list< Arc::Software >::difference_type i,std::list< Arc::Software >::value_type const &x){
05825       *(swig::getpos(self,i)) = x;
05826     }
05827 SWIGINTERN void std_list_Sl_Arc_Software_Sg__append(std::list< Arc::Software > *self,std::list< Arc::Software >::value_type const &x){
05828       self->push_back(x);
05829     }
05830 
05831   namespace swig {
05832     template <>  struct traits<Arc::SoftwareRequirement > {
05833       typedef pointer_category category;
05834       static const char* type_name() { return"Arc::SoftwareRequirement"; }
05835     };
05836   }
05837 
05838 
05839       namespace swig {
05840        template <>  struct traits<std::list<Arc::SoftwareRequirement, std::allocator< Arc::SoftwareRequirement > > > {
05841          typedef pointer_category category;
05842          static const char* type_name() {
05843            return "std::list<" "Arc::SoftwareRequirement" ", " "std::allocator< Arc::SoftwareRequirement >" " >";
05844          }
05845        };
05846       }
05847     
05848 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_SoftwareRequirement_Sg__iterator(std::list< Arc::SoftwareRequirement > *self,PyObject **PYTHON_SELF){
05849       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05850     }
05851 SWIGINTERN bool std_list_Sl_Arc_SoftwareRequirement_Sg____nonzero__(std::list< Arc::SoftwareRequirement > const *self){
05852       return !(self->empty());
05853     }
05854 SWIGINTERN std::list< Arc::SoftwareRequirement >::size_type std_list_Sl_Arc_SoftwareRequirement_Sg____len__(std::list< Arc::SoftwareRequirement > const *self){
05855       return self->size();
05856     }
05857 SWIGINTERN std::list< Arc::SoftwareRequirement >::value_type std_list_Sl_Arc_SoftwareRequirement_Sg__pop(std::list< Arc::SoftwareRequirement > *self){
05858       if (self->size() == 0)
05859        throw std::out_of_range("pop from empty container");
05860       std::list<Arc::SoftwareRequirement,std::allocator< Arc::SoftwareRequirement > >::value_type x = self->back();
05861       self->pop_back();
05862       return x;
05863     }
05864 SWIGINTERN std::list< Arc::SoftwareRequirement,std::allocator< Arc::SoftwareRequirement > > *std_list_Sl_Arc_SoftwareRequirement_Sg____getslice__(std::list< Arc::SoftwareRequirement > *self,std::list< Arc::SoftwareRequirement >::difference_type i,std::list< Arc::SoftwareRequirement >::difference_type j){
05865       return swig::getslice(self, i, j);
05866     }
05867 SWIGINTERN void std_list_Sl_Arc_SoftwareRequirement_Sg____setslice__(std::list< Arc::SoftwareRequirement > *self,std::list< Arc::SoftwareRequirement >::difference_type i,std::list< Arc::SoftwareRequirement >::difference_type j,std::list< Arc::SoftwareRequirement,std::allocator< Arc::SoftwareRequirement > > const &v){
05868       swig::setslice(self, i, j, v);
05869     }
05870 SWIGINTERN void std_list_Sl_Arc_SoftwareRequirement_Sg____delslice__(std::list< Arc::SoftwareRequirement > *self,std::list< Arc::SoftwareRequirement >::difference_type i,std::list< Arc::SoftwareRequirement >::difference_type j){
05871       swig::delslice(self, i, j);
05872     }
05873 SWIGINTERN void std_list_Sl_Arc_SoftwareRequirement_Sg____delitem__(std::list< Arc::SoftwareRequirement > *self,std::list< Arc::SoftwareRequirement >::difference_type i){
05874       self->erase(swig::getpos(self,i));
05875     }
05876 SWIGINTERN std::list< Arc::SoftwareRequirement >::value_type const &std_list_Sl_Arc_SoftwareRequirement_Sg____getitem__(std::list< Arc::SoftwareRequirement > const *self,std::list< Arc::SoftwareRequirement >::difference_type i){
05877       return *(swig::cgetpos(self, i));
05878     }
05879 SWIGINTERN void std_list_Sl_Arc_SoftwareRequirement_Sg____setitem__(std::list< Arc::SoftwareRequirement > *self,std::list< Arc::SoftwareRequirement >::difference_type i,std::list< Arc::SoftwareRequirement >::value_type const &x){
05880       *(swig::getpos(self,i)) = x;
05881     }
05882 SWIGINTERN void std_list_Sl_Arc_SoftwareRequirement_Sg__append(std::list< Arc::SoftwareRequirement > *self,std::list< Arc::SoftwareRequirement >::value_type const &x){
05883       self->push_back(x);
05884     }
05885 
05886   namespace swig {
05887     template <>  struct traits<Arc::ResourceTargetType > {
05888       typedef pointer_category category;
05889       static const char* type_name() { return"Arc::ResourceTargetType"; }
05890     };
05891   }
05892 
05893 
05894       namespace swig {
05895        template <>  struct traits<std::list<Arc::ResourceTargetType, std::allocator< Arc::ResourceTargetType > > > {
05896          typedef pointer_category category;
05897          static const char* type_name() {
05898            return "std::list<" "Arc::ResourceTargetType" ", " "std::allocator< Arc::ResourceTargetType >" " >";
05899          }
05900        };
05901       }
05902     
05903 SWIGINTERN swig::PySwigIterator *std_list_Sl_Arc_ResourceTargetType_Sg__iterator(std::list< Arc::ResourceTargetType > *self,PyObject **PYTHON_SELF){
05904       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
05905     }
05906 SWIGINTERN bool std_list_Sl_Arc_ResourceTargetType_Sg____nonzero__(std::list< Arc::ResourceTargetType > const *self){
05907       return !(self->empty());
05908     }
05909 SWIGINTERN std::list< Arc::ResourceTargetType >::size_type std_list_Sl_Arc_ResourceTargetType_Sg____len__(std::list< Arc::ResourceTargetType > const *self){
05910       return self->size();
05911     }
05912 SWIGINTERN std::list< Arc::ResourceTargetType >::value_type std_list_Sl_Arc_ResourceTargetType_Sg__pop(std::list< Arc::ResourceTargetType > *self){
05913       if (self->size() == 0)
05914        throw std::out_of_range("pop from empty container");
05915       std::list<Arc::ResourceTargetType,std::allocator< Arc::ResourceTargetType > >::value_type x = self->back();
05916       self->pop_back();
05917       return x;
05918     }
05919 SWIGINTERN std::list< Arc::ResourceTargetType,std::allocator< Arc::ResourceTargetType > > *std_list_Sl_Arc_ResourceTargetType_Sg____getslice__(std::list< Arc::ResourceTargetType > *self,std::list< Arc::ResourceTargetType >::difference_type i,std::list< Arc::ResourceTargetType >::difference_type j){
05920       return swig::getslice(self, i, j);
05921     }
05922 SWIGINTERN void std_list_Sl_Arc_ResourceTargetType_Sg____setslice__(std::list< Arc::ResourceTargetType > *self,std::list< Arc::ResourceTargetType >::difference_type i,std::list< Arc::ResourceTargetType >::difference_type j,std::list< Arc::ResourceTargetType,std::allocator< Arc::ResourceTargetType > > const &v){
05923       swig::setslice(self, i, j, v);
05924     }
05925 SWIGINTERN void std_list_Sl_Arc_ResourceTargetType_Sg____delslice__(std::list< Arc::ResourceTargetType > *self,std::list< Arc::ResourceTargetType >::difference_type i,std::list< Arc::ResourceTargetType >::difference_type j){
05926       swig::delslice(self, i, j);
05927     }
05928 SWIGINTERN void std_list_Sl_Arc_ResourceTargetType_Sg____delitem__(std::list< Arc::ResourceTargetType > *self,std::list< Arc::ResourceTargetType >::difference_type i){
05929       self->erase(swig::getpos(self,i));
05930     }
05931 SWIGINTERN std::list< Arc::ResourceTargetType >::value_type const &std_list_Sl_Arc_ResourceTargetType_Sg____getitem__(std::list< Arc::ResourceTargetType > const *self,std::list< Arc::ResourceTargetType >::difference_type i){
05932       return *(swig::cgetpos(self, i));
05933     }
05934 SWIGINTERN void std_list_Sl_Arc_ResourceTargetType_Sg____setitem__(std::list< Arc::ResourceTargetType > *self,std::list< Arc::ResourceTargetType >::difference_type i,std::list< Arc::ResourceTargetType >::value_type const &x){
05935       *(swig::getpos(self,i)) = x;
05936     }
05937 SWIGINTERN void std_list_Sl_Arc_ResourceTargetType_Sg__append(std::list< Arc::ResourceTargetType > *self,std::list< Arc::ResourceTargetType >::value_type const &x){
05938       self->push_back(x);
05939     }
05940 
05941 SWIGINTERN int
05942 SWIG_AsVal_float (PyObject * obj, float *val)
05943 {
05944   double v;
05945   int res = SWIG_AsVal_double (obj, &v);
05946   if (SWIG_IsOK(res)) {
05947     if ((v < -FLT_MAX || v > FLT_MAX)) {
05948       return SWIG_OverflowError;
05949     } else {
05950       if (val) *val = static_cast< float >(v);
05951     }
05952   }  
05953   return res;
05954 }
05955 
05956 
05957   #define SWIG_From_double   PyFloat_FromDouble 
05958 
05959 
05960 SWIGINTERNINLINE PyObject *
05961 SWIG_From_float  (float value)
05962 {    
05963   return SWIG_From_double  (value);
05964 }
05965 
05966 
05967 #include <arc/credential/Credential.h>
05968 
05969 
05970 #include <arc/data/DataStatus.h>
05971 #include <arc/data/FileInfo.h>
05972 #include <arc/data/DataPoint.h>
05973 #include <arc/data/DataHandle.h>
05974 #include <arc/data/DataSpeed.h>
05975 #include <arc/data/DataBuffer.h>
05976 #include <arc/data/FileCache.h>
05977 #include <arc/data/DataMover.h>
05978 #include <arc/data/URLMap.h>
05979 
05980 #ifdef WIN32
05981 #define uid_t int
05982 #define gid_t int
05983 #endif
05984 
05985 
05986 
05987 SWIGINTERNINLINE PyObject* 
05988 SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
05989 {
05990   return (value > LONG_MAX) ?
05991     PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value)); 
05992 }
05993 
05994 
05995 SWIGINTERN int
05996 SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
05997 {
05998   int res = SWIG_TypeError;
05999   if (PyLong_Check(obj)) {
06000     unsigned long long v = PyLong_AsUnsignedLongLong(obj);
06001     if (!PyErr_Occurred()) {
06002       if (val) *val = v;
06003       return SWIG_OK;
06004     } else {
06005       PyErr_Clear();
06006     }
06007   } else {
06008     unsigned long v;
06009     res = SWIG_AsVal_unsigned_SS_long (obj,&v);
06010     if (SWIG_IsOK(res)) {
06011       if (val) *val = v;
06012       return res;
06013     }
06014   }
06015 #ifdef SWIG_PYTHON_CAST_MODE
06016   {
06017     const double mant_max = 1LL << DBL_MANT_DIG;
06018     double d;
06019     res = SWIG_AsVal_double (obj,&d);
06020     if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
06021       if (val) *val = (unsigned long long)(d);
06022       return SWIG_AddCast(res);
06023     }
06024     res = SWIG_TypeError;
06025   }
06026 #endif
06027   return res;
06028 }
06029 
06030 
06031 SWIGINTERNINLINE PyObject *
06032 SWIG_From_unsigned_SS_int  (unsigned int value)
06033 {    
06034   return SWIG_From_unsigned_SS_long  (value);
06035 }
06036 
06037 
06038 #include <arc/delegation/DelegationInterface.h>
06039 
06040 
06041 #include <arc/security/ArcPDP/Evaluator.h>
06042 #include <arc/security/ArcPDP/EvaluationCtx.h>
06043 #include <arc/security/ArcPDP/EvaluatorLoader.h>
06044 #include <arc/security/ArcPDP/Request.h>
06045 #include <arc/security/ArcPDP/Response.h>
06046 #include <arc/security/ArcPDP/policy/Policy.h>
06047 #include <arc/security/ArcPDP/Source.h>
06048 
06049 #ifdef __cplusplus
06050 extern "C" {
06051 #endif
06052 SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06053   PyObject *resultobj = 0;
06054   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06055   void *argp1 = 0 ;
06056   int res1 = 0 ;
06057   PyObject * obj0 = 0 ;
06058   
06059   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06060   if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
06061   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
06062   if (!SWIG_IsOK(res1)) {
06063     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
06064   }
06065   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06066   {
06067     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06068     delete arg1;
06069     SWIG_PYTHON_THREAD_END_ALLOW;
06070   }
06071   resultobj = SWIG_Py_Void();
06072   SWIG_PYTHON_THREAD_END_BLOCK;
06073   return resultobj;
06074 fail:
06075   SWIG_PYTHON_THREAD_END_BLOCK;
06076   return NULL;
06077 }
06078 
06079 
06080 SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06081   PyObject *resultobj = 0;
06082   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06083   void *argp1 = 0 ;
06084   int res1 = 0 ;
06085   PyObject * obj0 = 0 ;
06086   PyObject *result = 0 ;
06087   
06088   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06089   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_value",&obj0)) SWIG_fail;
06090   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06091   if (!SWIG_IsOK(res1)) {
06092     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
06093   }
06094   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06095   {
06096     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06097     try {
06098       result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
06099     }
06100     catch(swig::stop_iteration &_e) {
06101       {
06102         (void)_e;
06103         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06104         SWIG_fail;
06105       }
06106     }
06107     
06108     SWIG_PYTHON_THREAD_END_ALLOW;
06109   }
06110   resultobj = result;
06111   SWIG_PYTHON_THREAD_END_BLOCK;
06112   return resultobj;
06113 fail:
06114   SWIG_PYTHON_THREAD_END_BLOCK;
06115   return NULL;
06116 }
06117 
06118 
06119 SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06120   PyObject *resultobj = 0;
06121   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06122   size_t arg2 ;
06123   void *argp1 = 0 ;
06124   int res1 = 0 ;
06125   size_t val2 ;
06126   int ecode2 = 0 ;
06127   PyObject * obj0 = 0 ;
06128   PyObject * obj1 = 0 ;
06129   swig::PySwigIterator *result = 0 ;
06130   
06131   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06132   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
06133   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06134   if (!SWIG_IsOK(res1)) {
06135     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
06136   }
06137   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06138   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
06139   if (!SWIG_IsOK(ecode2)) {
06140     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
06141   } 
06142   arg2 = static_cast< size_t >(val2);
06143   {
06144     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06145     try {
06146       result = (swig::PySwigIterator *)(arg1)->incr(arg2);
06147     }
06148     catch(swig::stop_iteration &_e) {
06149       {
06150         (void)_e;
06151         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06152         SWIG_fail;
06153       }
06154     }
06155     
06156     SWIG_PYTHON_THREAD_END_ALLOW;
06157   }
06158   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06159   SWIG_PYTHON_THREAD_END_BLOCK;
06160   return resultobj;
06161 fail:
06162   SWIG_PYTHON_THREAD_END_BLOCK;
06163   return NULL;
06164 }
06165 
06166 
06167 SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06168   PyObject *resultobj = 0;
06169   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06170   void *argp1 = 0 ;
06171   int res1 = 0 ;
06172   PyObject * obj0 = 0 ;
06173   swig::PySwigIterator *result = 0 ;
06174   
06175   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06176   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_incr",&obj0)) SWIG_fail;
06177   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06178   if (!SWIG_IsOK(res1)) {
06179     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
06180   }
06181   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06182   {
06183     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06184     try {
06185       result = (swig::PySwigIterator *)(arg1)->incr();
06186     }
06187     catch(swig::stop_iteration &_e) {
06188       {
06189         (void)_e;
06190         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06191         SWIG_fail;
06192       }
06193     }
06194     
06195     SWIG_PYTHON_THREAD_END_ALLOW;
06196   }
06197   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06198   SWIG_PYTHON_THREAD_END_BLOCK;
06199   return resultobj;
06200 fail:
06201   SWIG_PYTHON_THREAD_END_BLOCK;
06202   return NULL;
06203 }
06204 
06205 
06206 SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
06207   int argc;
06208   PyObject *argv[3];
06209   int ii;
06210   
06211   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06212   if (!PyTuple_Check(args)) SWIG_fail;
06213   argc = (int)PyObject_Length(args);
06214   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
06215     argv[ii] = PyTuple_GET_ITEM(args,ii);
06216   }
06217   if (argc == 1) {
06218     int _v;
06219     void *vptr = 0;
06220     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
06221     _v = SWIG_CheckState(res);
06222     if (_v) {
06223       SWIG_PYTHON_THREAD_END_BLOCK;
06224       return _wrap_PySwigIterator_incr__SWIG_1(self, args);
06225     }
06226   }
06227   if (argc == 2) {
06228     int _v;
06229     void *vptr = 0;
06230     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
06231     _v = SWIG_CheckState(res);
06232     if (_v) {
06233       {
06234         int res = SWIG_AsVal_size_t(argv[1], NULL);
06235         _v = SWIG_CheckState(res);
06236       }
06237       if (_v) {
06238         SWIG_PYTHON_THREAD_END_BLOCK;
06239         return _wrap_PySwigIterator_incr__SWIG_0(self, args);
06240       }
06241     }
06242   }
06243   
06244   SWIG_PYTHON_THREAD_END_BLOCK;
06245 fail:
06246   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n"
06247     "  Possible C/C++ prototypes are:\n"
06248     "    incr(swig::PySwigIterator *,size_t)\n"
06249     "    incr(swig::PySwigIterator *)\n");
06250   return NULL;
06251 }
06252 
06253 
06254 SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06255   PyObject *resultobj = 0;
06256   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06257   size_t arg2 ;
06258   void *argp1 = 0 ;
06259   int res1 = 0 ;
06260   size_t val2 ;
06261   int ecode2 = 0 ;
06262   PyObject * obj0 = 0 ;
06263   PyObject * obj1 = 0 ;
06264   swig::PySwigIterator *result = 0 ;
06265   
06266   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06267   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_decr",&obj0,&obj1)) SWIG_fail;
06268   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06269   if (!SWIG_IsOK(res1)) {
06270     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
06271   }
06272   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06273   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
06274   if (!SWIG_IsOK(ecode2)) {
06275     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
06276   } 
06277   arg2 = static_cast< size_t >(val2);
06278   {
06279     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06280     try {
06281       result = (swig::PySwigIterator *)(arg1)->decr(arg2);
06282     }
06283     catch(swig::stop_iteration &_e) {
06284       {
06285         (void)_e;
06286         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06287         SWIG_fail;
06288       }
06289     }
06290     
06291     SWIG_PYTHON_THREAD_END_ALLOW;
06292   }
06293   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06294   SWIG_PYTHON_THREAD_END_BLOCK;
06295   return resultobj;
06296 fail:
06297   SWIG_PYTHON_THREAD_END_BLOCK;
06298   return NULL;
06299 }
06300 
06301 
06302 SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06303   PyObject *resultobj = 0;
06304   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06305   void *argp1 = 0 ;
06306   int res1 = 0 ;
06307   PyObject * obj0 = 0 ;
06308   swig::PySwigIterator *result = 0 ;
06309   
06310   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06311   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
06312   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06313   if (!SWIG_IsOK(res1)) {
06314     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
06315   }
06316   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06317   {
06318     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06319     try {
06320       result = (swig::PySwigIterator *)(arg1)->decr();
06321     }
06322     catch(swig::stop_iteration &_e) {
06323       {
06324         (void)_e;
06325         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06326         SWIG_fail;
06327       }
06328     }
06329     
06330     SWIG_PYTHON_THREAD_END_ALLOW;
06331   }
06332   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06333   SWIG_PYTHON_THREAD_END_BLOCK;
06334   return resultobj;
06335 fail:
06336   SWIG_PYTHON_THREAD_END_BLOCK;
06337   return NULL;
06338 }
06339 
06340 
06341 SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
06342   int argc;
06343   PyObject *argv[3];
06344   int ii;
06345   
06346   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06347   if (!PyTuple_Check(args)) SWIG_fail;
06348   argc = (int)PyObject_Length(args);
06349   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
06350     argv[ii] = PyTuple_GET_ITEM(args,ii);
06351   }
06352   if (argc == 1) {
06353     int _v;
06354     void *vptr = 0;
06355     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
06356     _v = SWIG_CheckState(res);
06357     if (_v) {
06358       SWIG_PYTHON_THREAD_END_BLOCK;
06359       return _wrap_PySwigIterator_decr__SWIG_1(self, args);
06360     }
06361   }
06362   if (argc == 2) {
06363     int _v;
06364     void *vptr = 0;
06365     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
06366     _v = SWIG_CheckState(res);
06367     if (_v) {
06368       {
06369         int res = SWIG_AsVal_size_t(argv[1], NULL);
06370         _v = SWIG_CheckState(res);
06371       }
06372       if (_v) {
06373         SWIG_PYTHON_THREAD_END_BLOCK;
06374         return _wrap_PySwigIterator_decr__SWIG_0(self, args);
06375       }
06376     }
06377   }
06378   
06379   SWIG_PYTHON_THREAD_END_BLOCK;
06380 fail:
06381   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n"
06382     "  Possible C/C++ prototypes are:\n"
06383     "    decr(swig::PySwigIterator *,size_t)\n"
06384     "    decr(swig::PySwigIterator *)\n");
06385   return NULL;
06386 }
06387 
06388 
06389 SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06390   PyObject *resultobj = 0;
06391   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06392   swig::PySwigIterator *arg2 = 0 ;
06393   void *argp1 = 0 ;
06394   int res1 = 0 ;
06395   void *argp2 = 0 ;
06396   int res2 = 0 ;
06397   PyObject * obj0 = 0 ;
06398   PyObject * obj1 = 0 ;
06399   ptrdiff_t result;
06400   
06401   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06402   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
06403   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06404   if (!SWIG_IsOK(res1)) {
06405     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
06406   }
06407   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06408   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
06409   if (!SWIG_IsOK(res2)) {
06410     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
06411   }
06412   if (!argp2) {
06413     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
06414   }
06415   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
06416   {
06417     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06418     try {
06419       result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
06420     }
06421     catch(std::invalid_argument &_e) {
06422       SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
06423     }
06424     
06425     SWIG_PYTHON_THREAD_END_ALLOW;
06426   }
06427   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
06428   SWIG_PYTHON_THREAD_END_BLOCK;
06429   return resultobj;
06430 fail:
06431   SWIG_PYTHON_THREAD_END_BLOCK;
06432   return NULL;
06433 }
06434 
06435 
06436 SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06437   PyObject *resultobj = 0;
06438   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06439   swig::PySwigIterator *arg2 = 0 ;
06440   void *argp1 = 0 ;
06441   int res1 = 0 ;
06442   void *argp2 = 0 ;
06443   int res2 = 0 ;
06444   PyObject * obj0 = 0 ;
06445   PyObject * obj1 = 0 ;
06446   bool result;
06447   
06448   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06449   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
06450   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06451   if (!SWIG_IsOK(res1)) {
06452     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
06453   }
06454   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06455   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
06456   if (!SWIG_IsOK(res2)) {
06457     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
06458   }
06459   if (!argp2) {
06460     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
06461   }
06462   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
06463   {
06464     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06465     try {
06466       result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
06467     }
06468     catch(std::invalid_argument &_e) {
06469       SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
06470     }
06471     
06472     SWIG_PYTHON_THREAD_END_ALLOW;
06473   }
06474   resultobj = SWIG_From_bool(static_cast< bool >(result));
06475   SWIG_PYTHON_THREAD_END_BLOCK;
06476   return resultobj;
06477 fail:
06478   SWIG_PYTHON_THREAD_END_BLOCK;
06479   return NULL;
06480 }
06481 
06482 
06483 SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06484   PyObject *resultobj = 0;
06485   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06486   void *argp1 = 0 ;
06487   int res1 = 0 ;
06488   PyObject * obj0 = 0 ;
06489   swig::PySwigIterator *result = 0 ;
06490   
06491   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06492   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
06493   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06494   if (!SWIG_IsOK(res1)) {
06495     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
06496   }
06497   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06498   {
06499     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06500     result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
06501     SWIG_PYTHON_THREAD_END_ALLOW;
06502   }
06503   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
06504   SWIG_PYTHON_THREAD_END_BLOCK;
06505   return resultobj;
06506 fail:
06507   SWIG_PYTHON_THREAD_END_BLOCK;
06508   return NULL;
06509 }
06510 
06511 
06512 SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06513   PyObject *resultobj = 0;
06514   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06515   void *argp1 = 0 ;
06516   int res1 = 0 ;
06517   PyObject * obj0 = 0 ;
06518   PyObject *result = 0 ;
06519   
06520   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06521   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
06522   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06523   if (!SWIG_IsOK(res1)) {
06524     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
06525   }
06526   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06527   {
06528     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06529     try {
06530       result = (PyObject *)(arg1)->next();
06531     }
06532     catch(swig::stop_iteration &_e) {
06533       {
06534         (void)_e;
06535         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06536         SWIG_fail;
06537       }
06538     }
06539     
06540     SWIG_PYTHON_THREAD_END_ALLOW;
06541   }
06542   resultobj = result;
06543   SWIG_PYTHON_THREAD_END_BLOCK;
06544   return resultobj;
06545 fail:
06546   SWIG_PYTHON_THREAD_END_BLOCK;
06547   return NULL;
06548 }
06549 
06550 
06551 SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06552   PyObject *resultobj = 0;
06553   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06554   void *argp1 = 0 ;
06555   int res1 = 0 ;
06556   PyObject * obj0 = 0 ;
06557   PyObject *result = 0 ;
06558   
06559   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06560   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
06561   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06562   if (!SWIG_IsOK(res1)) {
06563     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
06564   }
06565   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06566   {
06567     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06568     try {
06569       result = (PyObject *)(arg1)->previous();
06570     }
06571     catch(swig::stop_iteration &_e) {
06572       {
06573         (void)_e;
06574         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06575         SWIG_fail;
06576       }
06577     }
06578     
06579     SWIG_PYTHON_THREAD_END_ALLOW;
06580   }
06581   resultobj = result;
06582   SWIG_PYTHON_THREAD_END_BLOCK;
06583   return resultobj;
06584 fail:
06585   SWIG_PYTHON_THREAD_END_BLOCK;
06586   return NULL;
06587 }
06588 
06589 
06590 SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06591   PyObject *resultobj = 0;
06592   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06593   ptrdiff_t arg2 ;
06594   void *argp1 = 0 ;
06595   int res1 = 0 ;
06596   ptrdiff_t val2 ;
06597   int ecode2 = 0 ;
06598   PyObject * obj0 = 0 ;
06599   PyObject * obj1 = 0 ;
06600   swig::PySwigIterator *result = 0 ;
06601   
06602   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06603   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_advance",&obj0,&obj1)) SWIG_fail;
06604   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06605   if (!SWIG_IsOK(res1)) {
06606     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
06607   }
06608   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06609   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
06610   if (!SWIG_IsOK(ecode2)) {
06611     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
06612   } 
06613   arg2 = static_cast< ptrdiff_t >(val2);
06614   {
06615     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06616     try {
06617       result = (swig::PySwigIterator *)(arg1)->advance(arg2);
06618     }
06619     catch(swig::stop_iteration &_e) {
06620       {
06621         (void)_e;
06622         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06623         SWIG_fail;
06624       }
06625     }
06626     
06627     SWIG_PYTHON_THREAD_END_ALLOW;
06628   }
06629   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06630   SWIG_PYTHON_THREAD_END_BLOCK;
06631   return resultobj;
06632 fail:
06633   SWIG_PYTHON_THREAD_END_BLOCK;
06634   return NULL;
06635 }
06636 
06637 
06638 SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06639   PyObject *resultobj = 0;
06640   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06641   swig::PySwigIterator *arg2 = 0 ;
06642   void *argp1 = 0 ;
06643   int res1 = 0 ;
06644   void *argp2 = 0 ;
06645   int res2 = 0 ;
06646   PyObject * obj0 = 0 ;
06647   PyObject * obj1 = 0 ;
06648   bool result;
06649   
06650   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06651   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
06652   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06653   if (!SWIG_IsOK(res1)) {
06654     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
06655   }
06656   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06657   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
06658   if (!SWIG_IsOK(res2)) {
06659     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
06660   }
06661   if (!argp2) {
06662     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
06663   }
06664   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
06665   {
06666     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06667     result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
06668     SWIG_PYTHON_THREAD_END_ALLOW;
06669   }
06670   resultobj = SWIG_From_bool(static_cast< bool >(result));
06671   SWIG_PYTHON_THREAD_END_BLOCK;
06672   return resultobj;
06673 fail:
06674   SWIG_PYTHON_THREAD_END_BLOCK;
06675   return NULL;
06676 }
06677 
06678 
06679 SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06680   PyObject *resultobj = 0;
06681   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06682   swig::PySwigIterator *arg2 = 0 ;
06683   void *argp1 = 0 ;
06684   int res1 = 0 ;
06685   void *argp2 = 0 ;
06686   int res2 = 0 ;
06687   PyObject * obj0 = 0 ;
06688   PyObject * obj1 = 0 ;
06689   bool result;
06690   
06691   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06692   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
06693   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06694   if (!SWIG_IsOK(res1)) {
06695     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
06696   }
06697   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06698   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
06699   if (!SWIG_IsOK(res2)) {
06700     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
06701   }
06702   if (!argp2) {
06703     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
06704   }
06705   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
06706   {
06707     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06708     result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
06709     SWIG_PYTHON_THREAD_END_ALLOW;
06710   }
06711   resultobj = SWIG_From_bool(static_cast< bool >(result));
06712   SWIG_PYTHON_THREAD_END_BLOCK;
06713   return resultobj;
06714 fail:
06715   SWIG_PYTHON_THREAD_END_BLOCK;
06716   return NULL;
06717 }
06718 
06719 
06720 SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06721   PyObject *resultobj = 0;
06722   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06723   ptrdiff_t arg2 ;
06724   void *argp1 = 0 ;
06725   int res1 = 0 ;
06726   ptrdiff_t val2 ;
06727   int ecode2 = 0 ;
06728   PyObject * obj0 = 0 ;
06729   PyObject * obj1 = 0 ;
06730   swig::PySwigIterator *result = 0 ;
06731   
06732   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06733   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
06734   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
06735   if (!SWIG_IsOK(res1)) {
06736     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
06737   }
06738   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06739   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
06740   if (!SWIG_IsOK(ecode2)) {
06741     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
06742   } 
06743   arg2 = static_cast< ptrdiff_t >(val2);
06744   {
06745     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06746     try {
06747       {
06748         swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
06749         result = (swig::PySwigIterator *) &_result_ref;
06750       }
06751     }
06752     catch(swig::stop_iteration &_e) {
06753       {
06754         (void)_e;
06755         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06756         SWIG_fail;
06757       }
06758     }
06759     
06760     SWIG_PYTHON_THREAD_END_ALLOW;
06761   }
06762   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
06763   SWIG_PYTHON_THREAD_END_BLOCK;
06764   return resultobj;
06765 fail:
06766   SWIG_PYTHON_THREAD_END_BLOCK;
06767   return NULL;
06768 }
06769 
06770 
06771 SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06772   PyObject *resultobj = 0;
06773   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06774   ptrdiff_t arg2 ;
06775   void *argp1 = 0 ;
06776   int res1 = 0 ;
06777   ptrdiff_t val2 ;
06778   int ecode2 = 0 ;
06779   PyObject * obj0 = 0 ;
06780   PyObject * obj1 = 0 ;
06781   swig::PySwigIterator *result = 0 ;
06782   
06783   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06784   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
06785   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
06786   if (!SWIG_IsOK(res1)) {
06787     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
06788   }
06789   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06790   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
06791   if (!SWIG_IsOK(ecode2)) {
06792     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
06793   } 
06794   arg2 = static_cast< ptrdiff_t >(val2);
06795   {
06796     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06797     try {
06798       {
06799         swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
06800         result = (swig::PySwigIterator *) &_result_ref;
06801       }
06802     }
06803     catch(swig::stop_iteration &_e) {
06804       {
06805         (void)_e;
06806         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06807         SWIG_fail;
06808       }
06809     }
06810     
06811     SWIG_PYTHON_THREAD_END_ALLOW;
06812   }
06813   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
06814   SWIG_PYTHON_THREAD_END_BLOCK;
06815   return resultobj;
06816 fail:
06817   SWIG_PYTHON_THREAD_END_BLOCK;
06818   return NULL;
06819 }
06820 
06821 
06822 SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06823   PyObject *resultobj = 0;
06824   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06825   ptrdiff_t arg2 ;
06826   void *argp1 = 0 ;
06827   int res1 = 0 ;
06828   ptrdiff_t val2 ;
06829   int ecode2 = 0 ;
06830   PyObject * obj0 = 0 ;
06831   PyObject * obj1 = 0 ;
06832   swig::PySwigIterator *result = 0 ;
06833   
06834   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06835   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
06836   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06837   if (!SWIG_IsOK(res1)) {
06838     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
06839   }
06840   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06841   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
06842   if (!SWIG_IsOK(ecode2)) {
06843     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
06844   } 
06845   arg2 = static_cast< ptrdiff_t >(val2);
06846   {
06847     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06848     try {
06849       result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
06850     }
06851     catch(swig::stop_iteration &_e) {
06852       {
06853         (void)_e;
06854         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06855         SWIG_fail;
06856       }
06857     }
06858     
06859     SWIG_PYTHON_THREAD_END_ALLOW;
06860   }
06861   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
06862   SWIG_PYTHON_THREAD_END_BLOCK;
06863   return resultobj;
06864 fail:
06865   SWIG_PYTHON_THREAD_END_BLOCK;
06866   return NULL;
06867 }
06868 
06869 
06870 SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06871   PyObject *resultobj = 0;
06872   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06873   ptrdiff_t arg2 ;
06874   void *argp1 = 0 ;
06875   int res1 = 0 ;
06876   ptrdiff_t val2 ;
06877   int ecode2 = 0 ;
06878   PyObject * obj0 = 0 ;
06879   PyObject * obj1 = 0 ;
06880   swig::PySwigIterator *result = 0 ;
06881   
06882   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06883   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
06884   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06885   if (!SWIG_IsOK(res1)) {
06886     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
06887   }
06888   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06889   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
06890   if (!SWIG_IsOK(ecode2)) {
06891     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
06892   } 
06893   arg2 = static_cast< ptrdiff_t >(val2);
06894   {
06895     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06896     try {
06897       result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
06898     }
06899     catch(swig::stop_iteration &_e) {
06900       {
06901         (void)_e;
06902         SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
06903         SWIG_fail;
06904       }
06905     }
06906     
06907     SWIG_PYTHON_THREAD_END_ALLOW;
06908   }
06909   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
06910   SWIG_PYTHON_THREAD_END_BLOCK;
06911   return resultobj;
06912 fail:
06913   SWIG_PYTHON_THREAD_END_BLOCK;
06914   return NULL;
06915 }
06916 
06917 
06918 SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06919   PyObject *resultobj = 0;
06920   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
06921   swig::PySwigIterator *arg2 = 0 ;
06922   void *argp1 = 0 ;
06923   int res1 = 0 ;
06924   void *argp2 = 0 ;
06925   int res2 = 0 ;
06926   PyObject * obj0 = 0 ;
06927   PyObject * obj1 = 0 ;
06928   ptrdiff_t result;
06929   
06930   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06931   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
06932   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
06933   if (!SWIG_IsOK(res1)) {
06934     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
06935   }
06936   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
06937   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
06938   if (!SWIG_IsOK(res2)) {
06939     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
06940   }
06941   if (!argp2) {
06942     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
06943   }
06944   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
06945   {
06946     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
06947     result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
06948     SWIG_PYTHON_THREAD_END_ALLOW;
06949   }
06950   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
06951   SWIG_PYTHON_THREAD_END_BLOCK;
06952   return resultobj;
06953 fail:
06954   SWIG_PYTHON_THREAD_END_BLOCK;
06955   return NULL;
06956 }
06957 
06958 
06959 SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
06960   int argc;
06961   PyObject *argv[3];
06962   int ii;
06963   
06964   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
06965   if (!PyTuple_Check(args)) SWIG_fail;
06966   argc = (int)PyObject_Length(args);
06967   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
06968     argv[ii] = PyTuple_GET_ITEM(args,ii);
06969   }
06970   if (argc == 2) {
06971     int _v;
06972     void *vptr = 0;
06973     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
06974     _v = SWIG_CheckState(res);
06975     if (_v) {
06976       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
06977       _v = SWIG_CheckState(res);
06978       if (_v) {
06979         SWIG_PYTHON_THREAD_END_BLOCK;
06980         return _wrap_PySwigIterator___sub____SWIG_1(self, args);
06981       }
06982     }
06983   }
06984   if (argc == 2) {
06985     int _v;
06986     void *vptr = 0;
06987     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
06988     _v = SWIG_CheckState(res);
06989     if (_v) {
06990       {
06991         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
06992         _v = SWIG_CheckState(res);
06993       }
06994       if (_v) {
06995         SWIG_PYTHON_THREAD_END_BLOCK;
06996         return _wrap_PySwigIterator___sub____SWIG_0(self, args);
06997       }
06998     }
06999   }
07000   
07001   SWIG_PYTHON_THREAD_END_BLOCK;
07002 fail:
07003   Py_INCREF(Py_NotImplemented);
07004   return Py_NotImplemented;
07005 }
07006 
07007 
07008 SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07009   PyObject *obj;
07010   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
07011   SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
07012   return SWIG_Py_Void();
07013 }
07014 
07015 SWIGINTERN PyObject *_wrap_StringList_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07016   PyObject *resultobj = 0;
07017   std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
07018   PyObject **arg2 = (PyObject **) 0 ;
07019   void *argp1 = 0 ;
07020   int res1 = 0 ;
07021   PyObject * obj0 = 0 ;
07022   swig::PySwigIterator *result = 0 ;
07023   
07024   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
07025   arg2 = &obj0;
07026   if (!PyArg_ParseTuple(args,(char *)"O:StringList_iterator",&obj0)) SWIG_fail;
07027   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
07028   if (!SWIG_IsOK(res1)) {
07029     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList_iterator" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
07030   }
07031   arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
07032   {
07033     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
07034     result = (swig::PySwigIterator *)std_list_Sl_std_string_Sg__iterator(arg1,arg2);
07035     SWIG_PYTHON_THREAD_END_ALLOW;
07036   }
07037   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
07038   SWIG_PYTHON_THREAD_END_BLOCK;
07039   return resultobj;
07040 fail:
07041   SWIG_PYTHON_THREAD_END_BLOCK;
07042   return NULL;
07043 }
07044 
07045 
07046 SWIGINTERN PyObject *_wrap_StringList___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07047   PyObject *resultobj = 0;
07048   std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
07049   void *argp1 = 0 ;
07050   int res1 = 0 ;
07051   PyObject * obj0 = 0 ;
07052   bool result;
07053   
07054   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
07055   if (!PyArg_ParseTuple(args,(char *)"O:StringList___nonzero__",&obj0)) SWIG_fail;
07056   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
07057   if (!SWIG_IsOK(res1)) {
07058     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringList___nonzero__" "', argument " "1"" of type '" "std::list< std::string > const *""'"); 
07059   }
07060   arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
07061   {
07062     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
07063     result = (bool)std_list_Sl_std_string_Sg____nonzero__((std::list< std::string > const *)arg1);
07064     SWIG_PYTHON_THREAD_END_ALLOW;
07065   }
07066   resultobj = SWIG_From_bool(static_cast< bool >(result));
07067   SWIG_PYTHON_THREAD_END_BLOCK;
07068   return resultobj;
07069 fail:
07070   SWIG_PYTHON_THREAD_END_BLOCK;
07071   return NULL;
07072 }
07073 
07074 
07075 SWIGINTERN PyObject *_wrap_StringList___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07076   PyObject *resultobj = 0;
07077   std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
07078   void *argp1 = 0 ;
07079   int res1 = 0 ;
07080   PyObject * obj0 = 0 ;
07081   std::list< std::string >::size_type result;
07082   
07083