Back to index

salome-kernel  6.5.0
calcium_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.40
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_DIRECTOR_NO_VTABLE
00013 
00014 
00015 #ifdef __cplusplus
00016 /* SwigValueWrapper is described in swig.swg */
00017 template<typename T> class SwigValueWrapper {
00018   struct SwigMovePointer {
00019     T *ptr;
00020     SwigMovePointer(T *p) : ptr(p) { }
00021     ~SwigMovePointer() { delete ptr; }
00022     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
00023   } pointer;
00024   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
00025   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
00026 public:
00027   SwigValueWrapper() : pointer(0) { }
00028   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
00029   operator T&() const { return *pointer.ptr; }
00030   T *operator&() { return pointer.ptr; }
00031 };
00032 
00033 template <typename T> T SwigValueInit() {
00034   return T();
00035 }
00036 #endif
00037 
00038 /* -----------------------------------------------------------------------------
00039  *  This section contains generic SWIG labels for method/variable
00040  *  declarations/attributes, and other compiler dependent labels.
00041  * ----------------------------------------------------------------------------- */
00042 
00043 /* template workaround for compilers that cannot correctly implement the C++ standard */
00044 #ifndef SWIGTEMPLATEDISAMBIGUATOR
00045 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
00046 #  define SWIGTEMPLATEDISAMBIGUATOR template
00047 # elif defined(__HP_aCC)
00048 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
00049 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
00050 #  define SWIGTEMPLATEDISAMBIGUATOR template
00051 # else
00052 #  define SWIGTEMPLATEDISAMBIGUATOR
00053 # endif
00054 #endif
00055 
00056 /* inline attribute */
00057 #ifndef SWIGINLINE
00058 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
00059 #   define SWIGINLINE inline
00060 # else
00061 #   define SWIGINLINE
00062 # endif
00063 #endif
00064 
00065 /* attribute recognised by some compilers to avoid 'unused' warnings */
00066 #ifndef SWIGUNUSED
00067 # if defined(__GNUC__)
00068 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
00069 #     define SWIGUNUSED __attribute__ ((__unused__)) 
00070 #   else
00071 #     define SWIGUNUSED
00072 #   endif
00073 # elif defined(__ICC)
00074 #   define SWIGUNUSED __attribute__ ((__unused__)) 
00075 # else
00076 #   define SWIGUNUSED 
00077 # endif
00078 #endif
00079 
00080 #ifndef SWIG_MSC_UNSUPPRESS_4505
00081 # if defined(_MSC_VER)
00082 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
00083 # endif 
00084 #endif
00085 
00086 #ifndef SWIGUNUSEDPARM
00087 # ifdef __cplusplus
00088 #   define SWIGUNUSEDPARM(p)
00089 # else
00090 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
00091 # endif
00092 #endif
00093 
00094 /* internal SWIG method */
00095 #ifndef SWIGINTERN
00096 # define SWIGINTERN static SWIGUNUSED
00097 #endif
00098 
00099 /* internal inline SWIG method */
00100 #ifndef SWIGINTERNINLINE
00101 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00102 #endif
00103 
00104 /* exporting methods */
00105 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
00106 #  ifndef GCC_HASCLASSVISIBILITY
00107 #    define GCC_HASCLASSVISIBILITY
00108 #  endif
00109 #endif
00110 
00111 #ifndef SWIGEXPORT
00112 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00113 #   if defined(STATIC_LINKED)
00114 #     define SWIGEXPORT
00115 #   else
00116 #     define SWIGEXPORT __declspec(dllexport)
00117 #   endif
00118 # else
00119 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
00120 #     define SWIGEXPORT __attribute__ ((visibility("default")))
00121 #   else
00122 #     define SWIGEXPORT
00123 #   endif
00124 # endif
00125 #endif
00126 
00127 /* calling conventions for Windows */
00128 #ifndef SWIGSTDCALL
00129 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00130 #   define SWIGSTDCALL __stdcall
00131 # else
00132 #   define SWIGSTDCALL
00133 # endif 
00134 #endif
00135 
00136 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
00137 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
00138 # define _CRT_SECURE_NO_DEPRECATE
00139 #endif
00140 
00141 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
00142 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
00143 # define _SCL_SECURE_NO_DEPRECATE
00144 #endif
00145 
00146 
00147 
00148 /* Python.h has to appear first */
00149 #include <Python.h>
00150 
00151 /* -----------------------------------------------------------------------------
00152  * swigrun.swg
00153  *
00154  * This file contains generic C API SWIG runtime support for pointer
00155  * type checking.
00156  * ----------------------------------------------------------------------------- */
00157 
00158 /* This should only be incremented when either the layout of swig_type_info changes,
00159    or for whatever reason, the runtime changes incompatibly */
00160 #define SWIG_RUNTIME_VERSION "4"
00161 
00162 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
00163 #ifdef SWIG_TYPE_TABLE
00164 # define SWIG_QUOTE_STRING(x) #x
00165 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
00166 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
00167 #else
00168 # define SWIG_TYPE_TABLE_NAME
00169 #endif
00170 
00171 /*
00172   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
00173   creating a static or dynamic library from the SWIG runtime code.
00174   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
00175   
00176   But only do this if strictly necessary, ie, if you have problems
00177   with your compiler or suchlike.
00178 */
00179 
00180 #ifndef SWIGRUNTIME
00181 # define SWIGRUNTIME SWIGINTERN
00182 #endif
00183 
00184 #ifndef SWIGRUNTIMEINLINE
00185 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
00186 #endif
00187 
00188 /*  Generic buffer size */
00189 #ifndef SWIG_BUFFER_SIZE
00190 # define SWIG_BUFFER_SIZE 1024
00191 #endif
00192 
00193 /* Flags for pointer conversions */
00194 #define SWIG_POINTER_DISOWN        0x1
00195 #define SWIG_CAST_NEW_MEMORY       0x2
00196 
00197 /* Flags for new pointer objects */
00198 #define SWIG_POINTER_OWN           0x1
00199 
00200 
00201 /* 
00202    Flags/methods for returning states.
00203    
00204    The SWIG conversion methods, as ConvertPtr, return and integer 
00205    that tells if the conversion was successful or not. And if not,
00206    an error code can be returned (see swigerrors.swg for the codes).
00207    
00208    Use the following macros/flags to set or process the returning
00209    states.
00210    
00211    In old versions of SWIG, code such as the following was usually written:
00212 
00213      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
00214        // success code
00215      } else {
00216        //fail code
00217      }
00218 
00219    Now you can be more explicit:
00220 
00221     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
00222     if (SWIG_IsOK(res)) {
00223       // success code
00224     } else {
00225       // fail code
00226     }
00227 
00228    which is the same really, but now you can also do
00229 
00230     Type *ptr;
00231     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
00232     if (SWIG_IsOK(res)) {
00233       // success code
00234       if (SWIG_IsNewObj(res) {
00235         ...
00236        delete *ptr;
00237       } else {
00238         ...
00239       }
00240     } else {
00241       // fail code
00242     }
00243     
00244    I.e., now SWIG_ConvertPtr can return new objects and you can
00245    identify the case and take care of the deallocation. Of course that
00246    also requires SWIG_ConvertPtr to return new result values, such as
00247 
00248       int SWIG_ConvertPtr(obj, ptr,...) {         
00249         if (<obj is ok>) {                       
00250           if (<need new object>) {               
00251             *ptr = <ptr to new allocated object>; 
00252             return SWIG_NEWOBJ;                  
00253           } else {                               
00254             *ptr = <ptr to old object>;          
00255             return SWIG_OLDOBJ;                  
00256           }                               
00257         } else {                                 
00258           return SWIG_BADOBJ;                    
00259         }                                        
00260       }
00261 
00262    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
00263    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
00264    SWIG errors code.
00265 
00266    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
00267    allows to return the 'cast rank', for example, if you have this
00268 
00269        int food(double)
00270        int fooi(int);
00271 
00272    and you call
00273  
00274       food(1)   // cast rank '1'  (1 -> 1.0)
00275       fooi(1)   // cast rank '0'
00276 
00277    just use the SWIG_AddCast()/SWIG_CheckState()
00278 */
00279 
00280 #define SWIG_OK                    (0) 
00281 #define SWIG_ERROR                 (-1)
00282 #define SWIG_IsOK(r)               (r >= 0)
00283 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
00284 
00285 /* The CastRankLimit says how many bits are used for the cast rank */
00286 #define SWIG_CASTRANKLIMIT         (1 << 8)
00287 /* The NewMask denotes the object was created (using new/malloc) */
00288 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
00289 /* The TmpMask is for in/out typemaps that use temporal objects */
00290 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
00291 /* Simple returning values */
00292 #define SWIG_BADOBJ                (SWIG_ERROR)
00293 #define SWIG_OLDOBJ                (SWIG_OK)
00294 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
00295 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
00296 /* Check, add and del mask methods */
00297 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
00298 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
00299 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
00300 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
00301 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
00302 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
00303 
00304 /* Cast-Rank Mode */
00305 #if defined(SWIG_CASTRANK_MODE)
00306 #  ifndef SWIG_TypeRank
00307 #    define SWIG_TypeRank             unsigned long
00308 #  endif
00309 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
00310 #    define SWIG_MAXCASTRANK          (2)
00311 #  endif
00312 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
00313 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
00314 SWIGINTERNINLINE int SWIG_AddCast(int r) { 
00315   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
00316 }
00317 SWIGINTERNINLINE int SWIG_CheckState(int r) { 
00318   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
00319 }
00320 #else /* no cast-rank mode */
00321 #  define SWIG_AddCast
00322 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
00323 #endif
00324 
00325 
00326 #include <string.h>
00327 
00328 #ifdef __cplusplus
00329 extern "C" {
00330 #endif
00331 
00332 typedef void *(*swig_converter_func)(void *, int *);
00333 typedef struct swig_type_info *(*swig_dycast_func)(void **);
00334 
00335 /* Structure to store information on one type */
00336 typedef struct swig_type_info {
00337   const char             *name;                  /* mangled name of this type */
00338   const char             *str;                   /* human readable name of this type */
00339   swig_dycast_func        dcast;          /* dynamic cast function down a hierarchy */
00340   struct swig_cast_info  *cast;                  /* linked list of types that can cast into this type */
00341   void                   *clientdata;            /* language specific type data */
00342   int                    owndata;         /* flag if the structure owns the clientdata */
00343 } swig_type_info;
00344 
00345 /* Structure to store a type and conversion function used for casting */
00346 typedef struct swig_cast_info {
00347   swig_type_info         *type;                  /* pointer to type that is equivalent to this type */
00348   swig_converter_func     converter;             /* function to cast the void pointers */
00349   struct swig_cast_info  *next;                  /* pointer to next cast in linked list */
00350   struct swig_cast_info  *prev;                  /* pointer to the previous cast */
00351 } swig_cast_info;
00352 
00353 /* Structure used to store module information
00354  * Each module generates one structure like this, and the runtime collects
00355  * all of these structures and stores them in a circularly linked list.*/
00356 typedef struct swig_module_info {
00357   swig_type_info         **types;         /* Array of pointers to swig_type_info structures that are in this module */
00358   size_t                 size;                    /* Number of types in this module */
00359   struct swig_module_info *next;          /* Pointer to next element in circularly linked list */
00360   swig_type_info         **type_initial;  /* Array of initially generated type structures */
00361   swig_cast_info         **cast_initial;  /* Array of initially generated casting structures */
00362   void                    *clientdata;           /* Language specific module data */
00363 } swig_module_info;
00364 
00365 /* 
00366   Compare two type names skipping the space characters, therefore
00367   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
00368 
00369   Return 0 when the two name types are equivalent, as in
00370   strncmp, but skipping ' '.
00371 */
00372 SWIGRUNTIME int
00373 SWIG_TypeNameComp(const char *f1, const char *l1,
00374                 const char *f2, const char *l2) {
00375   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
00376     while ((*f1 == ' ') && (f1 != l1)) ++f1;
00377     while ((*f2 == ' ') && (f2 != l2)) ++f2;
00378     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
00379   }
00380   return (int)((l1 - f1) - (l2 - f2));
00381 }
00382 
00383 /*
00384   Check type equivalence in a name list like <name1>|<name2>|...
00385   Return 0 if not equal, 1 if equal
00386 */
00387 SWIGRUNTIME int
00388 SWIG_TypeEquiv(const char *nb, const char *tb) {
00389   int equiv = 0;
00390   const char* te = tb + strlen(tb);
00391   const char* ne = nb;
00392   while (!equiv && *ne) {
00393     for (nb = ne; *ne; ++ne) {
00394       if (*ne == '|') break;
00395     }
00396     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00397     if (*ne) ++ne;
00398   }
00399   return equiv;
00400 }
00401 
00402 /*
00403   Check type equivalence in a name list like <name1>|<name2>|...
00404   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
00405 */
00406 SWIGRUNTIME int
00407 SWIG_TypeCompare(const char *nb, const char *tb) {
00408   int equiv = 0;
00409   const char* te = tb + strlen(tb);
00410   const char* ne = nb;
00411   while (!equiv && *ne) {
00412     for (nb = ne; *ne; ++ne) {
00413       if (*ne == '|') break;
00414     }
00415     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00416     if (*ne) ++ne;
00417   }
00418   return equiv;
00419 }
00420 
00421 
00422 /*
00423   Check the typename
00424 */
00425 SWIGRUNTIME swig_cast_info *
00426 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
00427   if (ty) {
00428     swig_cast_info *iter = ty->cast;
00429     while (iter) {
00430       if (strcmp(iter->type->name, c) == 0) {
00431         if (iter == ty->cast)
00432           return iter;
00433         /* Move iter to the top of the linked list */
00434         iter->prev->next = iter->next;
00435         if (iter->next)
00436           iter->next->prev = iter->prev;
00437         iter->next = ty->cast;
00438         iter->prev = 0;
00439         if (ty->cast) ty->cast->prev = iter;
00440         ty->cast = iter;
00441         return iter;
00442       }
00443       iter = iter->next;
00444     }
00445   }
00446   return 0;
00447 }
00448 
00449 /* 
00450   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
00451 */
00452 SWIGRUNTIME swig_cast_info *
00453 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
00454   if (ty) {
00455     swig_cast_info *iter = ty->cast;
00456     while (iter) {
00457       if (iter->type == from) {
00458         if (iter == ty->cast)
00459           return iter;
00460         /* Move iter to the top of the linked list */
00461         iter->prev->next = iter->next;
00462         if (iter->next)
00463           iter->next->prev = iter->prev;
00464         iter->next = ty->cast;
00465         iter->prev = 0;
00466         if (ty->cast) ty->cast->prev = iter;
00467         ty->cast = iter;
00468         return iter;
00469       }
00470       iter = iter->next;
00471     }
00472   }
00473   return 0;
00474 }
00475 
00476 /*
00477   Cast a pointer up an inheritance hierarchy
00478 */
00479 SWIGRUNTIMEINLINE void *
00480 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
00481   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
00482 }
00483 
00484 /* 
00485    Dynamic pointer casting. Down an inheritance hierarchy
00486 */
00487 SWIGRUNTIME swig_type_info *
00488 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
00489   swig_type_info *lastty = ty;
00490   if (!ty || !ty->dcast) return ty;
00491   while (ty && (ty->dcast)) {
00492     ty = (*ty->dcast)(ptr);
00493     if (ty) lastty = ty;
00494   }
00495   return lastty;
00496 }
00497 
00498 /*
00499   Return the name associated with this type
00500 */
00501 SWIGRUNTIMEINLINE const char *
00502 SWIG_TypeName(const swig_type_info *ty) {
00503   return ty->name;
00504 }
00505 
00506 /*
00507   Return the pretty name associated with this type,
00508   that is an unmangled type name in a form presentable to the user.
00509 */
00510 SWIGRUNTIME const char *
00511 SWIG_TypePrettyName(const swig_type_info *type) {
00512   /* The "str" field contains the equivalent pretty names of the
00513      type, separated by vertical-bar characters.  We choose
00514      to print the last name, as it is often (?) the most
00515      specific. */
00516   if (!type) return NULL;
00517   if (type->str != NULL) {
00518     const char *last_name = type->str;
00519     const char *s;
00520     for (s = type->str; *s; s++)
00521       if (*s == '|') last_name = s+1;
00522     return last_name;
00523   }
00524   else
00525     return type->name;
00526 }
00527 
00528 /* 
00529    Set the clientdata field for a type
00530 */
00531 SWIGRUNTIME void
00532 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
00533   swig_cast_info *cast = ti->cast;
00534   /* if (ti->clientdata == clientdata) return; */
00535   ti->clientdata = clientdata;
00536   
00537   while (cast) {
00538     if (!cast->converter) {
00539       swig_type_info *tc = cast->type;
00540       if (!tc->clientdata) {
00541        SWIG_TypeClientData(tc, clientdata);
00542       }
00543     }    
00544     cast = cast->next;
00545   }
00546 }
00547 SWIGRUNTIME void
00548 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
00549   SWIG_TypeClientData(ti, clientdata);
00550   ti->owndata = 1;
00551 }
00552   
00553 /*
00554   Search for a swig_type_info structure only by mangled name
00555   Search is a O(log #types)
00556   
00557   We start searching at module start, and finish searching when start == end.  
00558   Note: if start == end at the beginning of the function, we go all the way around
00559   the circular list.
00560 */
00561 SWIGRUNTIME swig_type_info *
00562 SWIG_MangledTypeQueryModule(swig_module_info *start, 
00563                             swig_module_info *end, 
00564                           const char *name) {
00565   swig_module_info *iter = start;
00566   do {
00567     if (iter->size) {
00568       register size_t l = 0;
00569       register size_t r = iter->size - 1;
00570       do {
00571        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
00572        register size_t i = (l + r) >> 1; 
00573        const char *iname = iter->types[i]->name;
00574        if (iname) {
00575          register int compare = strcmp(name, iname);
00576          if (compare == 0) {           
00577            return iter->types[i];
00578          } else if (compare < 0) {
00579            if (i) {
00580              r = i - 1;
00581            } else {
00582              break;
00583            }
00584          } else if (compare > 0) {
00585            l = i + 1;
00586          }
00587        } else {
00588          break; /* should never happen */
00589        }
00590       } while (l <= r);
00591     }
00592     iter = iter->next;
00593   } while (iter != end);
00594   return 0;
00595 }
00596 
00597 /*
00598   Search for a swig_type_info structure for either a mangled name or a human readable name.
00599   It first searches the mangled names of the types, which is a O(log #types)
00600   If a type is not found it then searches the human readable names, which is O(#types).
00601   
00602   We start searching at module start, and finish searching when start == end.  
00603   Note: if start == end at the beginning of the function, we go all the way around
00604   the circular list.
00605 */
00606 SWIGRUNTIME swig_type_info *
00607 SWIG_TypeQueryModule(swig_module_info *start, 
00608                      swig_module_info *end, 
00609                    const char *name) {
00610   /* STEP 1: Search the name field using binary search */
00611   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
00612   if (ret) {
00613     return ret;
00614   } else {
00615     /* STEP 2: If the type hasn't been found, do a complete search
00616        of the str field (the human readable name) */
00617     swig_module_info *iter = start;
00618     do {
00619       register size_t i = 0;
00620       for (; i < iter->size; ++i) {
00621        if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
00622          return iter->types[i];
00623       }
00624       iter = iter->next;
00625     } while (iter != end);
00626   }
00627   
00628   /* neither found a match */
00629   return 0;
00630 }
00631 
00632 /* 
00633    Pack binary data into a string
00634 */
00635 SWIGRUNTIME char *
00636 SWIG_PackData(char *c, void *ptr, size_t sz) {
00637   static const char hex[17] = "0123456789abcdef";
00638   register const unsigned char *u = (unsigned char *) ptr;
00639   register const unsigned char *eu =  u + sz;
00640   for (; u != eu; ++u) {
00641     register unsigned char uu = *u;
00642     *(c++) = hex[(uu & 0xf0) >> 4];
00643     *(c++) = hex[uu & 0xf];
00644   }
00645   return c;
00646 }
00647 
00648 /* 
00649    Unpack binary data from a string
00650 */
00651 SWIGRUNTIME const char *
00652 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
00653   register unsigned char *u = (unsigned char *) ptr;
00654   register const unsigned char *eu = u + sz;
00655   for (; u != eu; ++u) {
00656     register char d = *(c++);
00657     register unsigned char uu;
00658     if ((d >= '0') && (d <= '9'))
00659       uu = ((d - '0') << 4);
00660     else if ((d >= 'a') && (d <= 'f'))
00661       uu = ((d - ('a'-10)) << 4);
00662     else 
00663       return (char *) 0;
00664     d = *(c++);
00665     if ((d >= '0') && (d <= '9'))
00666       uu |= (d - '0');
00667     else if ((d >= 'a') && (d <= 'f'))
00668       uu |= (d - ('a'-10));
00669     else 
00670       return (char *) 0;
00671     *u = uu;
00672   }
00673   return c;
00674 }
00675 
00676 /* 
00677    Pack 'void *' into a string buffer.
00678 */
00679 SWIGRUNTIME char *
00680 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
00681   char *r = buff;
00682   if ((2*sizeof(void *) + 2) > bsz) return 0;
00683   *(r++) = '_';
00684   r = SWIG_PackData(r,&ptr,sizeof(void *));
00685   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
00686   strcpy(r,name);
00687   return buff;
00688 }
00689 
00690 SWIGRUNTIME const char *
00691 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
00692   if (*c != '_') {
00693     if (strcmp(c,"NULL") == 0) {
00694       *ptr = (void *) 0;
00695       return name;
00696     } else {
00697       return 0;
00698     }
00699   }
00700   return SWIG_UnpackData(++c,ptr,sizeof(void *));
00701 }
00702 
00703 SWIGRUNTIME char *
00704 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
00705   char *r = buff;
00706   size_t lname = (name ? strlen(name) : 0);
00707   if ((2*sz + 2 + lname) > bsz) return 0;
00708   *(r++) = '_';
00709   r = SWIG_PackData(r,ptr,sz);
00710   if (lname) {
00711     strncpy(r,name,lname+1);
00712   } else {
00713     *r = 0;
00714   }
00715   return buff;
00716 }
00717 
00718 SWIGRUNTIME const char *
00719 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
00720   if (*c != '_') {
00721     if (strcmp(c,"NULL") == 0) {
00722       memset(ptr,0,sz);
00723       return name;
00724     } else {
00725       return 0;
00726     }
00727   }
00728   return SWIG_UnpackData(++c,ptr,sz);
00729 }
00730 
00731 #ifdef __cplusplus
00732 }
00733 #endif
00734 
00735 /*  Errors in SWIG */
00736 #define  SWIG_UnknownError            -1 
00737 #define  SWIG_IOError                 -2 
00738 #define  SWIG_RuntimeError            -3 
00739 #define  SWIG_IndexError              -4 
00740 #define  SWIG_TypeError               -5 
00741 #define  SWIG_DivisionByZero          -6 
00742 #define  SWIG_OverflowError           -7 
00743 #define  SWIG_SyntaxError             -8 
00744 #define  SWIG_ValueError              -9 
00745 #define  SWIG_SystemError             -10
00746 #define  SWIG_AttributeError          -11
00747 #define  SWIG_MemoryError             -12 
00748 #define  SWIG_NullReferenceError   -13
00749 
00750 
00751 
00752 /* Compatibility macros for Python 3 */
00753 #if PY_VERSION_HEX >= 0x03000000
00754 
00755 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
00756 #define PyInt_Check(x) PyLong_Check(x)
00757 #define PyInt_AsLong(x) PyLong_AsLong(x)
00758 #define PyInt_FromLong(x) PyLong_FromLong(x)
00759 #define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
00760 
00761 #endif
00762 
00763 #ifndef Py_TYPE
00764 #  define Py_TYPE(op) ((op)->ob_type)
00765 #endif
00766 
00767 /* SWIG APIs for compatibility of both Python 2 & 3 */
00768 
00769 #if PY_VERSION_HEX >= 0x03000000
00770 #  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
00771 #else
00772 #  define SWIG_Python_str_FromFormat PyString_FromFormat
00773 #endif
00774 
00775 
00776 /* Warning: This function will allocate a new string in Python 3,
00777  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
00778  */
00779 SWIGINTERN char*
00780 SWIG_Python_str_AsChar(PyObject *str)
00781 {
00782 #if PY_VERSION_HEX >= 0x03000000
00783   char *cstr;
00784   char *newstr;
00785   Py_ssize_t len;
00786   str = PyUnicode_AsUTF8String(str);
00787   PyBytes_AsStringAndSize(str, &cstr, &len);
00788   newstr = (char *) malloc(len+1);
00789   memcpy(newstr, cstr, len+1);
00790   Py_XDECREF(str);
00791   return newstr;
00792 #else
00793   return PyString_AsString(str);
00794 #endif
00795 }
00796 
00797 #if PY_VERSION_HEX >= 0x03000000
00798 #  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
00799 #else
00800 #  define SWIG_Python_str_DelForPy3(x) 
00801 #endif
00802 
00803 
00804 SWIGINTERN PyObject*
00805 SWIG_Python_str_FromChar(const char *c)
00806 {
00807 #if PY_VERSION_HEX >= 0x03000000
00808   return PyUnicode_FromString(c); 
00809 #else
00810   return PyString_FromString(c);
00811 #endif
00812 }
00813 
00814 /* Add PyOS_snprintf for old Pythons */
00815 #if PY_VERSION_HEX < 0x02020000
00816 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
00817 #  define PyOS_snprintf _snprintf
00818 # else
00819 #  define PyOS_snprintf snprintf
00820 # endif
00821 #endif
00822 
00823 /* A crude PyString_FromFormat implementation for old Pythons */
00824 #if PY_VERSION_HEX < 0x02020000
00825 
00826 #ifndef SWIG_PYBUFFER_SIZE
00827 # define SWIG_PYBUFFER_SIZE 1024
00828 #endif
00829 
00830 static PyObject *
00831 PyString_FromFormat(const char *fmt, ...) {
00832   va_list ap;
00833   char buf[SWIG_PYBUFFER_SIZE * 2];
00834   int res;
00835   va_start(ap, fmt);
00836   res = vsnprintf(buf, sizeof(buf), fmt, ap);
00837   va_end(ap);
00838   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
00839 }
00840 #endif
00841 
00842 /* Add PyObject_Del for old Pythons */
00843 #if PY_VERSION_HEX < 0x01060000
00844 # define PyObject_Del(op) PyMem_DEL((op))
00845 #endif
00846 #ifndef PyObject_DEL
00847 # define PyObject_DEL PyObject_Del
00848 #endif
00849 
00850 /* A crude PyExc_StopIteration exception for old Pythons */
00851 #if PY_VERSION_HEX < 0x02020000
00852 # ifndef PyExc_StopIteration
00853 #  define PyExc_StopIteration PyExc_RuntimeError
00854 # endif
00855 # ifndef PyObject_GenericGetAttr
00856 #  define PyObject_GenericGetAttr 0
00857 # endif
00858 #endif
00859 
00860 /* Py_NotImplemented is defined in 2.1 and up. */
00861 #if PY_VERSION_HEX < 0x02010000
00862 # ifndef Py_NotImplemented
00863 #  define Py_NotImplemented PyExc_RuntimeError
00864 # endif
00865 #endif
00866 
00867 /* A crude PyString_AsStringAndSize implementation for old Pythons */
00868 #if PY_VERSION_HEX < 0x02010000
00869 # ifndef PyString_AsStringAndSize
00870 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
00871 # endif
00872 #endif
00873 
00874 /* PySequence_Size for old Pythons */
00875 #if PY_VERSION_HEX < 0x02000000
00876 # ifndef PySequence_Size
00877 #  define PySequence_Size PySequence_Length
00878 # endif
00879 #endif
00880 
00881 /* PyBool_FromLong for old Pythons */
00882 #if PY_VERSION_HEX < 0x02030000
00883 static
00884 PyObject *PyBool_FromLong(long ok)
00885 {
00886   PyObject *result = ok ? Py_True : Py_False;
00887   Py_INCREF(result);
00888   return result;
00889 }
00890 #endif
00891 
00892 /* Py_ssize_t for old Pythons */
00893 /* This code is as recommended by: */
00894 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
00895 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
00896 typedef int Py_ssize_t;
00897 # define PY_SSIZE_T_MAX INT_MAX
00898 # define PY_SSIZE_T_MIN INT_MIN
00899 #endif
00900 
00901 /* -----------------------------------------------------------------------------
00902  * error manipulation
00903  * ----------------------------------------------------------------------------- */
00904 
00905 SWIGRUNTIME PyObject*
00906 SWIG_Python_ErrorType(int code) {
00907   PyObject* type = 0;
00908   switch(code) {
00909   case SWIG_MemoryError:
00910     type = PyExc_MemoryError;
00911     break;
00912   case SWIG_IOError:
00913     type = PyExc_IOError;
00914     break;
00915   case SWIG_RuntimeError:
00916     type = PyExc_RuntimeError;
00917     break;
00918   case SWIG_IndexError:
00919     type = PyExc_IndexError;
00920     break;
00921   case SWIG_TypeError:
00922     type = PyExc_TypeError;
00923     break;
00924   case SWIG_DivisionByZero:
00925     type = PyExc_ZeroDivisionError;
00926     break;
00927   case SWIG_OverflowError:
00928     type = PyExc_OverflowError;
00929     break;
00930   case SWIG_SyntaxError:
00931     type = PyExc_SyntaxError;
00932     break;
00933   case SWIG_ValueError:
00934     type = PyExc_ValueError;
00935     break;
00936   case SWIG_SystemError:
00937     type = PyExc_SystemError;
00938     break;
00939   case SWIG_AttributeError:
00940     type = PyExc_AttributeError;
00941     break;
00942   default:
00943     type = PyExc_RuntimeError;
00944   }
00945   return type;
00946 }
00947 
00948 
00949 SWIGRUNTIME void
00950 SWIG_Python_AddErrorMsg(const char* mesg)
00951 {
00952   PyObject *type = 0;
00953   PyObject *value = 0;
00954   PyObject *traceback = 0;
00955 
00956   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
00957   if (value) {
00958     char *tmp;
00959     PyObject *old_str = PyObject_Str(value);
00960     PyErr_Clear();
00961     Py_XINCREF(type);
00962 
00963     PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
00964     SWIG_Python_str_DelForPy3(tmp);
00965     Py_DECREF(old_str);
00966     Py_DECREF(value);
00967   } else {
00968     PyErr_SetString(PyExc_RuntimeError, mesg);
00969   }
00970 }
00971 
00972 #if defined(SWIG_PYTHON_NO_THREADS)
00973 #  if defined(SWIG_PYTHON_THREADS)
00974 #    undef SWIG_PYTHON_THREADS
00975 #  endif
00976 #endif
00977 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
00978 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
00979 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
00980 #      define SWIG_PYTHON_USE_GIL
00981 #    endif
00982 #  endif
00983 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
00984 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
00985 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
00986 #    endif
00987 #    ifdef __cplusplus /* C++ code */
00988        class SWIG_Python_Thread_Block {
00989          bool status;
00990          PyGILState_STATE state;
00991        public:
00992          void end() { if (status) { PyGILState_Release(state); status = false;} }
00993          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
00994          ~SWIG_Python_Thread_Block() { end(); }
00995        };
00996        class SWIG_Python_Thread_Allow {
00997          bool status;
00998          PyThreadState *save;
00999        public:
01000          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
01001          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
01002          ~SWIG_Python_Thread_Allow() { end(); }
01003        };
01004 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
01005 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
01006 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
01007 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
01008 #    else /* C code */
01009 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
01010 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
01011 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
01012 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
01013 #    endif
01014 #  else /* Old thread way, not implemented, user must provide it */
01015 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
01016 #      define SWIG_PYTHON_INITIALIZE_THREADS
01017 #    endif
01018 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
01019 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
01020 #    endif
01021 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
01022 #      define SWIG_PYTHON_THREAD_END_BLOCK
01023 #    endif
01024 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
01025 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
01026 #    endif
01027 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
01028 #      define SWIG_PYTHON_THREAD_END_ALLOW
01029 #    endif
01030 #  endif
01031 #else /* No thread support */
01032 #  define SWIG_PYTHON_INITIALIZE_THREADS
01033 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
01034 #  define SWIG_PYTHON_THREAD_END_BLOCK
01035 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
01036 #  define SWIG_PYTHON_THREAD_END_ALLOW
01037 #endif
01038 
01039 /* -----------------------------------------------------------------------------
01040  * Python API portion that goes into the runtime
01041  * ----------------------------------------------------------------------------- */
01042 
01043 #ifdef __cplusplus
01044 extern "C" {
01045 #if 0
01046 } /* cc-mode */
01047 #endif
01048 #endif
01049 
01050 /* -----------------------------------------------------------------------------
01051  * Constant declarations
01052  * ----------------------------------------------------------------------------- */
01053 
01054 /* Constant Types */
01055 #define SWIG_PY_POINTER 4
01056 #define SWIG_PY_BINARY  5
01057 
01058 /* Constant information structure */
01059 typedef struct swig_const_info {
01060   int type;
01061   char *name;
01062   long lvalue;
01063   double dvalue;
01064   void   *pvalue;
01065   swig_type_info **ptype;
01066 } swig_const_info;
01067 
01068 
01069 /* -----------------------------------------------------------------------------
01070  * Wrapper of PyInstanceMethod_New() used in Python 3
01071  * It is exported to the generated module, used for -fastproxy
01072  * ----------------------------------------------------------------------------- */
01073 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
01074 {
01075 #if PY_VERSION_HEX >= 0x03000000
01076   return PyInstanceMethod_New(func);
01077 #else
01078   return NULL;
01079 #endif
01080 }
01081 
01082 #ifdef __cplusplus
01083 #if 0
01084 { /* cc-mode */
01085 #endif
01086 }
01087 #endif
01088 
01089 
01090 /* -----------------------------------------------------------------------------
01091  * See the LICENSE file for information on copyright, usage and redistribution
01092  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
01093  *
01094  * pyrun.swg
01095  *
01096  * This file contains the runtime support for Python modules
01097  * and includes code for managing global variables and pointer
01098  * type checking.
01099  *
01100  * ----------------------------------------------------------------------------- */
01101 
01102 /* Common SWIG API */
01103 
01104 /* for raw pointers */
01105 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
01106 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
01107 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
01108 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
01109 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
01110 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
01111 #define swig_owntype                                    int
01112 
01113 /* for raw packed data */
01114 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
01115 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
01116 
01117 /* for class or struct pointers */
01118 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
01119 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
01120 
01121 /* for C or C++ function pointers */
01122 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
01123 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
01124 
01125 /* for C++ member pointers, ie, member methods */
01126 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
01127 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
01128 
01129 
01130 /* Runtime API */
01131 
01132 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
01133 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
01134 #define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
01135 
01136 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
01137 #define SWIG_SetErrorMsg                         SWIG_Python_SetErrorMsg                             
01138 #define SWIG_ErrorType(code)                     SWIG_Python_ErrorType(code)                        
01139 #define SWIG_Error(code, msg)                    SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
01140 #define SWIG_fail                                goto fail                                    
01141 
01142 
01143 /* Runtime API implementation */
01144 
01145 /* Error manipulation */
01146 
01147 SWIGINTERN void 
01148 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
01149   SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
01150   PyErr_SetObject(errtype, obj);
01151   Py_DECREF(obj);
01152   SWIG_PYTHON_THREAD_END_BLOCK;
01153 }
01154 
01155 SWIGINTERN void 
01156 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
01157   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
01158   PyErr_SetString(errtype, (char *) msg);
01159   SWIG_PYTHON_THREAD_END_BLOCK;
01160 }
01161 
01162 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
01163 
01164 /* Set a constant value */
01165 
01166 SWIGINTERN void
01167 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
01168   PyDict_SetItemString(d, (char*) name, obj);
01169   Py_DECREF(obj);                            
01170 }
01171 
01172 /* Append a value to the result obj */
01173 
01174 SWIGINTERN PyObject*
01175 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
01176 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
01177   if (!result) {
01178     result = obj;
01179   } else if (result == Py_None) {
01180     Py_DECREF(result);
01181     result = obj;
01182   } else {
01183     if (!PyList_Check(result)) {
01184       PyObject *o2 = result;
01185       result = PyList_New(1);
01186       PyList_SetItem(result, 0, o2);
01187     }
01188     PyList_Append(result,obj);
01189     Py_DECREF(obj);
01190   }
01191   return result;
01192 #else
01193   PyObject*   o2;
01194   PyObject*   o3;
01195   if (!result) {
01196     result = obj;
01197   } else if (result == Py_None) {
01198     Py_DECREF(result);
01199     result = obj;
01200   } else {
01201     if (!PyTuple_Check(result)) {
01202       o2 = result;
01203       result = PyTuple_New(1);
01204       PyTuple_SET_ITEM(result, 0, o2);
01205     }
01206     o3 = PyTuple_New(1);
01207     PyTuple_SET_ITEM(o3, 0, obj);
01208     o2 = result;
01209     result = PySequence_Concat(o2, o3);
01210     Py_DECREF(o2);
01211     Py_DECREF(o3);
01212   }
01213   return result;
01214 #endif
01215 }
01216 
01217 /* Unpack the argument tuple */
01218 
01219 SWIGINTERN int
01220 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
01221 {
01222   if (!args) {
01223     if (!min && !max) {
01224       return 1;
01225     } else {
01226       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
01227                  name, (min == max ? "" : "at least "), (int)min);
01228       return 0;
01229     }
01230   }  
01231   if (!PyTuple_Check(args)) {
01232     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
01233     return 0;
01234   } else {
01235     register Py_ssize_t l = PyTuple_GET_SIZE(args);
01236     if (l < min) {
01237       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
01238                  name, (min == max ? "" : "at least "), (int)min, (int)l);
01239       return 0;
01240     } else if (l > max) {
01241       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
01242                  name, (min == max ? "" : "at most "), (int)max, (int)l);
01243       return 0;
01244     } else {
01245       register int i;
01246       for (i = 0; i < l; ++i) {
01247        objs[i] = PyTuple_GET_ITEM(args, i);
01248       }
01249       for (; l < max; ++l) {
01250        objs[l] = 0;
01251       }
01252       return i + 1;
01253     }    
01254   }
01255 }
01256 
01257 /* A functor is a function object with one single object argument */
01258 #if PY_VERSION_HEX >= 0x02020000
01259 #define SWIG_Python_CallFunctor(functor, obj)            PyObject_CallFunctionObjArgs(functor, obj, NULL);
01260 #else
01261 #define SWIG_Python_CallFunctor(functor, obj)            PyObject_CallFunction(functor, "O", obj);
01262 #endif
01263 
01264 /*
01265   Helper for static pointer initialization for both C and C++ code, for example
01266   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
01267 */
01268 #ifdef __cplusplus
01269 #define SWIG_STATIC_POINTER(var)  var
01270 #else
01271 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
01272 #endif
01273 
01274 /* -----------------------------------------------------------------------------
01275  * Pointer declarations
01276  * ----------------------------------------------------------------------------- */
01277 
01278 /* Flags for new pointer objects */
01279 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
01280 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
01281 
01282 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
01283 
01284 #ifdef __cplusplus
01285 extern "C" {
01286 #if 0
01287 } /* cc-mode */
01288 #endif
01289 #endif
01290 
01291 /*  How to access Py_None */
01292 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
01293 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
01294 #    ifndef SWIG_PYTHON_BUILD_NONE
01295 #      define SWIG_PYTHON_BUILD_NONE
01296 #    endif
01297 #  endif
01298 #endif
01299 
01300 #ifdef SWIG_PYTHON_BUILD_NONE
01301 #  ifdef Py_None
01302 #   undef Py_None
01303 #   define Py_None SWIG_Py_None()
01304 #  endif
01305 SWIGRUNTIMEINLINE PyObject * 
01306 _SWIG_Py_None(void)
01307 {
01308   PyObject *none = Py_BuildValue((char*)"");
01309   Py_DECREF(none);
01310   return none;
01311 }
01312 SWIGRUNTIME PyObject * 
01313 SWIG_Py_None(void)
01314 {
01315   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
01316   return none;
01317 }
01318 #endif
01319 
01320 /* The python void return value */
01321 
01322 SWIGRUNTIMEINLINE PyObject * 
01323 SWIG_Py_Void(void)
01324 {
01325   PyObject *none = Py_None;
01326   Py_INCREF(none);
01327   return none;
01328 }
01329 
01330 /* SwigPyClientData */
01331 
01332 typedef struct {
01333   PyObject *klass;
01334   PyObject *newraw;
01335   PyObject *newargs;
01336   PyObject *destroy;
01337   int delargs;
01338   int implicitconv;
01339 } SwigPyClientData;
01340 
01341 SWIGRUNTIMEINLINE int 
01342 SWIG_Python_CheckImplicit(swig_type_info *ty)
01343 {
01344   SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
01345   return data ? data->implicitconv : 0;
01346 }
01347 
01348 SWIGRUNTIMEINLINE PyObject *
01349 SWIG_Python_ExceptionType(swig_type_info *desc) {
01350   SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
01351   PyObject *klass = data ? data->klass : 0;
01352   return (klass ? klass : PyExc_RuntimeError);
01353 }
01354 
01355 
01356 SWIGRUNTIME SwigPyClientData * 
01357 SwigPyClientData_New(PyObject* obj)
01358 {
01359   if (!obj) {
01360     return 0;
01361   } else {
01362     SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
01363     /* the klass element */
01364     data->klass = obj;
01365     Py_INCREF(data->klass);
01366     /* the newraw method and newargs arguments used to create a new raw instance */
01367     if (PyClass_Check(obj)) {
01368       data->newraw = 0;
01369       data->newargs = obj;
01370       Py_INCREF(obj);
01371     } else {
01372 #if (PY_VERSION_HEX < 0x02020000)
01373       data->newraw = 0;
01374 #else
01375       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
01376 #endif
01377       if (data->newraw) {
01378        Py_INCREF(data->newraw);
01379        data->newargs = PyTuple_New(1);
01380        PyTuple_SetItem(data->newargs, 0, obj);
01381       } else {
01382        data->newargs = obj;
01383       }
01384       Py_INCREF(data->newargs);
01385     }
01386     /* the destroy method, aka as the C++ delete method */
01387     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
01388     if (PyErr_Occurred()) {
01389       PyErr_Clear();
01390       data->destroy = 0;
01391     }
01392     if (data->destroy) {
01393       int flags;
01394       Py_INCREF(data->destroy);
01395       flags = PyCFunction_GET_FLAGS(data->destroy);
01396 #ifdef METH_O
01397       data->delargs = !(flags & (METH_O));
01398 #else
01399       data->delargs = 0;
01400 #endif
01401     } else {
01402       data->delargs = 0;
01403     }
01404     data->implicitconv = 0;
01405     return data;
01406   }
01407 }
01408 
01409 SWIGRUNTIME void 
01410 SwigPyClientData_Del(SwigPyClientData* data)
01411 {
01412   Py_XDECREF(data->newraw);
01413   Py_XDECREF(data->newargs);
01414   Py_XDECREF(data->destroy);
01415 }
01416 
01417 /* =============== SwigPyObject =====================*/
01418 
01419 typedef struct {
01420   PyObject_HEAD
01421   void *ptr;
01422   swig_type_info *ty;
01423   int own;
01424   PyObject *next;
01425 } SwigPyObject;
01426 
01427 SWIGRUNTIME PyObject *
01428 SwigPyObject_long(SwigPyObject *v)
01429 {
01430   return PyLong_FromVoidPtr(v->ptr);
01431 }
01432 
01433 SWIGRUNTIME PyObject *
01434 SwigPyObject_format(const char* fmt, SwigPyObject *v)
01435 {
01436   PyObject *res = NULL;
01437   PyObject *args = PyTuple_New(1);
01438   if (args) {
01439     if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
01440       PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
01441       if (ofmt) {
01442 #if PY_VERSION_HEX >= 0x03000000
01443        res = PyUnicode_Format(ofmt,args);
01444 #else
01445        res = PyString_Format(ofmt,args);
01446 #endif
01447        Py_DECREF(ofmt);
01448       }
01449       Py_DECREF(args);
01450     }
01451   }
01452   return res;
01453 }
01454 
01455 SWIGRUNTIME PyObject *
01456 SwigPyObject_oct(SwigPyObject *v)
01457 {
01458   return SwigPyObject_format("%o",v);
01459 }
01460 
01461 SWIGRUNTIME PyObject *
01462 SwigPyObject_hex(SwigPyObject *v)
01463 {
01464   return SwigPyObject_format("%x",v);
01465 }
01466 
01467 SWIGRUNTIME PyObject *
01468 #ifdef METH_NOARGS
01469 SwigPyObject_repr(SwigPyObject *v)
01470 #else
01471 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
01472 #endif
01473 {
01474   const char *name = SWIG_TypePrettyName(v->ty);
01475   PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, v);
01476   if (v->next) {
01477 #ifdef METH_NOARGS
01478     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
01479 #else
01480     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
01481 #endif
01482 #if PY_VERSION_HEX >= 0x03000000
01483     PyObject *joined = PyUnicode_Concat(repr, nrep);
01484     Py_DecRef(repr);
01485     Py_DecRef(nrep);
01486     repr = joined;
01487 #else
01488     PyString_ConcatAndDel(&repr,nrep);
01489 #endif
01490   }
01491   return repr;  
01492 }
01493 
01494 SWIGRUNTIME int
01495 SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
01496 {
01497   char *str;
01498 #ifdef METH_NOARGS
01499   PyObject *repr = SwigPyObject_repr(v);
01500 #else
01501   PyObject *repr = SwigPyObject_repr(v, NULL);
01502 #endif
01503   if (repr) {
01504     str = SWIG_Python_str_AsChar(repr); 
01505     fputs(str, fp);
01506     SWIG_Python_str_DelForPy3(str);
01507     Py_DECREF(repr);
01508     return 0; 
01509   } else {
01510     return 1; 
01511   }
01512 }
01513 
01514 SWIGRUNTIME PyObject *
01515 SwigPyObject_str(SwigPyObject *v)
01516 {
01517   char result[SWIG_BUFFER_SIZE];
01518   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
01519     SWIG_Python_str_FromChar(result) : 0;
01520 }
01521 
01522 SWIGRUNTIME int
01523 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
01524 {
01525   void *i = v->ptr;
01526   void *j = w->ptr;
01527   return (i < j) ? -1 : ((i > j) ? 1 : 0);
01528 }
01529 
01530 /* Added for Python 3.x, would it also be useful for Python 2.x? */
01531 SWIGRUNTIME PyObject*
01532 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
01533 {
01534   PyObject* res;
01535   if( op != Py_EQ && op != Py_NE ) {
01536     Py_INCREF(Py_NotImplemented);
01537     return Py_NotImplemented;
01538   }
01539   if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
01540     res = Py_True;
01541   else
01542     res = Py_False;
01543   Py_INCREF(res);
01544   return res;  
01545 }
01546 
01547 
01548 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
01549 
01550 SWIGRUNTIME PyTypeObject*
01551 SwigPyObject_type(void) {
01552   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
01553   return type;
01554 }
01555 
01556 SWIGRUNTIMEINLINE int
01557 SwigPyObject_Check(PyObject *op) {
01558   return (Py_TYPE(op) == SwigPyObject_type())
01559     || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
01560 }
01561 
01562 SWIGRUNTIME PyObject *
01563 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
01564 
01565 SWIGRUNTIME void
01566 SwigPyObject_dealloc(PyObject *v)
01567 {
01568   SwigPyObject *sobj = (SwigPyObject *) v;
01569   PyObject *next = sobj->next;
01570   if (sobj->own == SWIG_POINTER_OWN) {
01571     swig_type_info *ty = sobj->ty;
01572     SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
01573     PyObject *destroy = data ? data->destroy : 0;
01574     if (destroy) {
01575       /* destroy is always a VARARGS method */
01576       PyObject *res;
01577       if (data->delargs) {
01578        /* we need to create a temporary object to carry the destroy operation */
01579        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
01580        res = SWIG_Python_CallFunctor(destroy, tmp);
01581        Py_DECREF(tmp);
01582       } else {
01583        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
01584        PyObject *mself = PyCFunction_GET_SELF(destroy);
01585        res = ((*meth)(mself, v));
01586       }
01587       Py_XDECREF(res);
01588     } 
01589 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
01590     else {
01591       const char *name = SWIG_TypePrettyName(ty);
01592       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
01593     }
01594 #endif
01595   } 
01596   Py_XDECREF(next);
01597   PyObject_DEL(v);
01598 }
01599 
01600 SWIGRUNTIME PyObject* 
01601 SwigPyObject_append(PyObject* v, PyObject* next)
01602 {
01603   SwigPyObject *sobj = (SwigPyObject *) v;
01604 #ifndef METH_O
01605   PyObject *tmp = 0;
01606   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
01607   next = tmp;
01608 #endif
01609   if (!SwigPyObject_Check(next)) {
01610     return NULL;
01611   }
01612   sobj->next = next;
01613   Py_INCREF(next);
01614   return SWIG_Py_Void();
01615 }
01616 
01617 SWIGRUNTIME PyObject* 
01618 #ifdef METH_NOARGS
01619 SwigPyObject_next(PyObject* v)
01620 #else
01621 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01622 #endif
01623 {
01624   SwigPyObject *sobj = (SwigPyObject *) v;
01625   if (sobj->next) {    
01626     Py_INCREF(sobj->next);
01627     return sobj->next;
01628   } else {
01629     return SWIG_Py_Void();
01630   }
01631 }
01632 
01633 SWIGINTERN PyObject*
01634 #ifdef METH_NOARGS
01635 SwigPyObject_disown(PyObject *v)
01636 #else
01637 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01638 #endif
01639 {
01640   SwigPyObject *sobj = (SwigPyObject *)v;
01641   sobj->own = 0;
01642   return SWIG_Py_Void();
01643 }
01644 
01645 SWIGINTERN PyObject*
01646 #ifdef METH_NOARGS
01647 SwigPyObject_acquire(PyObject *v)
01648 #else
01649 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01650 #endif
01651 {
01652   SwigPyObject *sobj = (SwigPyObject *)v;
01653   sobj->own = SWIG_POINTER_OWN;
01654   return SWIG_Py_Void();
01655 }
01656 
01657 SWIGINTERN PyObject*
01658 SwigPyObject_own(PyObject *v, PyObject *args)
01659 {
01660   PyObject *val = 0;
01661 #if (PY_VERSION_HEX < 0x02020000)
01662   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
01663 #else
01664   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
01665 #endif
01666     {
01667       return NULL;
01668     } 
01669   else
01670     {
01671       SwigPyObject *sobj = (SwigPyObject *)v;
01672       PyObject *obj = PyBool_FromLong(sobj->own);
01673       if (val) {
01674 #ifdef METH_NOARGS
01675        if (PyObject_IsTrue(val)) {
01676          SwigPyObject_acquire(v);
01677        } else {
01678          SwigPyObject_disown(v);
01679        }
01680 #else
01681        if (PyObject_IsTrue(val)) {
01682          SwigPyObject_acquire(v,args);
01683        } else {
01684          SwigPyObject_disown(v,args);
01685        }
01686 #endif
01687       } 
01688       return obj;
01689     }
01690 }
01691 
01692 #ifdef METH_O
01693 static PyMethodDef
01694 swigobject_methods[] = {
01695   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
01696   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
01697   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
01698   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
01699   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
01700   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
01701   {0, 0, 0, 0}  
01702 };
01703 #else
01704 static PyMethodDef
01705 swigobject_methods[] = {
01706   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
01707   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
01708   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
01709   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
01710   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
01711   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
01712   {0, 0, 0, 0}  
01713 };
01714 #endif
01715 
01716 #if PY_VERSION_HEX < 0x02020000
01717 SWIGINTERN PyObject *
01718 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
01719 {
01720   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
01721 }
01722 #endif
01723 
01724 SWIGRUNTIME PyTypeObject*
01725 _PySwigObject_type(void) {
01726   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
01727   
01728   static PyNumberMethods SwigPyObject_as_number = {
01729     (binaryfunc)0, /*nb_add*/
01730     (binaryfunc)0, /*nb_subtract*/
01731     (binaryfunc)0, /*nb_multiply*/
01732     /* nb_divide removed in Python 3 */
01733 #if PY_VERSION_HEX < 0x03000000
01734     (binaryfunc)0, /*nb_divide*/
01735 #endif
01736     (binaryfunc)0, /*nb_remainder*/
01737     (binaryfunc)0, /*nb_divmod*/
01738     (ternaryfunc)0,/*nb_power*/
01739     (unaryfunc)0,  /*nb_negative*/
01740     (unaryfunc)0,  /*nb_positive*/
01741     (unaryfunc)0,  /*nb_absolute*/
01742     (inquiry)0,    /*nb_nonzero*/
01743     0,           /*nb_invert*/
01744     0,           /*nb_lshift*/
01745     0,           /*nb_rshift*/
01746     0,           /*nb_and*/
01747     0,           /*nb_xor*/
01748     0,           /*nb_or*/
01749 #if PY_VERSION_HEX < 0x03000000
01750     0,   /*nb_coerce*/
01751 #endif
01752     (unaryfunc)SwigPyObject_long, /*nb_int*/
01753 #if PY_VERSION_HEX < 0x03000000
01754     (unaryfunc)SwigPyObject_long, /*nb_long*/
01755 #else
01756     0, /*nb_reserved*/
01757 #endif
01758     (unaryfunc)0,                 /*nb_float*/
01759 #if PY_VERSION_HEX < 0x03000000
01760     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
01761     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
01762 #endif
01763 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
01764     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
01765 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
01766     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
01767 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
01768     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
01769 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
01770     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
01771 #endif
01772   };
01773 
01774   static PyTypeObject swigpyobject_type;  
01775   static int type_init = 0;
01776   if (!type_init) {
01777     const PyTypeObject tmp
01778       = {
01779        /* PyObject header changed in Python 3 */
01780 #if PY_VERSION_HEX >= 0x03000000
01781        PyVarObject_HEAD_INIT(&PyType_Type, 0)
01782 #else    
01783        PyObject_HEAD_INIT(NULL)
01784        0,                              /* ob_size */
01785 #endif
01786        (char *)"SwigPyObject",                /* tp_name */
01787        sizeof(SwigPyObject),                  /* tp_basicsize */
01788        0,                               /* tp_itemsize */
01789        (destructor)SwigPyObject_dealloc,   /* tp_dealloc */
01790        (printfunc)SwigPyObject_print,         /* tp_print */
01791 #if PY_VERSION_HEX < 0x02020000
01792        (getattrfunc)SwigPyObject_getattr,  /* tp_getattr */ 
01793 #else
01794        (getattrfunc)0,                        /* tp_getattr */ 
01795 #endif
01796        (setattrfunc)0,                        /* tp_setattr */ 
01797 #if PY_VERSION_HEX >= 0x03000000
01798     0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
01799 #else
01800        (cmpfunc)SwigPyObject_compare,         /* tp_compare */
01801 #endif
01802        (reprfunc)SwigPyObject_repr,           /* tp_repr */    
01803        &SwigPyObject_as_number,        /* tp_as_number */
01804        0,                              /* tp_as_sequence */
01805        0,                              /* tp_as_mapping */
01806        (hashfunc)0,                    /* tp_hash */
01807        (ternaryfunc)0,                        /* tp_call */
01808        (reprfunc)SwigPyObject_str,     /* tp_str */
01809        PyObject_GenericGetAttr,            /* tp_getattro */
01810        0,                              /* tp_setattro */
01811        0,                                /* tp_as_buffer */
01812        Py_TPFLAGS_DEFAULT,              /* tp_flags */
01813        swigobject_doc,                  /* tp_doc */        
01814        0,                                  /* tp_traverse */
01815        0,                                  /* tp_clear */
01816        (richcmpfunc)SwigPyObject_richcompare,           /* tp_richcompare */
01817        0,                                  /* tp_weaklistoffset */
01818 #if PY_VERSION_HEX >= 0x02020000
01819        0,                                  /* tp_iter */
01820        0,                                  /* tp_iternext */
01821        swigobject_methods,             /* tp_methods */ 
01822        0,                               /* tp_members */
01823        0,                              /* tp_getset */         
01824        0,                               /* tp_base */           
01825        0,                              /* tp_dict */           
01826        0,                              /* tp_descr_get */      
01827        0,                              /* tp_descr_set */      
01828        0,                              /* tp_dictoffset */     
01829        0,                              /* tp_init */           
01830        0,                              /* tp_alloc */          
01831        0,                               /* tp_new */           
01832        0,                                 /* tp_free */    
01833        0,                                  /* tp_is_gc */  
01834        0,                              /* tp_bases */   
01835        0,                              /* tp_mro */
01836        0,                              /* tp_cache */   
01837        0,                              /* tp_subclasses */
01838        0,                              /* tp_weaklist */
01839 #endif
01840 #if PY_VERSION_HEX >= 0x02030000
01841        0,                                  /* tp_del */
01842 #endif
01843 #ifdef COUNT_ALLOCS
01844        0,0,0,0                             /* tp_alloc -> tp_next */
01845 #endif
01846       };
01847     swigpyobject_type = tmp;
01848     /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
01849 #if PY_VERSION_HEX < 0x03000000
01850     swigpyobject_type.ob_type = &PyType_Type;
01851 #endif
01852     type_init = 1;
01853   }
01854   return &swigpyobject_type;
01855 }
01856 
01857 SWIGRUNTIME PyObject *
01858 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
01859 {
01860   SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
01861   if (sobj) {
01862     sobj->ptr  = ptr;
01863     sobj->ty   = ty;
01864     sobj->own  = own;
01865     sobj->next = 0;
01866   }
01867   return (PyObject *)sobj;
01868 }
01869 
01870 /* -----------------------------------------------------------------------------
01871  * Implements a simple Swig Packed type, and use it instead of string
01872  * ----------------------------------------------------------------------------- */
01873 
01874 typedef struct {
01875   PyObject_HEAD
01876   void *pack;
01877   swig_type_info *ty;
01878   size_t size;
01879 } SwigPyPacked;
01880 
01881 SWIGRUNTIME int
01882 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
01883 {
01884   char result[SWIG_BUFFER_SIZE];
01885   fputs("<Swig Packed ", fp); 
01886   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01887     fputs("at ", fp); 
01888     fputs(result, fp); 
01889   }
01890   fputs(v->ty->name,fp); 
01891   fputs(">", fp);
01892   return 0; 
01893 }
01894   
01895 SWIGRUNTIME PyObject *
01896 SwigPyPacked_repr(SwigPyPacked *v)
01897 {
01898   char result[SWIG_BUFFER_SIZE];
01899   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01900     return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
01901   } else {
01902     return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
01903   }  
01904 }
01905 
01906 SWIGRUNTIME PyObject *
01907 SwigPyPacked_str(SwigPyPacked *v)
01908 {
01909   char result[SWIG_BUFFER_SIZE];
01910   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
01911     return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
01912   } else {
01913     return SWIG_Python_str_FromChar(v->ty->name);
01914   }  
01915 }
01916 
01917 SWIGRUNTIME int
01918 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
01919 {
01920   size_t i = v->size;
01921   size_t j = w->size;
01922   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
01923   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
01924 }
01925 
01926 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
01927 
01928 SWIGRUNTIME PyTypeObject*
01929 SwigPyPacked_type(void) {
01930   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
01931   return type;
01932 }
01933 
01934 SWIGRUNTIMEINLINE int
01935 SwigPyPacked_Check(PyObject *op) {
01936   return ((op)->ob_type == _PySwigPacked_type()) 
01937     || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
01938 }
01939 
01940 SWIGRUNTIME void
01941 SwigPyPacked_dealloc(PyObject *v)
01942 {
01943   if (SwigPyPacked_Check(v)) {
01944     SwigPyPacked *sobj = (SwigPyPacked *) v;
01945     free(sobj->pack);
01946   }
01947   PyObject_DEL(v);
01948 }
01949 
01950 SWIGRUNTIME PyTypeObject*
01951 _PySwigPacked_type(void) {
01952   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
01953   static PyTypeObject swigpypacked_type;
01954   static int type_init = 0;  
01955   if (!type_init) {
01956     const PyTypeObject tmp
01957       = {
01958     /* PyObject header changed in Python 3 */
01959 #if PY_VERSION_HEX>=0x03000000
01960     PyVarObject_HEAD_INIT(&PyType_Type, 0)
01961 #else
01962        PyObject_HEAD_INIT(NULL)
01963     0,                          /* ob_size */    
01964 #endif
01965        (char *)"SwigPyPacked",                /* tp_name */    
01966        sizeof(SwigPyPacked),                  /* tp_basicsize */      
01967        0,                              /* tp_itemsize */       
01968        (destructor)SwigPyPacked_dealloc,   /* tp_dealloc */    
01969        (printfunc)SwigPyPacked_print,         /* tp_print */          
01970        (getattrfunc)0,                        /* tp_getattr */        
01971        (setattrfunc)0,                        /* tp_setattr */        
01972 #if PY_VERSION_HEX>=0x03000000
01973     0, /* tp_reserved in 3.0.1 */
01974 #else
01975     (cmpfunc)SwigPyPacked_compare,     /* tp_compare */
01976 #endif
01977        (reprfunc)SwigPyPacked_repr,           /* tp_repr */
01978        0,                                 /* tp_as_number */
01979        0,                              /* tp_as_sequence */
01980        0,                              /* tp_as_mapping */
01981        (hashfunc)0,                    /* tp_hash */
01982        (ternaryfunc)0,                        /* tp_call */
01983        (reprfunc)SwigPyPacked_str,     /* tp_str */
01984        PyObject_GenericGetAttr,            /* tp_getattro */
01985        0,                              /* tp_setattro */
01986        0,                                /* tp_as_buffer */
01987        Py_TPFLAGS_DEFAULT,              /* tp_flags */
01988        swigpacked_doc,                  /* tp_doc */
01989        0,                                  /* tp_traverse */
01990        0,                                  /* tp_clear */
01991        0,                                  /* tp_richcompare */
01992        0,                                  /* tp_weaklistoffset */
01993 #if PY_VERSION_HEX >= 0x02020000
01994        0,                                  /* tp_iter */
01995        0,                                  /* tp_iternext */
01996        0,                                /* tp_methods */ 
01997        0,                               /* tp_members */
01998        0,                              /* tp_getset */         
01999        0,                               /* tp_base */           
02000        0,                              /* tp_dict */           
02001        0,                              /* tp_descr_get */      
02002        0,                              /* tp_descr_set */      
02003        0,                              /* tp_dictoffset */     
02004        0,                              /* tp_init */           
02005        0,                              /* tp_alloc */          
02006        0,                               /* tp_new */           
02007        0,                                 /* tp_free */    
02008         0,                                  /* tp_is_gc */  
02009        0,                              /* tp_bases */   
02010        0,                              /* tp_mro */
02011        0,                              /* tp_cache */   
02012        0,                              /* tp_subclasses */
02013        0,                              /* tp_weaklist */
02014 #endif
02015 #if PY_VERSION_HEX >= 0x02030000
02016        0,                                  /* tp_del */
02017 #endif
02018 #ifdef COUNT_ALLOCS
02019        0,0,0,0                             /* tp_alloc -> tp_next */
02020 #endif
02021       };
02022     swigpypacked_type = tmp;
02023     /* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
02024 #if PY_VERSION_HEX < 0x03000000
02025     swigpypacked_type.ob_type = &PyType_Type;
02026 #endif
02027     type_init = 1;
02028   }
02029   return &swigpypacked_type;
02030 }
02031 
02032 SWIGRUNTIME PyObject *
02033 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
02034 {
02035   SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
02036   if (sobj) {
02037     void *pack = malloc(size);
02038     if (pack) {
02039       memcpy(pack, ptr, size);
02040       sobj->pack = pack;
02041       sobj->ty   = ty;
02042       sobj->size = size;
02043     } else {
02044       PyObject_DEL((PyObject *) sobj);
02045       sobj = 0;
02046     }
02047   }
02048   return (PyObject *) sobj;
02049 }
02050 
02051 SWIGRUNTIME swig_type_info *
02052 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
02053 {
02054   if (SwigPyPacked_Check(obj)) {
02055     SwigPyPacked *sobj = (SwigPyPacked *)obj;
02056     if (sobj->size != size) return 0;
02057     memcpy(ptr, sobj->pack, size);
02058     return sobj->ty;
02059   } else {
02060     return 0;
02061   }
02062 }
02063 
02064 /* -----------------------------------------------------------------------------
02065  * pointers/data manipulation
02066  * ----------------------------------------------------------------------------- */
02067 
02068 SWIGRUNTIMEINLINE PyObject *
02069 _SWIG_This(void)
02070 {
02071     return SWIG_Python_str_FromChar("this");
02072 }
02073 
02074 SWIGRUNTIME PyObject *
02075 SWIG_This(void)
02076 {
02077   static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
02078   return swig_this;
02079 }
02080 
02081 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
02082 
02083 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
02084 #if PY_VERSION_HEX>=0x03000000
02085 #define SWIG_PYTHON_SLOW_GETSET_THIS 
02086 #endif
02087 
02088 SWIGRUNTIME SwigPyObject *
02089 SWIG_Python_GetSwigThis(PyObject *pyobj) 
02090 {
02091   if (SwigPyObject_Check(pyobj)) {
02092     return (SwigPyObject *) pyobj;
02093   } else {
02094     PyObject *obj = 0;
02095 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
02096     if (PyInstance_Check(pyobj)) {
02097       obj = _PyInstance_Lookup(pyobj, SWIG_This());      
02098     } else {
02099       PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
02100       if (dictptr != NULL) {
02101        PyObject *dict = *dictptr;
02102        obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
02103       } else {
02104 #ifdef PyWeakref_CheckProxy
02105        if (PyWeakref_CheckProxy(pyobj)) {
02106          PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
02107          return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
02108        }
02109 #endif
02110        obj = PyObject_GetAttr(pyobj,SWIG_This());
02111        if (obj) {
02112          Py_DECREF(obj);
02113        } else {
02114          if (PyErr_Occurred()) PyErr_Clear();
02115          return 0;
02116        }
02117       }
02118     }
02119 #else
02120     obj = PyObject_GetAttr(pyobj,SWIG_This());
02121     if (obj) {
02122       Py_DECREF(obj);
02123     } else {
02124       if (PyErr_Occurred()) PyErr_Clear();
02125       return 0;
02126     }
02127 #endif
02128     if (obj && !SwigPyObject_Check(obj)) {
02129       /* a PyObject is called 'this', try to get the 'real this'
02130         SwigPyObject from it */ 
02131       return SWIG_Python_GetSwigThis(obj);
02132     }
02133     return (SwigPyObject *)obj;
02134   }
02135 }
02136 
02137 /* Acquire a pointer value */
02138 
02139 SWIGRUNTIME int
02140 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
02141   if (own == SWIG_POINTER_OWN) {
02142     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
02143     if (sobj) {
02144       int oldown = sobj->own;
02145       sobj->own = own;
02146       return oldown;
02147     }
02148   }
02149   return 0;
02150 }
02151 
02152 /* Convert a pointer value */
02153 
02154 SWIGRUNTIME int
02155 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
02156   if (!obj) return SWIG_ERROR;
02157   if (obj == Py_None) {
02158     if (ptr) *ptr = 0;
02159     return SWIG_OK;
02160   } else {
02161     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
02162     if (own)
02163       *own = 0;
02164     while (sobj) {
02165       void *vptr = sobj->ptr;
02166       if (ty) {
02167        swig_type_info *to = sobj->ty;
02168        if (to == ty) {
02169          /* no type cast needed */
02170          if (ptr) *ptr = vptr;
02171          break;
02172        } else {
02173          swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
02174          if (!tc) {
02175            sobj = (SwigPyObject *)sobj->next;
02176          } else {
02177            if (ptr) {
02178               int newmemory = 0;
02179               *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
02180               if (newmemory == SWIG_CAST_NEW_MEMORY) {
02181                 assert(own);
02182                 if (own)
02183                   *own = *own | SWIG_CAST_NEW_MEMORY;
02184               }
02185             }
02186            break;
02187          }
02188        }
02189       } else {
02190        if (ptr) *ptr = vptr;
02191        break;
02192       }
02193     }
02194     if (sobj) {
02195       if (own)
02196         *own = *own | sobj->own;
02197       if (flags & SWIG_POINTER_DISOWN) {
02198        sobj->own = 0;
02199       }
02200       return SWIG_OK;
02201     } else {
02202       int res = SWIG_ERROR;
02203       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
02204        SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
02205        if (data && !data->implicitconv) {
02206          PyObject *klass = data->klass;
02207          if (klass) {
02208            PyObject *impconv;
02209            data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
02210            impconv = SWIG_Python_CallFunctor(klass, obj);
02211            data->implicitconv = 0;
02212            if (PyErr_Occurred()) {
02213              PyErr_Clear();
02214              impconv = 0;
02215            }
02216            if (impconv) {
02217              SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
02218              if (iobj) {
02219               void *vptr;
02220               res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
02221               if (SWIG_IsOK(res)) {
02222                 if (ptr) {
02223                   *ptr = vptr;
02224                   /* transfer the ownership to 'ptr' */
02225                   iobj->own = 0;
02226                   res = SWIG_AddCast(res);
02227                   res = SWIG_AddNewMask(res);
02228                 } else {
02229                   res = SWIG_AddCast(res);                  
02230                 }
02231               }
02232              }
02233              Py_DECREF(impconv);
02234            }
02235          }
02236        }
02237       }
02238       return res;
02239     }
02240   }
02241 }
02242 
02243 /* Convert a function ptr value */
02244 
02245 SWIGRUNTIME int
02246 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
02247   if (!PyCFunction_Check(obj)) {
02248     return SWIG_ConvertPtr(obj, ptr, ty, 0);
02249   } else {
02250     void *vptr = 0;
02251     
02252     /* here we get the method pointer for callbacks */
02253     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
02254     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
02255     if (desc)
02256       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
02257     if (!desc) 
02258       return SWIG_ERROR;
02259     if (ty) {
02260       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
02261       if (tc) {
02262         int newmemory = 0;
02263         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
02264         assert(!newmemory); /* newmemory handling not yet implemented */
02265       } else {
02266         return SWIG_ERROR;
02267       }
02268     } else {
02269       *ptr = vptr;
02270     }
02271     return SWIG_OK;
02272   }
02273 }
02274 
02275 /* Convert a packed value value */
02276 
02277 SWIGRUNTIME int
02278 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
02279   swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
02280   if (!to) return SWIG_ERROR;
02281   if (ty) {
02282     if (to != ty) {
02283       /* check type cast? */
02284       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
02285       if (!tc) return SWIG_ERROR;
02286     }
02287   }
02288   return SWIG_OK;
02289 }  
02290 
02291 /* -----------------------------------------------------------------------------
02292  * Create a new pointer object
02293  * ----------------------------------------------------------------------------- */
02294 
02295 /*
02296   Create a new instance object, without calling __init__, and set the
02297   'this' attribute.
02298 */
02299 
02300 SWIGRUNTIME PyObject* 
02301 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
02302 {
02303 #if (PY_VERSION_HEX >= 0x02020000)
02304   PyObject *inst = 0;
02305   PyObject *newraw = data->newraw;
02306   if (newraw) {
02307     inst = PyObject_Call(newraw, data->newargs, NULL);
02308     if (inst) {
02309 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02310       PyObject **dictptr = _PyObject_GetDictPtr(inst);
02311       if (dictptr != NULL) {
02312        PyObject *dict = *dictptr;
02313        if (dict == NULL) {
02314          dict = PyDict_New();
02315          *dictptr = dict;
02316          PyDict_SetItem(dict, SWIG_This(), swig_this);
02317        }
02318       }
02319 #else
02320       PyObject *key = SWIG_This();
02321       PyObject_SetAttr(inst, key, swig_this);
02322 #endif
02323     }
02324   } else {
02325 #if PY_VERSION_HEX >= 0x03000000
02326     inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
02327     PyObject_SetAttr(inst, SWIG_This(), swig_this);
02328     Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
02329 #else
02330     PyObject *dict = PyDict_New();
02331     PyDict_SetItem(dict, SWIG_This(), swig_this);
02332     inst = PyInstance_NewRaw(data->newargs, dict);
02333     Py_DECREF(dict);
02334 #endif
02335   }
02336   return inst;
02337 #else
02338 #if (PY_VERSION_HEX >= 0x02010000)
02339   PyObject *inst;
02340   PyObject *dict = PyDict_New();
02341   PyDict_SetItem(dict, SWIG_This(), swig_this);
02342   inst = PyInstance_NewRaw(data->newargs, dict);
02343   Py_DECREF(dict);
02344   return (PyObject *) inst;
02345 #else
02346   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
02347   if (inst == NULL) {
02348     return NULL;
02349   }
02350   inst->in_class = (PyClassObject *)data->newargs;
02351   Py_INCREF(inst->in_class);
02352   inst->in_dict = PyDict_New();
02353   if (inst->in_dict == NULL) {
02354     Py_DECREF(inst);
02355     return NULL;
02356   }
02357 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
02358   inst->in_weakreflist = NULL;
02359 #endif
02360 #ifdef Py_TPFLAGS_GC
02361   PyObject_GC_Init(inst);
02362 #endif
02363   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
02364   return (PyObject *) inst;
02365 #endif
02366 #endif
02367 }
02368 
02369 SWIGRUNTIME void
02370 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
02371 {
02372  PyObject *dict;
02373 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02374  PyObject **dictptr = _PyObject_GetDictPtr(inst);
02375  if (dictptr != NULL) {
02376    dict = *dictptr;
02377    if (dict == NULL) {
02378      dict = PyDict_New();
02379      *dictptr = dict;
02380    }
02381    PyDict_SetItem(dict, SWIG_This(), swig_this);
02382    return;
02383  }
02384 #endif
02385  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
02386  PyDict_SetItem(dict, SWIG_This(), swig_this);
02387  Py_DECREF(dict);
02388 } 
02389 
02390 
02391 SWIGINTERN PyObject *
02392 SWIG_Python_InitShadowInstance(PyObject *args) {
02393   PyObject *obj[2];
02394   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
02395     return NULL;
02396   } else {
02397     SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
02398     if (sthis) {
02399       SwigPyObject_append((PyObject*) sthis, obj[1]);
02400     } else {
02401       SWIG_Python_SetSwigThis(obj[0], obj[1]);
02402     }
02403     return SWIG_Py_Void();
02404   }
02405 }
02406 
02407 /* Create a new pointer object */
02408 
02409 SWIGRUNTIME PyObject *
02410 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
02411   if (!ptr) {
02412     return SWIG_Py_Void();
02413   } else {
02414     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
02415     PyObject *robj = SwigPyObject_New(ptr, type, own);
02416     SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
02417     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
02418       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
02419       if (inst) {
02420        Py_DECREF(robj);
02421        robj = inst;
02422       }
02423     }
02424     return robj;
02425   }
02426 }
02427 
02428 /* Create a new packed object */
02429 
02430 SWIGRUNTIMEINLINE PyObject *
02431 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
02432   return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
02433 }
02434 
02435 /* -----------------------------------------------------------------------------*
02436  *  Get type list 
02437  * -----------------------------------------------------------------------------*/
02438 
02439 #ifdef SWIG_LINK_RUNTIME
02440 void *SWIG_ReturnGlobalTypeList(void *);
02441 #endif
02442 
02443 SWIGRUNTIME swig_module_info *
02444 SWIG_Python_GetModule(void) {
02445   static void *type_pointer = (void *)0;
02446   /* first check if module already created */
02447   if (!type_pointer) {
02448 #ifdef SWIG_LINK_RUNTIME
02449     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
02450 #else
02451     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
02452                                 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
02453     if (PyErr_Occurred()) {
02454       PyErr_Clear();
02455       type_pointer = (void *)0;
02456     }
02457 #endif
02458   }
02459   return (swig_module_info *) type_pointer;
02460 }
02461 
02462 #if PY_MAJOR_VERSION < 2
02463 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
02464    is copied out of Python/modsupport.c in python version 2.3.4 */
02465 SWIGINTERN int
02466 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
02467 {
02468   PyObject *dict;
02469   if (!PyModule_Check(m)) {
02470     PyErr_SetString(PyExc_TypeError,
02471                   "PyModule_AddObject() needs module as first arg");
02472     return SWIG_ERROR;
02473   }
02474   if (!o) {
02475     PyErr_SetString(PyExc_TypeError,
02476                   "PyModule_AddObject() needs non-NULL value");
02477     return SWIG_ERROR;
02478   }
02479   
02480   dict = PyModule_GetDict(m);
02481   if (dict == NULL) {
02482     /* Internal error -- modules must have a dict! */
02483     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
02484                PyModule_GetName(m));
02485     return SWIG_ERROR;
02486   }
02487   if (PyDict_SetItemString(dict, name, o))
02488     return SWIG_ERROR;
02489   Py_DECREF(o);
02490   return SWIG_OK;
02491 }
02492 #endif
02493 
02494 SWIGRUNTIME void
02495 SWIG_Python_DestroyModule(void *vptr)
02496 {
02497   swig_module_info *swig_module = (swig_module_info *) vptr;
02498   swig_type_info **types = swig_module->types;
02499   size_t i;
02500   for (i =0; i < swig_module->size; ++i) {
02501     swig_type_info *ty = types[i];
02502     if (ty->owndata) {
02503       SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
02504       if (data) SwigPyClientData_Del(data);
02505     }
02506   }
02507   Py_DECREF(SWIG_This());
02508 }
02509 
02510 SWIGRUNTIME void
02511 SWIG_Python_SetModule(swig_module_info *swig_module) {
02512   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
02513 
02514 #if PY_VERSION_HEX >= 0x03000000
02515  /* Add a dummy module object into sys.modules */
02516   PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
02517 #else
02518   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
02519                                swig_empty_runtime_method_table);
02520 #endif
02521   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
02522   if (pointer && module) {
02523     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
02524   } else {
02525     Py_XDECREF(pointer);
02526   }
02527 }
02528 
02529 /* The python cached type query */
02530 SWIGRUNTIME PyObject *
02531 SWIG_Python_TypeCache(void) {
02532   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
02533   return cache;
02534 }
02535 
02536 SWIGRUNTIME swig_type_info *
02537 SWIG_Python_TypeQuery(const char *type)
02538 {
02539   PyObject *cache = SWIG_Python_TypeCache();
02540   PyObject *key = SWIG_Python_str_FromChar(type); 
02541   PyObject *obj = PyDict_GetItem(cache, key);
02542   swig_type_info *descriptor;
02543   if (obj) {
02544     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
02545   } else {
02546     swig_module_info *swig_module = SWIG_Python_GetModule();
02547     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
02548     if (descriptor) {
02549       obj = PyCObject_FromVoidPtr(descriptor, NULL);
02550       PyDict_SetItem(cache, key, obj);
02551       Py_DECREF(obj);
02552     }
02553   }
02554   Py_DECREF(key);
02555   return descriptor;
02556 }
02557 
02558 /* 
02559    For backward compatibility only
02560 */
02561 #define SWIG_POINTER_EXCEPTION  0
02562 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
02563 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
02564 
02565 SWIGRUNTIME int
02566 SWIG_Python_AddErrMesg(const char* mesg, int infront)
02567 {  
02568   if (PyErr_Occurred()) {
02569     PyObject *type = 0;
02570     PyObject *value = 0;
02571     PyObject *traceback = 0;
02572     PyErr_Fetch(&type, &value, &traceback);
02573     if (value) {
02574       char *tmp;
02575       PyObject *old_str = PyObject_Str(value);
02576       Py_XINCREF(type);
02577       PyErr_Clear();
02578       if (infront) {
02579        PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
02580       } else {
02581        PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
02582       }
02583       SWIG_Python_str_DelForPy3(tmp);
02584       Py_DECREF(old_str);
02585     }
02586     return 1;
02587   } else {
02588     return 0;
02589   }
02590 }
02591   
02592 SWIGRUNTIME int
02593 SWIG_Python_ArgFail(int argnum)
02594 {
02595   if (PyErr_Occurred()) {
02596     /* add information about failing argument */
02597     char mesg[256];
02598     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
02599     return SWIG_Python_AddErrMesg(mesg, 1);
02600   } else {
02601     return 0;
02602   }
02603 }
02604 
02605 SWIGRUNTIMEINLINE const char *
02606 SwigPyObject_GetDesc(PyObject *self)
02607 {
02608   SwigPyObject *v = (SwigPyObject *)self;
02609   swig_type_info *ty = v ? v->ty : 0;
02610   return ty ? ty->str : (char*)"";
02611 }
02612 
02613 SWIGRUNTIME void
02614 SWIG_Python_TypeError(const char *type, PyObject *obj)
02615 {
02616   if (type) {
02617 #if defined(SWIG_COBJECT_TYPES)
02618     if (obj && SwigPyObject_Check(obj)) {
02619       const char *otype = (const char *) SwigPyObject_GetDesc(obj);
02620       if (otype) {
02621        PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
02622                    type, otype);
02623        return;
02624       }
02625     } else 
02626 #endif      
02627     {
02628       const char *otype = (obj ? obj->ob_type->tp_name : 0); 
02629       if (otype) {
02630        PyObject *str = PyObject_Str(obj);
02631        const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
02632        if (cstr) {
02633          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
02634                      type, otype, cstr);
02635           SWIG_Python_str_DelForPy3(cstr);
02636        } else {
02637          PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
02638                      type, otype);
02639        }
02640        Py_XDECREF(str);
02641        return;
02642       }
02643     }   
02644     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
02645   } else {
02646     PyErr_Format(PyExc_TypeError, "unexpected type is received");
02647   }
02648 }
02649 
02650 
02651 /* Convert a pointer value, signal an exception on a type mismatch */
02652 SWIGRUNTIME void *
02653 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
02654   void *result;
02655   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
02656     PyErr_Clear();
02657 #if SWIG_POINTER_EXCEPTION
02658     if (flags) {
02659       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
02660       SWIG_Python_ArgFail(argnum);
02661     }
02662 #endif
02663   }
02664   return result;
02665 }
02666 
02667 
02668 #ifdef __cplusplus
02669 #if 0
02670 { /* cc-mode */
02671 #endif
02672 }
02673 #endif
02674 
02675 
02676 
02677 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
02678 
02679 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
02680 
02681 
02682 
02683   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 
02684 
02685 
02686 /* -------- TYPES TABLE (BEGIN) -------- */
02687 
02688 #define SWIGTYPE_p_CORBA__Boolean swig_types[0]
02689 #define SWIGTYPE_p_CORBA__ORB_ptr swig_types[1]
02690 #define SWIGTYPE_p_Engines__Container_ptr swig_types[2]
02691 #define SWIGTYPE_p_Engines__DSC swig_types[3]
02692 #define SWIGTYPE_p_PortableServer__POA_ptr swig_types[4]
02693 #define SWIGTYPE_p_Ports__PortProperties_ptr swig_types[5]
02694 #define SWIGTYPE_p_Ports__Port_ptr swig_types[6]
02695 #define SWIGTYPE_p_PySupervCompo swig_types[7]
02696 #define SWIGTYPE_p_Superv_Component_i swig_types[8]
02697 #define SWIGTYPE_p_char swig_types[9]
02698 #define SWIGTYPE_p_double swig_types[10]
02699 #define SWIGTYPE_p_doubleArray swig_types[11]
02700 #define SWIGTYPE_p_float swig_types[12]
02701 #define SWIGTYPE_p_floatArray swig_types[13]
02702 #define SWIGTYPE_p_int swig_types[14]
02703 #define SWIGTYPE_p_intArray swig_types[15]
02704 #define SWIGTYPE_p_long swig_types[16]
02705 #define SWIGTYPE_p_longArray swig_types[17]
02706 #define SWIGTYPE_p_p_char swig_types[18]
02707 #define SWIGTYPE_p_provides_port swig_types[19]
02708 #define SWIGTYPE_p_stringArray swig_types[20]
02709 #define SWIGTYPE_p_uses_port swig_types[21]
02710 static swig_type_info *swig_types[23];
02711 static swig_module_info swig_module = {swig_types, 22, 0, 0, 0, 0};
02712 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
02713 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
02714 
02715 /* -------- TYPES TABLE (END) -------- */
02716 
02717 #if (PY_VERSION_HEX <= 0x02000000)
02718 # if !defined(SWIG_PYTHON_CLASSIC)
02719 #  error "This python version requires swig to be run with the '-classic' option"
02720 # endif
02721 #endif
02722 
02723 /*-----------------------------------------------
02724               @(target):= _calcium.so
02725   ------------------------------------------------*/
02726 #if PY_VERSION_HEX >= 0x03000000
02727 #  define SWIG_init    PyInit__calcium
02728 
02729 #else
02730 #  define SWIG_init    init_calcium
02731 
02732 #endif
02733 #define SWIG_name    "_calcium"
02734 
02735 #define SWIGVERSION 0x010340 
02736 #define SWIG_VERSION SWIGVERSION
02737 
02738 
02739 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
02740 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
02741 
02742 
02743 #include <stdexcept>
02744 
02745 
02746 namespace swig {
02747   class SwigPtr_PyObject {
02748   protected:
02749     PyObject *_obj;
02750 
02751   public:
02752     SwigPtr_PyObject() :_obj(0)
02753     {
02754     }
02755 
02756     SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
02757     {
02758       Py_XINCREF(_obj);      
02759     }
02760     
02761     SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
02762     {
02763       if (initial_ref) {
02764         Py_XINCREF(_obj);
02765       }
02766     }
02767     
02768     SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
02769     {
02770       Py_XINCREF(item._obj);
02771       Py_XDECREF(_obj);
02772       _obj = item._obj;
02773       return *this;      
02774     }
02775     
02776     ~SwigPtr_PyObject() 
02777     {
02778       Py_XDECREF(_obj);
02779     }
02780     
02781     operator PyObject *() const
02782     {
02783       return _obj;
02784     }
02785 
02786     PyObject *operator->() const
02787     {
02788       return _obj;
02789     }
02790   };
02791 }
02792 
02793 
02794 namespace swig {
02795   struct SwigVar_PyObject : SwigPtr_PyObject {
02796     SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
02797     
02798     SwigVar_PyObject & operator = (PyObject* obj)
02799     {
02800       Py_XDECREF(_obj);
02801       _obj = obj;
02802       return *this;      
02803     }
02804   };
02805 }
02806 
02807 
02808 //C++ Includes 
02809 #include <SALOMEconfig.h>
02810 #include <Calcium.hxx>
02811 #include <calcium.h>
02812 #include <Superv_Component_i.hxx>
02813 #include <Salome_file_i.hxx>
02814 #include <omniORB4/CORBA.h>
02815 
02816 //--- from omniORBpy.h (not present on Debian Sarge packages)
02817 
02818 struct omniORBpyAPI {
02819 
02820   PyObject* (*cxxObjRefToPyObjRef)(const CORBA::Object_ptr cxx_obj,
02821            CORBA::Boolean hold_lock);
02822   // Convert a C++ object reference to a Python object reference.
02823   // If <hold_lock> is true, caller holds the Python interpreter lock.
02824 
02825   CORBA::Object_ptr (*pyObjRefToCxxObjRef)(PyObject* py_obj,
02826              CORBA::Boolean hold_lock);
02827   // Convert a Python object reference to a C++ object reference.
02828   // Raises BAD_PARAM if the Python object is not an object reference.
02829   // If <hold_lock> is true, caller holds the Python interpreter lock.
02830 
02831   PyObject* (*handleCxxSystemException)(const CORBA::SystemException& ex);
02832   // Sets the Python exception state to reflect the given C++ system
02833   // exception. Always returns NULL. The caller must hold the Python
02834   // interpreter lock.
02835 };
02836 
02837   omniORBpyAPI* api;
02838   PyObject* dsc ;
02839 
02840 
02841 
02842 
02843 
02844 #ifdef WITH_NUMPY
02845 /* With Numpy */
02846 #ifdef HAVE_ISINF
02847 #undef HAVE_ISINF
02848 #endif
02849 #include <numpy/arrayobject.h>
02850 
02851 typedef PyArrayObject ArrayObject;
02852 
02853 /* Macros to extract array attributes.
02854  */
02855 #define is_array(a)            ((a) && PyArray_Check((PyArrayObject *)a))
02856 #define array_type(a)          (int)(PyArray_TYPE(a))
02857 #define array_dimensions(a)    (((PyArrayObject *)a)->nd)
02858 #define array_size(a,i)        (((PyArrayObject *)a)->dimensions[i])
02859 #define array_is_contiguous(a) (PyArray_ISCONTIGUOUS(a))
02860 
02861 const char* pytype_string(PyObject*);
02862 const char* typecode_string(int);
02863 int type_match(int, int);
02864 int require_size(PyArrayObject*, int*, int);
02865 int require_dimensions_n(PyArrayObject*, int*, int);
02866 int require_dimensions(PyArrayObject*, int);
02867 int require_contiguous(PyArrayObject*);
02868 PyArrayObject* make_contiguous(PyArrayObject*, int*, int, int);
02869 PyArrayObject* obj_to_array_no_conversion(PyObject*, int);
02870 PyArrayObject* obj_to_array_allow_conversion(PyObject*, int, int*);
02871 PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject*, int, int*);
02872 PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject*, int, int*);
02873 
02874 /* Given a PyObject, return a string describing its type.
02875  */
02876 const char* pytype_string(PyObject* py_obj) {
02877   if (py_obj == NULL          ) return "C NULL value";
02878   if (PyCallable_Check(py_obj)) return "callable"    ;
02879   if (PyString_Check(  py_obj)) return "string"      ;
02880   if (PyInt_Check(     py_obj)) return "int"         ;
02881   if (PyFloat_Check(   py_obj)) return "float"       ;
02882   if (PyDict_Check(    py_obj)) return "dict"        ;
02883   if (PyList_Check(    py_obj)) return "list"        ;
02884   if (PyTuple_Check(   py_obj)) return "tuple"       ;
02885   if (PyFile_Check(    py_obj)) return "file"        ;
02886   if (PyModule_Check(  py_obj)) return "module"      ;
02887   if (PyInstance_Check(py_obj)) return "instance"    ;
02888 
02889   return "unkown type";
02890 }
02891 
02892 /*
02893 For documentation only : numpy typecodes
02894 
02895 enum NPY_TYPECHAR { NPY_BOOLLTR = '?',
02896                         NPY_BYTELTR = 'b',
02897                         NPY_UBYTELTR = 'B',
02898                         NPY_SHORTLTR = 'h',
02899                         NPY_USHORTLTR = 'H',
02900                         NPY_INTLTR = 'i',
02901                         NPY_UINTLTR = 'I',
02902                         NPY_LONGLTR = 'l',
02903                         NPY_ULONGLTR = 'L',
02904                         NPY_LONGLONGLTR = 'q',
02905                         NPY_ULONGLONGLTR = 'Q',
02906                         NPY_FLOATLTR = 'f',
02907                         NPY_DOUBLELTR = 'd',
02908                         NPY_LONGDOUBLELTR = 'g',
02909                         NPY_CFLOATLTR = 'F',
02910                         NPY_CDOUBLELTR = 'D',
02911                         NPY_CLONGDOUBLELTR = 'G',
02912                         NPY_OBJECTLTR = 'O',
02913                         NPY_STRINGLTR = 'S',
02914                         NPY_STRINGLTR2 = 'a',
02915                         NPY_UNICODELTR = 'U',
02916                         NPY_VOIDLTR = 'V',
02917                         NPY_CHARLTR = 'c',
02918 
02919                         NPY_INTPLTR = 'p',
02920                         NPY_UINTPLTR = 'P',
02921 
02922                         NPY_GENBOOLLTR ='b',
02923                         NPY_SIGNEDLTR = 'i',
02924                         NPY_UNSIGNEDLTR = 'u',
02925                         NPY_FLOATINGLTR = 'f',
02926                         NPY_COMPLEXLTR = 'c'
02927 };
02928 */
02929 
02930 /* Given a Numeric typecode, return a string describing the type.
02931  */
02932 const char* typecode_string(int typecode) {
02933   const char* type_names[] = {"bool","byte","unsigned byte","short",
02934         "unsigned short","int","unsigned int","long","unsigned long",
02935         "longlong","unsigned longlong",
02936         "float","double","long double","complex float","complex double","complex long double",
02937         "object","string","unicode","void","ntypes","notype","char","unkown"};
02938   return type_names[typecode];
02939 }
02940 
02941 /* Make sure input has correct numeric type.  Allow character and byte
02942  * to match.  Also allow int and long to match.
02943  */
02944 int type_match(int actual_type, int desired_type) {
02945   return PyArray_EquivTypenums(actual_type, desired_type);
02946 }
02947 
02948 /* Given a PyObject pointer, cast it to a PyArrayObject pointer if
02949  * legal.  If not, set the python error string appropriately and
02950  * return NULL./
02951  */
02952 PyArrayObject* obj_to_array_no_conversion(PyObject* input, int typecode) {
02953   PyArrayObject* ary = NULL;
02954   if (is_array(input) && (typecode == PyArray_NOTYPE ||
02955         PyArray_EquivTypenums(array_type(input),
02956             typecode))) {
02957         ary = (PyArrayObject*) input;
02958     }
02959     else if is_array(input) {
02960       const char* desired_type = typecode_string(typecode);
02961       const char* actual_type = typecode_string(array_type(input));
02962       PyErr_Format(PyExc_TypeError,
02963        "Array of type '%s' required.  Array of type '%s' given",
02964        desired_type, actual_type);
02965       ary = NULL;
02966     }
02967     else {
02968       const char * desired_type = typecode_string(typecode);
02969       const char * actual_type = pytype_string(input);
02970       PyErr_Format(PyExc_TypeError,
02971        "Array of type '%s' required.  A %s was given",
02972        desired_type, actual_type);
02973       ary = NULL;
02974     }
02975   return ary;
02976 }
02977 
02978 /* Convert the given PyObject to a Numeric array with the given
02979  * typecode.  On Success, return a valid PyArrayObject* with the
02980  * correct type.  On failure, the python error string will be set and
02981  * the routine returns NULL.
02982  */
02983 PyArrayObject* obj_to_array_allow_conversion(PyObject* input, int typecode,
02984                                              int* is_new_object)
02985 {
02986   PyArrayObject* ary = NULL;
02987   PyObject* py_obj;
02988   if (is_array(input) && (typecode == PyArray_NOTYPE || type_match(array_type(input),typecode))) {
02989     ary = (PyArrayObject*) input;
02990     *is_new_object = 0;
02991   }
02992   else {
02993     py_obj = PyArray_FromObject(input, typecode, 0, 0);
02994     /* If NULL, PyArray_FromObject will have set python error value.*/
02995     ary = (PyArrayObject*) py_obj;
02996     *is_new_object = 1;
02997   }
02998   return ary;
02999 }
03000 
03001 /* Given a PyArrayObject, check to see if it is contiguous.  If so,
03002  * return the input pointer and flag it as not a new object.  If it is
03003  * not contiguous, create a new PyArrayObject using the original data,
03004  * flag it as a new object and return the pointer.
03005  */
03006 PyArrayObject* make_contiguous(PyArrayObject* ary, int* is_new_object,
03007                                int min_dims, int max_dims)
03008 {
03009   PyArrayObject* result;
03010   if (array_is_contiguous(ary)) {
03011     result = ary;
03012     *is_new_object = 0;
03013   }
03014   else {
03015     result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary,
03016                  array_type(ary),
03017                  min_dims,
03018                  max_dims);
03019     *is_new_object = 1;
03020   }
03021   return result;
03022 }
03023 
03024 /* Convert a given PyObject to a contiguous PyArrayObject of the
03025  * specified type.  If the input object is not a contiguous
03026  * PyArrayObject, a new one will be created and the new object flag
03027  * will be set.
03028  */
03029 PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input,
03030                                                         int typecode,
03031                                                         int* is_new_object) {
03032   int is_new1 = 0;
03033   int is_new2 = 0;
03034   PyArrayObject* ary2;
03035   PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode,
03036                   &is_new1);
03037   if (ary1) {
03038     ary2 = make_contiguous(ary1, &is_new2, 0, 0);
03039     if ( is_new1 && is_new2) {
03040       Py_DECREF(ary1);
03041     }
03042     ary1 = ary2;
03043   }
03044   *is_new_object = is_new1 || is_new2;
03045   return ary1;
03046 }
03047 
03048 /* Test whether a python object is contiguous.  If array is
03049  * contiguous, return 1.  Otherwise, set the python error string and
03050  * return 0.
03051  */
03052 int require_contiguous(PyArrayObject* ary) {
03053   int contiguous = 1;
03054   if (!array_is_contiguous(ary)) {
03055     PyErr_SetString(PyExc_TypeError, "Array must be contiguous.  A discontiguous array was given");
03056     contiguous = 0;
03057   }
03058   return contiguous;
03059 }
03060 
03061 /* Require the given PyArrayObject to have a specified number of
03062  * dimensions.  If the array has the specified number of dimensions,
03063  * return 1.  Otherwise, set the python error string and return 0.
03064  */
03065 int require_dimensions(PyArrayObject* ary, int exact_dimensions) {
03066   int success = 1;
03067   if (array_dimensions(ary) != exact_dimensions) {
03068     PyErr_Format(PyExc_TypeError,
03069      "Array must have %d dimensions.  Given array has %d dimensions",
03070      exact_dimensions, array_dimensions(ary));
03071     success = 0;
03072   }
03073   return success;
03074 }
03075 
03076 /* Require the given PyArrayObject to have one of a list of specified
03077  * number of dimensions.  If the array has one of the specified number
03078  * of dimensions, return 1.  Otherwise, set the python error string
03079  * and return 0.
03080  */
03081 int require_dimensions_n(PyArrayObject* ary, int* exact_dimensions, int n) {
03082   int success = 0;
03083   int i;
03084   char dims_str[255] = "";
03085   char s[255];
03086   for (i = 0; i < n && !success; i++) {
03087     if (array_dimensions(ary) == exact_dimensions[i]) {
03088       success = 1;
03089     }
03090   }
03091   if (!success) {
03092     for (i = 0; i < n-1; i++) {
03093       sprintf(s, "%d, ", exact_dimensions[i]);
03094       strcat(dims_str,s);
03095     }
03096     sprintf(s, " or %d", exact_dimensions[n-1]);
03097     strcat(dims_str,s);
03098     PyErr_Format(PyExc_TypeError,
03099      "Array must have %s dimensions.  Given array has %d dimensions",
03100      dims_str, array_dimensions(ary));
03101   }
03102   return success;
03103 }
03104 
03105 /* Require the given PyArrayObject to have a specified shape.  If the
03106  * array has the specified shape, return 1.  Otherwise, set the python
03107  * error string and return 0.
03108  */
03109 int require_size(PyArrayObject* ary, int* size, int n) {
03110   int i;
03111   int success = 1;
03112   int len;
03113   char desired_dims[255] = "[";
03114   char s[255];
03115   char actual_dims[255] = "[";
03116   for(i=0; i < n;i++) {
03117     if (size[i] != -1 &&  size[i] != array_size(ary,i)) {
03118       success = 0;
03119     }
03120   }
03121   if (!success) {
03122     for (i = 0; i < n; i++) {
03123       if (size[i] == -1) {
03124         sprintf(s, "*,");
03125       }
03126       else
03127       {
03128         sprintf(s, "%d,", size[i]);
03129       }
03130       strcat(desired_dims,s);
03131     }
03132     len = strlen(desired_dims);
03133     desired_dims[len-1] = ']';
03134     for (i = 0; i < n; i++) {
03135       sprintf(s, "%d,", array_size(ary,i));
03136       strcat(actual_dims,s);
03137     }
03138     len = strlen(actual_dims);
03139     actual_dims[len-1] = ']';
03140     PyErr_Format(PyExc_TypeError,
03141      "Array must have shape of %s.  Given array has shape of %s",
03142      desired_dims, actual_dims);
03143   }
03144   return success;
03145 }
03146 
03147 #else
03148 /* Without Numpy */
03149 typedef PyObject ArrayObject;
03150 
03151 #endif
03152 
03153 
03154 typedef int intArray;
03155 
03156 
03157 SWIGINTERN int
03158 SWIG_AsVal_double (PyObject *obj, double *val)
03159 {
03160   int res = SWIG_TypeError;
03161   if (PyFloat_Check(obj)) {
03162     if (val) *val = PyFloat_AsDouble(obj);
03163     return SWIG_OK;
03164   } else if (PyInt_Check(obj)) {
03165     if (val) *val = PyInt_AsLong(obj);
03166     return SWIG_OK;
03167   } else if (PyLong_Check(obj)) {
03168     double v = PyLong_AsDouble(obj);
03169     if (!PyErr_Occurred()) {
03170       if (val) *val = v;
03171       return SWIG_OK;
03172     } else {
03173       PyErr_Clear();
03174     }
03175   }
03176 #ifdef SWIG_PYTHON_CAST_MODE
03177   {
03178     int dispatch = 0;
03179     double d = PyFloat_AsDouble(obj);
03180     if (!PyErr_Occurred()) {
03181       if (val) *val = d;
03182       return SWIG_AddCast(SWIG_OK);
03183     } else {
03184       PyErr_Clear();
03185     }
03186     if (!dispatch) {
03187       long v = PyLong_AsLong(obj);
03188       if (!PyErr_Occurred()) {
03189        if (val) *val = v;
03190        return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
03191       } else {
03192        PyErr_Clear();
03193       }
03194     }
03195   }
03196 #endif
03197   return res;
03198 }
03199 
03200 
03201 #include <float.h>
03202 
03203 
03204 #include <math.h>
03205 
03206 
03207 SWIGINTERNINLINE int
03208 SWIG_CanCastAsInteger(double *d, double min, double max) {
03209   double x = *d;
03210   if ((min <= x && x <= max)) {
03211    double fx = floor(x);
03212    double cx = ceil(x);
03213    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
03214    if ((errno == EDOM) || (errno == ERANGE)) {
03215      errno = 0;
03216    } else {
03217      double summ, reps, diff;
03218      if (rd < x) {
03219        diff = x - rd;
03220      } else if (rd > x) {
03221        diff = rd - x;
03222      } else {
03223        return 1;
03224      }
03225      summ = rd + x;
03226      reps = diff/summ;
03227      if (reps < 8*DBL_EPSILON) {
03228        *d = rd;
03229        return 1;
03230      }
03231    }
03232   }
03233   return 0;
03234 }
03235 
03236 
03237 SWIGINTERN int
03238 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
03239 {
03240   if (PyInt_Check(obj)) {
03241     long v = PyInt_AsLong(obj);
03242     if (v >= 0) {
03243       if (val) *val = v;
03244       return SWIG_OK;
03245     } else {
03246       return SWIG_OverflowError;
03247     }
03248   } else if (PyLong_Check(obj)) {
03249     unsigned long v = PyLong_AsUnsignedLong(obj);
03250     if (!PyErr_Occurred()) {
03251       if (val) *val = v;
03252       return SWIG_OK;
03253     } else {
03254       PyErr_Clear();
03255     }
03256   }
03257 #ifdef SWIG_PYTHON_CAST_MODE
03258   {
03259     int dispatch = 0;
03260     unsigned long v = PyLong_AsUnsignedLong(obj);
03261     if (!PyErr_Occurred()) {
03262       if (val) *val = v;
03263       return SWIG_AddCast(SWIG_OK);
03264     } else {
03265       PyErr_Clear();
03266     }
03267     if (!dispatch) {
03268       double d;
03269       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
03270       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
03271        if (val) *val = (unsigned long)(d);
03272        return res;
03273       }
03274     }
03275   }
03276 #endif
03277   return SWIG_TypeError;
03278 }
03279 
03280 
03281 SWIGINTERNINLINE int
03282 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
03283 {
03284   unsigned long v;
03285   int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
03286   if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
03287   return res;
03288 }
03289 
03290 SWIGINTERN intArray *new_intArray(size_t nelements){
03291     return (new int[nelements]);
03292   }
03293 SWIGINTERN void delete_intArray(intArray *self){
03294     delete[] self;
03295   }
03296 SWIGINTERN int intArray___getitem__(intArray *self,size_t index){
03297     return self[index];
03298   }
03299 
03300   #define SWIG_From_long   PyInt_FromLong 
03301 
03302 
03303 SWIGINTERNINLINE PyObject *
03304 SWIG_From_int  (int value)
03305 {    
03306   return SWIG_From_long  (value);
03307 }
03308 
03309 
03310 #include <limits.h>
03311 #if !defined(SWIG_NO_LLONG_MAX)
03312 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
03313 #   define LLONG_MAX __LONG_LONG_MAX__
03314 #   define LLONG_MIN (-LLONG_MAX - 1LL)
03315 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
03316 # endif
03317 #endif
03318 
03319 
03320 SWIGINTERN int
03321 SWIG_AsVal_long (PyObject *obj, long* val)
03322 {
03323   if (PyInt_Check(obj)) {
03324     if (val) *val = PyInt_AsLong(obj);
03325     return SWIG_OK;
03326   } else if (PyLong_Check(obj)) {
03327     long v = PyLong_AsLong(obj);
03328     if (!PyErr_Occurred()) {
03329       if (val) *val = v;
03330       return SWIG_OK;
03331     } else {
03332       PyErr_Clear();
03333     }
03334   }
03335 #ifdef SWIG_PYTHON_CAST_MODE
03336   {
03337     int dispatch = 0;
03338     long v = PyInt_AsLong(obj);
03339     if (!PyErr_Occurred()) {
03340       if (val) *val = v;
03341       return SWIG_AddCast(SWIG_OK);
03342     } else {
03343       PyErr_Clear();
03344     }
03345     if (!dispatch) {
03346       double d;
03347       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
03348       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
03349        if (val) *val = (long)(d);
03350        return res;
03351       }
03352     }
03353   }
03354 #endif
03355   return SWIG_TypeError;
03356 }
03357 
03358 
03359 SWIGINTERN int
03360 SWIG_AsVal_int (PyObject * obj, int *val)
03361 {
03362   long v;
03363   int res = SWIG_AsVal_long (obj, &v);
03364   if (SWIG_IsOK(res)) {
03365     if ((v < INT_MIN || v > INT_MAX)) {
03366       return SWIG_OverflowError;
03367     } else {
03368       if (val) *val = static_cast< int >(v);
03369     }
03370   }  
03371   return res;
03372 }
03373 
03374 SWIGINTERN void intArray___setitem__(intArray *self,size_t index,int value){
03375     self[index] = value;
03376   }
03377 SWIGINTERN int *intArray_cast(intArray *self){
03378     return self;
03379   }
03380 SWIGINTERN intArray *intArray_frompointer(int *t){
03381     return static_cast< intArray * >(t);
03382   }
03383 
03384 typedef long longArray;
03385 
03386 SWIGINTERN longArray *new_longArray(size_t nelements){
03387     return (new long[nelements]);
03388   }
03389 SWIGINTERN void delete_longArray(longArray *self){
03390     delete[] self;
03391   }
03392 SWIGINTERN long longArray___getitem__(longArray *self,size_t index){
03393     return self[index];
03394   }
03395 SWIGINTERN void longArray___setitem__(longArray *self,size_t index,long value){
03396     self[index] = value;
03397   }
03398 SWIGINTERN long *longArray_cast(longArray *self){
03399     return self;
03400   }
03401 SWIGINTERN longArray *longArray_frompointer(long *t){
03402     return static_cast< longArray * >(t);
03403   }
03404 
03405 typedef float floatArray;
03406 
03407 SWIGINTERN floatArray *new_floatArray(size_t nelements){
03408     return (new float[nelements]);
03409   }
03410 SWIGINTERN void delete_floatArray(floatArray *self){
03411     delete[] self;
03412   }
03413 SWIGINTERN float floatArray___getitem__(floatArray *self,size_t index){
03414     return self[index];
03415   }
03416 
03417   #define SWIG_From_double   PyFloat_FromDouble 
03418 
03419 
03420 SWIGINTERNINLINE PyObject *
03421 SWIG_From_float  (float value)
03422 {    
03423   return SWIG_From_double  (value);
03424 }
03425 
03426 
03427 SWIGINTERN int
03428 SWIG_AsVal_float (PyObject * obj, float *val)
03429 {
03430   double v;
03431   int res = SWIG_AsVal_double (obj, &v);
03432   if (SWIG_IsOK(res)) {
03433     if ((v < -FLT_MAX || v > FLT_MAX)) {
03434       return SWIG_OverflowError;
03435     } else {
03436       if (val) *val = static_cast< float >(v);
03437     }
03438   }  
03439   return res;
03440 }
03441 
03442 SWIGINTERN void floatArray___setitem__(floatArray *self,size_t index,float value){
03443     self[index] = value;
03444   }
03445 SWIGINTERN float *floatArray_cast(floatArray *self){
03446     return self;
03447   }
03448 SWIGINTERN floatArray *floatArray_frompointer(float *t){
03449     return static_cast< floatArray * >(t);
03450   }
03451 
03452 typedef double doubleArray;
03453 
03454 SWIGINTERN doubleArray *new_doubleArray(size_t nelements){
03455     return (new double[nelements]);
03456   }
03457 SWIGINTERN void delete_doubleArray(doubleArray *self){
03458     delete[] self;
03459   }
03460 SWIGINTERN double doubleArray___getitem__(doubleArray *self,size_t index){
03461     return self[index];
03462   }
03463 SWIGINTERN void doubleArray___setitem__(doubleArray *self,size_t index,double value){
03464     self[index] = value;
03465   }
03466 SWIGINTERN double *doubleArray_cast(doubleArray *self){
03467     return self;
03468   }
03469 SWIGINTERN doubleArray *doubleArray_frompointer(double *t){
03470     return static_cast< doubleArray * >(t);
03471   }
03472 
03473 struct stringArray
03474 {
03475   stringArray(int nelements,int size=0) {
03476     nelem=nelements;
03477     size=size;
03478     data= new char*[nelements];
03479     for(int i=0;i<nelements;i++)
03480     {
03481       data[i]=(char *)malloc((size+1)*sizeof(char));
03482       data[i][size+1]='\0';
03483     }
03484   }
03485   ~stringArray() 
03486   {
03487     for(int i=0;i<nelem;i++)
03488       free(data[i]);
03489     delete [] data;
03490   }
03491   char* __getitem__(int index) {
03492     return data[index];
03493   }
03494   void __setitem__(int index, char* value) {
03495     free(data[index]);
03496     data[index] = strdup(value);
03497   }
03498   char** data;
03499   int nelem;
03500   int size;
03501 };
03502 
03503 
03504 SWIGINTERN swig_type_info*
03505 SWIG_pchar_descriptor(void)
03506 {
03507   static int init = 0;
03508   static swig_type_info* info = 0;
03509   if (!init) {
03510     info = SWIG_TypeQuery("_p_char");
03511     init = 1;
03512   }
03513   return info;
03514 }
03515 
03516 
03517 SWIGINTERNINLINE PyObject *
03518 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
03519 {
03520   if (carray) {
03521     if (size > INT_MAX) {
03522       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
03523       return pchar_descriptor ? 
03524        SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
03525     } else {
03526 #if PY_VERSION_HEX >= 0x03000000
03527       return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
03528 #else
03529       return PyString_FromStringAndSize(carray, static_cast< int >(size));
03530 #endif
03531     }
03532   } else {
03533     return SWIG_Py_Void();
03534   }
03535 }
03536 
03537 
03538 SWIGINTERNINLINE PyObject * 
03539 SWIG_FromCharPtr(const char *cptr)
03540 { 
03541   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
03542 }
03543 
03544 
03545 SWIGINTERN int
03546 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
03547 {
03548 #if PY_VERSION_HEX>=0x03000000
03549   if (PyUnicode_Check(obj))
03550 #else  
03551   if (PyString_Check(obj))
03552 #endif
03553   {
03554     char *cstr; Py_ssize_t len;
03555 #if PY_VERSION_HEX>=0x03000000
03556     if (!alloc && cptr) {
03557         /* We can't allow converting without allocation, since the internal
03558            representation of string in Python 3 is UCS-2/UCS-4 but we require
03559            a UTF-8 representation.
03560            TODO(bhy) More detailed explanation */
03561         return SWIG_RuntimeError;
03562     }
03563     obj = PyUnicode_AsUTF8String(obj);
03564     PyBytes_AsStringAndSize(obj, &cstr, &len);
03565     if(alloc) *alloc = SWIG_NEWOBJ;
03566 #else
03567     PyString_AsStringAndSize(obj, &cstr, &len);
03568 #endif
03569     if (cptr) {
03570       if (alloc) {
03571        /* 
03572           In python the user should not be able to modify the inner
03573           string representation. To warranty that, if you define
03574           SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
03575           buffer is always returned.
03576 
03577           The default behavior is just to return the pointer value,
03578           so, be careful.
03579        */ 
03580 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
03581        if (*alloc != SWIG_OLDOBJ) 
03582 #else
03583        if (*alloc == SWIG_NEWOBJ) 
03584 #endif
03585          {
03586            *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
03587            *alloc = SWIG_NEWOBJ;
03588          }
03589        else {
03590          *cptr = cstr;
03591          *alloc = SWIG_OLDOBJ;
03592        }
03593       } else {
03594         #if PY_VERSION_HEX>=0x03000000
03595         assert(0); /* Should never reach here in Python 3 */
03596         #endif
03597        *cptr = SWIG_Python_str_AsChar(obj);
03598       }
03599     }
03600     if (psize) *psize = len + 1;
03601 #if PY_VERSION_HEX>=0x03000000
03602     Py_XDECREF(obj);
03603 #endif
03604     return SWIG_OK;
03605   } else {
03606     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
03607     if (pchar_descriptor) {
03608       void* vptr = 0;
03609       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
03610        if (cptr) *cptr = (char *) vptr;
03611        if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
03612        if (alloc) *alloc = SWIG_OLDOBJ;
03613        return SWIG_OK;
03614       }
03615     }
03616   }
03617   return SWIG_TypeError;
03618 }
03619 
03620 
03621 
03622 
03623 SWIGINTERN long PySupervCompo_ptr(PySupervCompo *self){
03624           return (long)self;
03625         }
03626 #ifdef __cplusplus
03627 extern "C" {
03628 #endif
03629 SWIGINTERN PyObject *_wrap_new_intArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03630   PyObject *resultobj = 0;
03631   size_t arg1 ;
03632   size_t val1 ;
03633   int ecode1 = 0 ;
03634   PyObject * obj0 = 0 ;
03635   intArray *result = 0 ;
03636   
03637   if (!PyArg_ParseTuple(args,(char *)"O:new_intArray",&obj0)) SWIG_fail;
03638   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
03639   if (!SWIG_IsOK(ecode1)) {
03640     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intArray" "', argument " "1"" of type '" "size_t""'");
03641   } 
03642   arg1 = static_cast< size_t >(val1);
03643   result = (intArray *)new_intArray(arg1);
03644   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intArray, SWIG_POINTER_NEW |  0 );
03645   return resultobj;
03646 fail:
03647   return NULL;
03648 }
03649 
03650 
03651 SWIGINTERN PyObject *_wrap_delete_intArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03652   PyObject *resultobj = 0;
03653   intArray *arg1 = (intArray *) 0 ;
03654   void *argp1 = 0 ;
03655   int res1 = 0 ;
03656   PyObject * obj0 = 0 ;
03657   
03658   if (!PyArg_ParseTuple(args,(char *)"O:delete_intArray",&obj0)) SWIG_fail;
03659   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intArray, SWIG_POINTER_DISOWN |  0 );
03660   if (!SWIG_IsOK(res1)) {
03661     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_intArray" "', argument " "1"" of type '" "intArray *""'"); 
03662   }
03663   arg1 = reinterpret_cast< intArray * >(argp1);
03664   delete_intArray(arg1);
03665   resultobj = SWIG_Py_Void();
03666   return resultobj;
03667 fail:
03668   return NULL;
03669 }
03670 
03671 
03672 SWIGINTERN PyObject *_wrap_intArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03673   PyObject *resultobj = 0;
03674   intArray *arg1 = (intArray *) 0 ;
03675   size_t arg2 ;
03676   void *argp1 = 0 ;
03677   int res1 = 0 ;
03678   size_t val2 ;
03679   int ecode2 = 0 ;
03680   PyObject * obj0 = 0 ;
03681   PyObject * obj1 = 0 ;
03682   int result;
03683   
03684   if (!PyArg_ParseTuple(args,(char *)"OO:intArray___getitem__",&obj0,&obj1)) SWIG_fail;
03685   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intArray, 0 |  0 );
03686   if (!SWIG_IsOK(res1)) {
03687     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray___getitem__" "', argument " "1"" of type '" "intArray *""'"); 
03688   }
03689   arg1 = reinterpret_cast< intArray * >(argp1);
03690   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
03691   if (!SWIG_IsOK(ecode2)) {
03692     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray___getitem__" "', argument " "2"" of type '" "size_t""'");
03693   } 
03694   arg2 = static_cast< size_t >(val2);
03695   result = (int)intArray___getitem__(arg1,arg2);
03696   resultobj = SWIG_From_int(static_cast< int >(result));
03697   return resultobj;
03698 fail:
03699   return NULL;
03700 }
03701 
03702 
03703 SWIGINTERN PyObject *_wrap_intArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03704   PyObject *resultobj = 0;
03705   intArray *arg1 = (intArray *) 0 ;
03706   size_t arg2 ;
03707   int arg3 ;
03708   void *argp1 = 0 ;
03709   int res1 = 0 ;
03710   size_t val2 ;
03711   int ecode2 = 0 ;
03712   int val3 ;
03713   int ecode3 = 0 ;
03714   PyObject * obj0 = 0 ;
03715   PyObject * obj1 = 0 ;
03716   PyObject * obj2 = 0 ;
03717   
03718   if (!PyArg_ParseTuple(args,(char *)"OOO:intArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
03719   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intArray, 0 |  0 );
03720   if (!SWIG_IsOK(res1)) {
03721     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray___setitem__" "', argument " "1"" of type '" "intArray *""'"); 
03722   }
03723   arg1 = reinterpret_cast< intArray * >(argp1);
03724   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
03725   if (!SWIG_IsOK(ecode2)) {
03726     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray___setitem__" "', argument " "2"" of type '" "size_t""'");
03727   } 
03728   arg2 = static_cast< size_t >(val2);
03729   ecode3 = SWIG_AsVal_int(obj2, &val3);
03730   if (!SWIG_IsOK(ecode3)) {
03731     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray___setitem__" "', argument " "3"" of type '" "int""'");
03732   } 
03733   arg3 = static_cast< int >(val3);
03734   intArray___setitem__(arg1,arg2,arg3);
03735   resultobj = SWIG_Py_Void();
03736   return resultobj;
03737 fail:
03738   return NULL;
03739 }
03740 
03741 
03742 SWIGINTERN PyObject *_wrap_intArray_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03743   PyObject *resultobj = 0;
03744   intArray *arg1 = (intArray *) 0 ;
03745   void *argp1 = 0 ;
03746   int res1 = 0 ;
03747   PyObject * obj0 = 0 ;
03748   int *result = 0 ;
03749   
03750   if (!PyArg_ParseTuple(args,(char *)"O:intArray_cast",&obj0)) SWIG_fail;
03751   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intArray, 0 |  0 );
03752   if (!SWIG_IsOK(res1)) {
03753     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_cast" "', argument " "1"" of type '" "intArray *""'"); 
03754   }
03755   arg1 = reinterpret_cast< intArray * >(argp1);
03756   result = (int *)intArray_cast(arg1);
03757   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
03758   return resultobj;
03759 fail:
03760   return NULL;
03761 }
03762 
03763 
03764 SWIGINTERN PyObject *_wrap_intArray_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03765   PyObject *resultobj = 0;
03766   int *arg1 = (int *) 0 ;
03767   void *argp1 = 0 ;
03768   int res1 = 0 ;
03769   PyObject * obj0 = 0 ;
03770   intArray *result = 0 ;
03771   
03772   if (!PyArg_ParseTuple(args,(char *)"O:intArray_frompointer",&obj0)) SWIG_fail;
03773   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
03774   if (!SWIG_IsOK(res1)) {
03775     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_frompointer" "', argument " "1"" of type '" "int *""'"); 
03776   }
03777   arg1 = reinterpret_cast< int * >(argp1);
03778   result = (intArray *)intArray_frompointer(arg1);
03779   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intArray, 0 |  0 );
03780   return resultobj;
03781 fail:
03782   return NULL;
03783 }
03784 
03785 
03786 SWIGINTERN PyObject *intArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03787   PyObject *obj;
03788   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
03789   SWIG_TypeNewClientData(SWIGTYPE_p_intArray, SWIG_NewClientData(obj));
03790   return SWIG_Py_Void();
03791 }
03792 
03793 SWIGINTERN PyObject *_wrap_new_longArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03794   PyObject *resultobj = 0;
03795   size_t arg1 ;
03796   size_t val1 ;
03797   int ecode1 = 0 ;
03798   PyObject * obj0 = 0 ;
03799   longArray *result = 0 ;
03800   
03801   if (!PyArg_ParseTuple(args,(char *)"O:new_longArray",&obj0)) SWIG_fail;
03802   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
03803   if (!SWIG_IsOK(ecode1)) {
03804     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_longArray" "', argument " "1"" of type '" "size_t""'");
03805   } 
03806   arg1 = static_cast< size_t >(val1);
03807   result = (longArray *)new_longArray(arg1);
03808   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_longArray, SWIG_POINTER_NEW |  0 );
03809   return resultobj;
03810 fail:
03811   return NULL;
03812 }
03813 
03814 
03815 SWIGINTERN PyObject *_wrap_delete_longArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03816   PyObject *resultobj = 0;
03817   longArray *arg1 = (longArray *) 0 ;
03818   void *argp1 = 0 ;
03819   int res1 = 0 ;
03820   PyObject * obj0 = 0 ;
03821   
03822   if (!PyArg_ParseTuple(args,(char *)"O:delete_longArray",&obj0)) SWIG_fail;
03823   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_longArray, SWIG_POINTER_DISOWN |  0 );
03824   if (!SWIG_IsOK(res1)) {
03825     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_longArray" "', argument " "1"" of type '" "longArray *""'"); 
03826   }
03827   arg1 = reinterpret_cast< longArray * >(argp1);
03828   delete_longArray(arg1);
03829   resultobj = SWIG_Py_Void();
03830   return resultobj;
03831 fail:
03832   return NULL;
03833 }
03834 
03835 
03836 SWIGINTERN PyObject *_wrap_longArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03837   PyObject *resultobj = 0;
03838   longArray *arg1 = (longArray *) 0 ;
03839   size_t arg2 ;
03840   void *argp1 = 0 ;
03841   int res1 = 0 ;
03842   size_t val2 ;
03843   int ecode2 = 0 ;
03844   PyObject * obj0 = 0 ;
03845   PyObject * obj1 = 0 ;
03846   long result;
03847   
03848   if (!PyArg_ParseTuple(args,(char *)"OO:longArray___getitem__",&obj0,&obj1)) SWIG_fail;
03849   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_longArray, 0 |  0 );
03850   if (!SWIG_IsOK(res1)) {
03851     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "longArray___getitem__" "', argument " "1"" of type '" "longArray *""'"); 
03852   }
03853   arg1 = reinterpret_cast< longArray * >(argp1);
03854   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
03855   if (!SWIG_IsOK(ecode2)) {
03856     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "longArray___getitem__" "', argument " "2"" of type '" "size_t""'");
03857   } 
03858   arg2 = static_cast< size_t >(val2);
03859   result = (long)longArray___getitem__(arg1,arg2);
03860   resultobj = SWIG_From_long(static_cast< long >(result));
03861   return resultobj;
03862 fail:
03863   return NULL;
03864 }
03865 
03866 
03867 SWIGINTERN PyObject *_wrap_longArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03868   PyObject *resultobj = 0;
03869   longArray *arg1 = (longArray *) 0 ;
03870   size_t arg2 ;
03871   long arg3 ;
03872   void *argp1 = 0 ;
03873   int res1 = 0 ;
03874   size_t val2 ;
03875   int ecode2 = 0 ;
03876   long val3 ;
03877   int ecode3 = 0 ;
03878   PyObject * obj0 = 0 ;
03879   PyObject * obj1 = 0 ;
03880   PyObject * obj2 = 0 ;
03881   
03882   if (!PyArg_ParseTuple(args,(char *)"OOO:longArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
03883   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_longArray, 0 |  0 );
03884   if (!SWIG_IsOK(res1)) {
03885     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "longArray___setitem__" "', argument " "1"" of type '" "longArray *""'"); 
03886   }
03887   arg1 = reinterpret_cast< longArray * >(argp1);
03888   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
03889   if (!SWIG_IsOK(ecode2)) {
03890     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "longArray___setitem__" "', argument " "2"" of type '" "size_t""'");
03891   } 
03892   arg2 = static_cast< size_t >(val2);
03893   ecode3 = SWIG_AsVal_long(obj2, &val3);
03894   if (!SWIG_IsOK(ecode3)) {
03895     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "longArray___setitem__" "', argument " "3"" of type '" "long""'");
03896   } 
03897   arg3 = static_cast< long >(val3);
03898   longArray___setitem__(arg1,arg2,arg3);
03899   resultobj = SWIG_Py_Void();
03900   return resultobj;
03901 fail:
03902   return NULL;
03903 }
03904 
03905 
03906 SWIGINTERN PyObject *_wrap_longArray_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03907   PyObject *resultobj = 0;
03908   longArray *arg1 = (longArray *) 0 ;
03909   void *argp1 = 0 ;
03910   int res1 = 0 ;
03911   PyObject * obj0 = 0 ;
03912   long *result = 0 ;
03913   
03914   if (!PyArg_ParseTuple(args,(char *)"O:longArray_cast",&obj0)) SWIG_fail;
03915   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_longArray, 0 |  0 );
03916   if (!SWIG_IsOK(res1)) {
03917     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "longArray_cast" "', argument " "1"" of type '" "longArray *""'"); 
03918   }
03919   arg1 = reinterpret_cast< longArray * >(argp1);
03920   result = (long *)longArray_cast(arg1);
03921   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_long, 0 |  0 );
03922   return resultobj;
03923 fail:
03924   return NULL;
03925 }
03926 
03927 
03928 SWIGINTERN PyObject *_wrap_longArray_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03929   PyObject *resultobj = 0;
03930   long *arg1 = (long *) 0 ;
03931   void *argp1 = 0 ;
03932   int res1 = 0 ;
03933   PyObject * obj0 = 0 ;
03934   longArray *result = 0 ;
03935   
03936   if (!PyArg_ParseTuple(args,(char *)"O:longArray_frompointer",&obj0)) SWIG_fail;
03937   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_long, 0 |  0 );
03938   if (!SWIG_IsOK(res1)) {
03939     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "longArray_frompointer" "', argument " "1"" of type '" "long *""'"); 
03940   }
03941   arg1 = reinterpret_cast< long * >(argp1);
03942   result = (longArray *)longArray_frompointer(arg1);
03943   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_longArray, 0 |  0 );
03944   return resultobj;
03945 fail:
03946   return NULL;
03947 }
03948 
03949 
03950 SWIGINTERN PyObject *longArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03951   PyObject *obj;
03952   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
03953   SWIG_TypeNewClientData(SWIGTYPE_p_longArray, SWIG_NewClientData(obj));
03954   return SWIG_Py_Void();
03955 }
03956 
03957 SWIGINTERN PyObject *_wrap_new_floatArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03958   PyObject *resultobj = 0;
03959   size_t arg1 ;
03960   size_t val1 ;
03961   int ecode1 = 0 ;
03962   PyObject * obj0 = 0 ;
03963   floatArray *result = 0 ;
03964   
03965   if (!PyArg_ParseTuple(args,(char *)"O:new_floatArray",&obj0)) SWIG_fail;
03966   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
03967   if (!SWIG_IsOK(ecode1)) {
03968     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_floatArray" "', argument " "1"" of type '" "size_t""'");
03969   } 
03970   arg1 = static_cast< size_t >(val1);
03971   result = (floatArray *)new_floatArray(arg1);
03972   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_floatArray, SWIG_POINTER_NEW |  0 );
03973   return resultobj;
03974 fail:
03975   return NULL;
03976 }
03977 
03978 
03979 SWIGINTERN PyObject *_wrap_delete_floatArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03980   PyObject *resultobj = 0;
03981   floatArray *arg1 = (floatArray *) 0 ;
03982   void *argp1 = 0 ;
03983   int res1 = 0 ;
03984   PyObject * obj0 = 0 ;
03985   
03986   if (!PyArg_ParseTuple(args,(char *)"O:delete_floatArray",&obj0)) SWIG_fail;
03987   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_floatArray, SWIG_POINTER_DISOWN |  0 );
03988   if (!SWIG_IsOK(res1)) {
03989     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_floatArray" "', argument " "1"" of type '" "floatArray *""'"); 
03990   }
03991   arg1 = reinterpret_cast< floatArray * >(argp1);
03992   delete_floatArray(arg1);
03993   resultobj = SWIG_Py_Void();
03994   return resultobj;
03995 fail:
03996   return NULL;
03997 }
03998 
03999 
04000 SWIGINTERN PyObject *_wrap_floatArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04001   PyObject *resultobj = 0;
04002   floatArray *arg1 = (floatArray *) 0 ;
04003   size_t arg2 ;
04004   void *argp1 = 0 ;
04005   int res1 = 0 ;
04006   size_t val2 ;
04007   int ecode2 = 0 ;
04008   PyObject * obj0 = 0 ;
04009   PyObject * obj1 = 0 ;
04010   float result;
04011   
04012   if (!PyArg_ParseTuple(args,(char *)"OO:floatArray___getitem__",&obj0,&obj1)) SWIG_fail;
04013   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_floatArray, 0 |  0 );
04014   if (!SWIG_IsOK(res1)) {
04015     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray___getitem__" "', argument " "1"" of type '" "floatArray *""'"); 
04016   }
04017   arg1 = reinterpret_cast< floatArray * >(argp1);
04018   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
04019   if (!SWIG_IsOK(ecode2)) {
04020     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatArray___getitem__" "', argument " "2"" of type '" "size_t""'");
04021   } 
04022   arg2 = static_cast< size_t >(val2);
04023   result = (float)floatArray___getitem__(arg1,arg2);
04024   resultobj = SWIG_From_float(static_cast< float >(result));
04025   return resultobj;
04026 fail:
04027   return NULL;
04028 }
04029 
04030 
04031 SWIGINTERN PyObject *_wrap_floatArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04032   PyObject *resultobj = 0;
04033   floatArray *arg1 = (floatArray *) 0 ;
04034   size_t arg2 ;
04035   float arg3 ;
04036   void *argp1 = 0 ;
04037   int res1 = 0 ;
04038   size_t val2 ;
04039   int ecode2 = 0 ;
04040   float val3 ;
04041   int ecode3 = 0 ;
04042   PyObject * obj0 = 0 ;
04043   PyObject * obj1 = 0 ;
04044   PyObject * obj2 = 0 ;
04045   
04046   if (!PyArg_ParseTuple(args,(char *)"OOO:floatArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
04047   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_floatArray, 0 |  0 );
04048   if (!SWIG_IsOK(res1)) {
04049     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray___setitem__" "', argument " "1"" of type '" "floatArray *""'"); 
04050   }
04051   arg1 = reinterpret_cast< floatArray * >(argp1);
04052   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
04053   if (!SWIG_IsOK(ecode2)) {
04054     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatArray___setitem__" "', argument " "2"" of type '" "size_t""'");
04055   } 
04056   arg2 = static_cast< size_t >(val2);
04057   ecode3 = SWIG_AsVal_float(obj2, &val3);
04058   if (!SWIG_IsOK(ecode3)) {
04059     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatArray___setitem__" "', argument " "3"" of type '" "float""'");
04060   } 
04061   arg3 = static_cast< float >(val3);
04062   floatArray___setitem__(arg1,arg2,arg3);
04063   resultobj = SWIG_Py_Void();
04064   return resultobj;
04065 fail:
04066   return NULL;
04067 }
04068 
04069 
04070 SWIGINTERN PyObject *_wrap_floatArray_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04071   PyObject *resultobj = 0;
04072   floatArray *arg1 = (floatArray *) 0 ;
04073   void *argp1 = 0 ;
04074   int res1 = 0 ;
04075   PyObject * obj0 = 0 ;
04076   float *result = 0 ;
04077   
04078   if (!PyArg_ParseTuple(args,(char *)"O:floatArray_cast",&obj0)) SWIG_fail;
04079   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_floatArray, 0 |  0 );
04080   if (!SWIG_IsOK(res1)) {
04081     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray_cast" "', argument " "1"" of type '" "floatArray *""'"); 
04082   }
04083   arg1 = reinterpret_cast< floatArray * >(argp1);
04084   result = (float *)floatArray_cast(arg1);
04085   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
04086   return resultobj;
04087 fail:
04088   return NULL;
04089 }
04090 
04091 
04092 SWIGINTERN PyObject *_wrap_floatArray_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04093   PyObject *resultobj = 0;
04094   float *arg1 = (float *) 0 ;
04095   void *argp1 = 0 ;
04096   int res1 = 0 ;
04097   PyObject * obj0 = 0 ;
04098   floatArray *result = 0 ;
04099   
04100   if (!PyArg_ParseTuple(args,(char *)"O:floatArray_frompointer",&obj0)) SWIG_fail;
04101   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 |  0 );
04102   if (!SWIG_IsOK(res1)) {
04103     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray_frompointer" "', argument " "1"" of type '" "float *""'"); 
04104   }
04105   arg1 = reinterpret_cast< float * >(argp1);
04106   result = (floatArray *)floatArray_frompointer(arg1);
04107   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_floatArray, 0 |  0 );
04108   return resultobj;
04109 fail:
04110   return NULL;
04111 }
04112 
04113 
04114 SWIGINTERN PyObject *floatArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04115   PyObject *obj;
04116   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
04117   SWIG_TypeNewClientData(SWIGTYPE_p_floatArray, SWIG_NewClientData(obj));
04118   return SWIG_Py_Void();
04119 }
04120 
04121 SWIGINTERN PyObject *_wrap_new_doubleArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04122   PyObject *resultobj = 0;
04123   size_t arg1 ;
04124   size_t val1 ;
04125   int ecode1 = 0 ;
04126   PyObject * obj0 = 0 ;
04127   doubleArray *result = 0 ;
04128   
04129   if (!PyArg_ParseTuple(args,(char *)"O:new_doubleArray",&obj0)) SWIG_fail;
04130   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
04131   if (!SWIG_IsOK(ecode1)) {
04132     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleArray" "', argument " "1"" of type '" "size_t""'");
04133   } 
04134   arg1 = static_cast< size_t >(val1);
04135   result = (doubleArray *)new_doubleArray(arg1);
04136   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_doubleArray, SWIG_POINTER_NEW |  0 );
04137   return resultobj;
04138 fail:
04139   return NULL;
04140 }
04141 
04142 
04143 SWIGINTERN PyObject *_wrap_delete_doubleArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04144   PyObject *resultobj = 0;
04145   doubleArray *arg1 = (doubleArray *) 0 ;
04146   void *argp1 = 0 ;
04147   int res1 = 0 ;
04148   PyObject * obj0 = 0 ;
04149   
04150   if (!PyArg_ParseTuple(args,(char *)"O:delete_doubleArray",&obj0)) SWIG_fail;
04151   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doubleArray, SWIG_POINTER_DISOWN |  0 );
04152   if (!SWIG_IsOK(res1)) {
04153     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_doubleArray" "', argument " "1"" of type '" "doubleArray *""'"); 
04154   }
04155   arg1 = reinterpret_cast< doubleArray * >(argp1);
04156   delete_doubleArray(arg1);
04157   resultobj = SWIG_Py_Void();
04158   return resultobj;
04159 fail:
04160   return NULL;
04161 }
04162 
04163 
04164 SWIGINTERN PyObject *_wrap_doubleArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04165   PyObject *resultobj = 0;
04166   doubleArray *arg1 = (doubleArray *) 0 ;
04167   size_t arg2 ;
04168   void *argp1 = 0 ;
04169   int res1 = 0 ;
04170   size_t val2 ;
04171   int ecode2 = 0 ;
04172   PyObject * obj0 = 0 ;
04173   PyObject * obj1 = 0 ;
04174   double result;
04175   
04176   if (!PyArg_ParseTuple(args,(char *)"OO:doubleArray___getitem__",&obj0,&obj1)) SWIG_fail;
04177   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doubleArray, 0 |  0 );
04178   if (!SWIG_IsOK(res1)) {
04179     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray___getitem__" "', argument " "1"" of type '" "doubleArray *""'"); 
04180   }
04181   arg1 = reinterpret_cast< doubleArray * >(argp1);
04182   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
04183   if (!SWIG_IsOK(ecode2)) {
04184     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray___getitem__" "', argument " "2"" of type '" "size_t""'");
04185   } 
04186   arg2 = static_cast< size_t >(val2);
04187   result = (double)doubleArray___getitem__(arg1,arg2);
04188   resultobj = SWIG_From_double(static_cast< double >(result));
04189   return resultobj;
04190 fail:
04191   return NULL;
04192 }
04193 
04194 
04195 SWIGINTERN PyObject *_wrap_doubleArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04196   PyObject *resultobj = 0;
04197   doubleArray *arg1 = (doubleArray *) 0 ;
04198   size_t arg2 ;
04199   double arg3 ;
04200   void *argp1 = 0 ;
04201   int res1 = 0 ;
04202   size_t val2 ;
04203   int ecode2 = 0 ;
04204   double val3 ;
04205   int ecode3 = 0 ;
04206   PyObject * obj0 = 0 ;
04207   PyObject * obj1 = 0 ;
04208   PyObject * obj2 = 0 ;
04209   
04210   if (!PyArg_ParseTuple(args,(char *)"OOO:doubleArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
04211   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doubleArray, 0 |  0 );
04212   if (!SWIG_IsOK(res1)) {
04213     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray___setitem__" "', argument " "1"" of type '" "doubleArray *""'"); 
04214   }
04215   arg1 = reinterpret_cast< doubleArray * >(argp1);
04216   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
04217   if (!SWIG_IsOK(ecode2)) {
04218     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray___setitem__" "', argument " "2"" of type '" "size_t""'");
04219   } 
04220   arg2 = static_cast< size_t >(val2);
04221   ecode3 = SWIG_AsVal_double(obj2, &val3);
04222   if (!SWIG_IsOK(ecode3)) {
04223     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray___setitem__" "', argument " "3"" of type '" "double""'");
04224   } 
04225   arg3 = static_cast< double >(val3);
04226   doubleArray___setitem__(arg1,arg2,arg3);
04227   resultobj = SWIG_Py_Void();
04228   return resultobj;
04229 fail:
04230   return NULL;
04231 }
04232 
04233 
04234 SWIGINTERN PyObject *_wrap_doubleArray_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04235   PyObject *resultobj = 0;
04236   doubleArray *arg1 = (doubleArray *) 0 ;
04237   void *argp1 = 0 ;
04238   int res1 = 0 ;
04239   PyObject * obj0 = 0 ;
04240   double *result = 0 ;
04241   
04242   if (!PyArg_ParseTuple(args,(char *)"O:doubleArray_cast",&obj0)) SWIG_fail;
04243   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doubleArray, 0 |  0 );
04244   if (!SWIG_IsOK(res1)) {
04245     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_cast" "', argument " "1"" of type '" "doubleArray *""'"); 
04246   }
04247   arg1 = reinterpret_cast< doubleArray * >(argp1);
04248   result = (double *)doubleArray_cast(arg1);
04249   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
04250   return resultobj;
04251 fail:
04252   return NULL;
04253 }
04254 
04255 
04256 SWIGINTERN PyObject *_wrap_doubleArray_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04257   PyObject *resultobj = 0;
04258   double *arg1 = (double *) 0 ;
04259   void *argp1 = 0 ;
04260   int res1 = 0 ;
04261   PyObject * obj0 = 0 ;
04262   doubleArray *result = 0 ;
04263   
04264   if (!PyArg_ParseTuple(args,(char *)"O:doubleArray_frompointer",&obj0)) SWIG_fail;
04265   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
04266   if (!SWIG_IsOK(res1)) {
04267     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_frompointer" "', argument " "1"" of type '" "double *""'"); 
04268   }
04269   arg1 = reinterpret_cast< double * >(argp1);
04270   result = (doubleArray *)doubleArray_frompointer(arg1);
04271   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_doubleArray, 0 |  0 );
04272   return resultobj;
04273 fail:
04274   return NULL;
04275 }
04276 
04277 
04278 SWIGINTERN PyObject *doubleArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04279   PyObject *obj;
04280   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
04281   SWIG_TypeNewClientData(SWIGTYPE_p_doubleArray, SWIG_NewClientData(obj));
04282   return SWIG_Py_Void();
04283 }
04284 
04285 SWIGINTERN PyObject *_wrap_new_stringArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04286   PyObject *resultobj = 0;
04287   int arg1 ;
04288   int arg2 ;
04289   int val1 ;
04290   int ecode1 = 0 ;
04291   int val2 ;
04292   int ecode2 = 0 ;
04293   PyObject * obj0 = 0 ;
04294   PyObject * obj1 = 0 ;
04295   stringArray *result = 0 ;
04296   
04297   if (!PyArg_ParseTuple(args,(char *)"OO:new_stringArray",&obj0,&obj1)) SWIG_fail;
04298   ecode1 = SWIG_AsVal_int(obj0, &val1);
04299   if (!SWIG_IsOK(ecode1)) {
04300     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_stringArray" "', argument " "1"" of type '" "int""'");
04301   } 
04302   arg1 = static_cast< int >(val1);
04303   ecode2 = SWIG_AsVal_int(obj1, &val2);
04304   if (!SWIG_IsOK(ecode2)) {
04305     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_stringArray" "', argument " "2"" of type '" "int""'");
04306   } 
04307   arg2 = static_cast< int >(val2);
04308   result = (stringArray *)new stringArray(arg1,arg2);
04309   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_stringArray, SWIG_POINTER_NEW |  0 );
04310   return resultobj;
04311 fail:
04312   return NULL;
04313 }
04314 
04315 
04316 SWIGINTERN PyObject *_wrap_new_stringArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04317   PyObject *resultobj = 0;
04318   int arg1 ;
04319   int val1 ;
04320   int ecode1 = 0 ;
04321   PyObject * obj0 = 0 ;
04322   stringArray *result = 0 ;
04323   
04324   if (!PyArg_ParseTuple(args,(char *)"O:new_stringArray",&obj0)) SWIG_fail;
04325   ecode1 = SWIG_AsVal_int(obj0, &val1);
04326   if (!SWIG_IsOK(ecode1)) {
04327     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_stringArray" "', argument " "1"" of type '" "int""'");
04328   } 
04329   arg1 = static_cast< int >(val1);
04330   result = (stringArray *)new stringArray(arg1);
04331   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_stringArray, SWIG_POINTER_NEW |  0 );
04332   return resultobj;
04333 fail:
04334   return NULL;
04335 }
04336 
04337 
04338 SWIGINTERN PyObject *_wrap_new_stringArray(PyObject *self, PyObject *args) {
04339   int argc;
04340   PyObject *argv[3];
04341   int ii;
04342   
04343   if (!PyTuple_Check(args)) SWIG_fail;
04344   argc = (int)PyObject_Length(args);
04345   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
04346     argv[ii] = PyTuple_GET_ITEM(args,ii);
04347   }
04348   if (argc == 1) {
04349     int _v;
04350     {
04351       int res = SWIG_AsVal_int(argv[0], NULL);
04352       _v = SWIG_CheckState(res);
04353     }
04354     if (_v) {
04355       return _wrap_new_stringArray__SWIG_1(self, args);
04356     }
04357   }
04358   if (argc == 2) {
04359     int _v;
04360     {
04361       int res = SWIG_AsVal_int(argv[0], NULL);
04362       _v = SWIG_CheckState(res);
04363     }
04364     if (_v) {
04365       {
04366         int res = SWIG_AsVal_int(argv[1], NULL);
04367         _v = SWIG_CheckState(res);
04368       }
04369       if (_v) {
04370         return _wrap_new_stringArray__SWIG_0(self, args);
04371       }
04372     }
04373   }
04374   
04375 fail:
04376   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_stringArray'.\n"
04377     "  Possible C/C++ prototypes are:\n"
04378     "    stringArray(int,int)\n"
04379     "    stringArray(int)\n");
04380   return NULL;
04381 }
04382 
04383 
04384 SWIGINTERN PyObject *_wrap_delete_stringArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04385   PyObject *resultobj = 0;
04386   stringArray *arg1 = (stringArray *) 0 ;
04387   void *argp1 = 0 ;
04388   int res1 = 0 ;
04389   PyObject * obj0 = 0 ;
04390   
04391   if (!PyArg_ParseTuple(args,(char *)"O:delete_stringArray",&obj0)) SWIG_fail;
04392   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_stringArray, SWIG_POINTER_DISOWN |  0 );
04393   if (!SWIG_IsOK(res1)) {
04394     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_stringArray" "', argument " "1"" of type '" "stringArray *""'"); 
04395   }
04396   arg1 = reinterpret_cast< stringArray * >(argp1);
04397   delete arg1;
04398   resultobj = SWIG_Py_Void();
04399   return resultobj;
04400 fail:
04401   return NULL;
04402 }
04403 
04404 
04405 SWIGINTERN PyObject *_wrap_stringArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04406   PyObject *resultobj = 0;
04407   stringArray *arg1 = (stringArray *) 0 ;
04408   int arg2 ;
04409   void *argp1 = 0 ;
04410   int res1 = 0 ;
04411   int val2 ;
04412   int ecode2 = 0 ;
04413   PyObject * obj0 = 0 ;
04414   PyObject * obj1 = 0 ;
04415   char *result = 0 ;
04416   
04417   if (!PyArg_ParseTuple(args,(char *)"OO:stringArray___getitem__",&obj0,&obj1)) SWIG_fail;
04418   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_stringArray, 0 |  0 );
04419   if (!SWIG_IsOK(res1)) {
04420     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringArray___getitem__" "', argument " "1"" of type '" "stringArray *""'"); 
04421   }
04422   arg1 = reinterpret_cast< stringArray * >(argp1);
04423   ecode2 = SWIG_AsVal_int(obj1, &val2);
04424   if (!SWIG_IsOK(ecode2)) {
04425     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "stringArray___getitem__" "', argument " "2"" of type '" "int""'");
04426   } 
04427   arg2 = static_cast< int >(val2);
04428   result = (char *)(arg1)->__getitem__(arg2);
04429   resultobj = SWIG_FromCharPtr((const char *)result);
04430   return resultobj;
04431 fail:
04432   return NULL;
04433 }
04434 
04435 
04436 SWIGINTERN PyObject *_wrap_stringArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04437   PyObject *resultobj = 0;
04438   stringArray *arg1 = (stringArray *) 0 ;
04439   int arg2 ;
04440   char *arg3 = (char *) 0 ;
04441   void *argp1 = 0 ;
04442   int res1 = 0 ;
04443   int val2 ;
04444   int ecode2 = 0 ;
04445   int res3 ;
04446   char *buf3 = 0 ;
04447   int alloc3 = 0 ;
04448   PyObject * obj0 = 0 ;
04449   PyObject * obj1 = 0 ;
04450   PyObject * obj2 = 0 ;
04451   
04452   if (!PyArg_ParseTuple(args,(char *)"OOO:stringArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
04453   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_stringArray, 0 |  0 );
04454   if (!SWIG_IsOK(res1)) {
04455     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringArray___setitem__" "', argument " "1"" of type '" "stringArray *""'"); 
04456   }
04457   arg1 = reinterpret_cast< stringArray * >(argp1);
04458   ecode2 = SWIG_AsVal_int(obj1, &val2);
04459   if (!SWIG_IsOK(ecode2)) {
04460     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "stringArray___setitem__" "', argument " "2"" of type '" "int""'");
04461   } 
04462   arg2 = static_cast< int >(val2);
04463   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
04464   if (!SWIG_IsOK(res3)) {
04465     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "stringArray___setitem__" "', argument " "3"" of type '" "char *""'");
04466   }
04467   arg3 = reinterpret_cast< char * >(buf3);
04468   (arg1)->__setitem__(arg2,arg3);
04469   resultobj = SWIG_Py_Void();
04470   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04471   return resultobj;
04472 fail:
04473   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04474   return NULL;
04475 }
04476 
04477 
04478 SWIGINTERN PyObject *_wrap_stringArray_data_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04479   PyObject *resultobj = 0;
04480   stringArray *arg1 = (stringArray *) 0 ;
04481   char **arg2 = (char **) 0 ;
04482   void *argp1 = 0 ;
04483   int res1 = 0 ;
04484   void *argp2 = 0 ;
04485   int res2 = 0 ;
04486   PyObject * obj0 = 0 ;
04487   PyObject * obj1 = 0 ;
04488   
04489   if (!PyArg_ParseTuple(args,(char *)"OO:stringArray_data_set",&obj0,&obj1)) SWIG_fail;
04490   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_stringArray, 0 |  0 );
04491   if (!SWIG_IsOK(res1)) {
04492     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringArray_data_set" "', argument " "1"" of type '" "stringArray *""'"); 
04493   }
04494   arg1 = reinterpret_cast< stringArray * >(argp1);
04495   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
04496   if (!SWIG_IsOK(res2)) {
04497     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "stringArray_data_set" "', argument " "2"" of type '" "char **""'"); 
04498   }
04499   arg2 = reinterpret_cast< char ** >(argp2);
04500   if (arg1) (arg1)->data = arg2;
04501   resultobj = SWIG_Py_Void();
04502   return resultobj;
04503 fail:
04504   return NULL;
04505 }
04506 
04507 
04508 SWIGINTERN PyObject *_wrap_stringArray_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04509   PyObject *resultobj = 0;
04510   stringArray *arg1 = (stringArray *) 0 ;
04511   void *argp1 = 0 ;
04512   int res1 = 0 ;
04513   PyObject * obj0 = 0 ;
04514   char **result = 0 ;
04515   
04516   if (!PyArg_ParseTuple(args,(char *)"O:stringArray_data_get",&obj0)) SWIG_fail;
04517   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_stringArray, 0 |  0 );
04518   if (!SWIG_IsOK(res1)) {
04519     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringArray_data_get" "', argument " "1"" of type '" "stringArray *""'"); 
04520   }
04521   arg1 = reinterpret_cast< stringArray * >(argp1);
04522   result = (char **) ((arg1)->data);
04523   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
04524   return resultobj;
04525 fail:
04526   return NULL;
04527 }
04528 
04529 
04530 SWIGINTERN PyObject *_wrap_stringArray_nelem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04531   PyObject *resultobj = 0;
04532   stringArray *arg1 = (stringArray *) 0 ;
04533   int arg2 ;
04534   void *argp1 = 0 ;
04535   int res1 = 0 ;
04536   int val2 ;
04537   int ecode2 = 0 ;
04538   PyObject * obj0 = 0 ;
04539   PyObject * obj1 = 0 ;
04540   
04541   if (!PyArg_ParseTuple(args,(char *)"OO:stringArray_nelem_set",&obj0,&obj1)) SWIG_fail;
04542   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_stringArray, 0 |  0 );
04543   if (!SWIG_IsOK(res1)) {
04544     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringArray_nelem_set" "', argument " "1"" of type '" "stringArray *""'"); 
04545   }
04546   arg1 = reinterpret_cast< stringArray * >(argp1);
04547   ecode2 = SWIG_AsVal_int(obj1, &val2);
04548   if (!SWIG_IsOK(ecode2)) {
04549     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "stringArray_nelem_set" "', argument " "2"" of type '" "int""'");
04550   } 
04551   arg2 = static_cast< int >(val2);
04552   if (arg1) (arg1)->nelem = arg2;
04553   resultobj = SWIG_Py_Void();
04554   return resultobj;
04555 fail:
04556   return NULL;
04557 }
04558 
04559 
04560 SWIGINTERN PyObject *_wrap_stringArray_nelem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04561   PyObject *resultobj = 0;
04562   stringArray *arg1 = (stringArray *) 0 ;
04563   void *argp1 = 0 ;
04564   int res1 = 0 ;
04565   PyObject * obj0 = 0 ;
04566   int result;
04567   
04568   if (!PyArg_ParseTuple(args,(char *)"O:stringArray_nelem_get",&obj0)) SWIG_fail;
04569   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_stringArray, 0 |  0 );
04570   if (!SWIG_IsOK(res1)) {
04571     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringArray_nelem_get" "', argument " "1"" of type '" "stringArray *""'"); 
04572   }
04573   arg1 = reinterpret_cast< stringArray * >(argp1);
04574   result = (int) ((arg1)->nelem);
04575   resultobj = SWIG_From_int(static_cast< int >(result));
04576   return resultobj;
04577 fail:
04578   return NULL;
04579 }
04580 
04581 
04582 SWIGINTERN PyObject *_wrap_stringArray_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04583   PyObject *resultobj = 0;
04584   stringArray *arg1 = (stringArray *) 0 ;
04585   int arg2 ;
04586   void *argp1 = 0 ;
04587   int res1 = 0 ;
04588   int val2 ;
04589   int ecode2 = 0 ;
04590   PyObject * obj0 = 0 ;
04591   PyObject * obj1 = 0 ;
04592   
04593   if (!PyArg_ParseTuple(args,(char *)"OO:stringArray_size_set",&obj0,&obj1)) SWIG_fail;
04594   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_stringArray, 0 |  0 );
04595   if (!SWIG_IsOK(res1)) {
04596     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringArray_size_set" "', argument " "1"" of type '" "stringArray *""'"); 
04597   }
04598   arg1 = reinterpret_cast< stringArray * >(argp1);
04599   ecode2 = SWIG_AsVal_int(obj1, &val2);
04600   if (!SWIG_IsOK(ecode2)) {
04601     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "stringArray_size_set" "', argument " "2"" of type '" "int""'");
04602   } 
04603   arg2 = static_cast< int >(val2);
04604   if (arg1) (arg1)->size = arg2;
04605   resultobj = SWIG_Py_Void();
04606   return resultobj;
04607 fail:
04608   return NULL;
04609 }
04610 
04611 
04612 SWIGINTERN PyObject *_wrap_stringArray_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04613   PyObject *resultobj = 0;
04614   stringArray *arg1 = (stringArray *) 0 ;
04615   void *argp1 = 0 ;
04616   int res1 = 0 ;
04617   PyObject * obj0 = 0 ;
04618   int result;
04619   
04620   if (!PyArg_ParseTuple(args,(char *)"O:stringArray_size_get",&obj0)) SWIG_fail;
04621   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_stringArray, 0 |  0 );
04622   if (!SWIG_IsOK(res1)) {
04623     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringArray_size_get" "', argument " "1"" of type '" "stringArray *""'"); 
04624   }
04625   arg1 = reinterpret_cast< stringArray * >(argp1);
04626   result = (int) ((arg1)->size);
04627   resultobj = SWIG_From_int(static_cast< int >(result));
04628   return resultobj;
04629 fail:
04630   return NULL;
04631 }
04632 
04633 
04634 SWIGINTERN PyObject *stringArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04635   PyObject *obj;
04636   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
04637   SWIG_TypeNewClientData(SWIGTYPE_p_stringArray, SWIG_NewClientData(obj));
04638   return SWIG_Py_Void();
04639 }
04640 
04641 SWIGINTERN PyObject *_wrap_new_DSC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04642   PyObject *resultobj = 0;
04643   Engines::DSC *result = 0 ;
04644   
04645   if (!PyArg_ParseTuple(args,(char *)":new_DSC")) SWIG_fail;
04646   {
04647     Py_BEGIN_ALLOW_THREADS
04648     try {
04649       result = (Engines::DSC *)new Engines::DSC();
04650     }
04651     catch(Engines::DSC::PortNotDefined& _e) {
04652       Py_BLOCK_THREADS
04653       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
04654       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04655       PyErr_SetObject(excc, exci);
04656       Py_XDECREF(excc);
04657       Py_XDECREF(exci);
04658       return NULL;
04659     }
04660     catch(Engines::DSC::PortNotConnected& _e) {
04661       Py_BLOCK_THREADS
04662       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
04663       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04664       PyErr_SetObject(excc, exci);
04665       Py_XDECREF(excc);
04666       Py_XDECREF(exci);
04667       return NULL;
04668     }
04669     catch(Engines::DSC::BadPortType& _e) {
04670       Py_BLOCK_THREADS
04671       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
04672       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04673       PyErr_SetObject(excc, exci);
04674       Py_XDECREF(excc);
04675       Py_XDECREF(exci);
04676       return NULL;
04677     }
04678     catch (SALOME_Exception &e) {
04679       Py_BLOCK_THREADS
04680       PyErr_SetString(PyExc_RuntimeError,e.what());
04681       return NULL;
04682     }
04683     catch (SALOME::SALOME_Exception &e) {
04684       Py_BLOCK_THREADS
04685       //This one should be converted into a python corba exception
04686       PyErr_SetString(PyExc_RuntimeError,e.details.text);
04687       return NULL;
04688     }
04689     catch (const CORBA::SystemException& e) {
04690       Py_BLOCK_THREADS 
04691       return api->handleCxxSystemException(e);
04692     }
04693     catch(...) {
04694       Py_BLOCK_THREADS
04695       PyErr_SetString(PyExc_ValueError,"Unknown exception");
04696       return NULL;
04697     }
04698     Py_END_ALLOW_THREADS
04699   }
04700   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Engines__DSC, SWIG_POINTER_NEW |  0 );
04701   return resultobj;
04702 fail:
04703   return NULL;
04704 }
04705 
04706 
04707 SWIGINTERN PyObject *_wrap_delete_DSC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04708   PyObject *resultobj = 0;
04709   Engines::DSC *arg1 = (Engines::DSC *) 0 ;
04710   void *argp1 = 0 ;
04711   int res1 = 0 ;
04712   PyObject * obj0 = 0 ;
04713   
04714   if (!PyArg_ParseTuple(args,(char *)"O:delete_DSC",&obj0)) SWIG_fail;
04715   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Engines__DSC, SWIG_POINTER_DISOWN |  0 );
04716   if (!SWIG_IsOK(res1)) {
04717     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DSC" "', argument " "1"" of type '" "Engines::DSC *""'"); 
04718   }
04719   arg1 = reinterpret_cast< Engines::DSC * >(argp1);
04720   {
04721     Py_BEGIN_ALLOW_THREADS
04722     try {
04723       delete arg1;
04724     }
04725     catch(Engines::DSC::PortNotDefined& _e) {
04726       Py_BLOCK_THREADS
04727       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
04728       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04729       PyErr_SetObject(excc, exci);
04730       Py_XDECREF(excc);
04731       Py_XDECREF(exci);
04732       return NULL;
04733     }
04734     catch(Engines::DSC::PortNotConnected& _e) {
04735       Py_BLOCK_THREADS
04736       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
04737       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04738       PyErr_SetObject(excc, exci);
04739       Py_XDECREF(excc);
04740       Py_XDECREF(exci);
04741       return NULL;
04742     }
04743     catch(Engines::DSC::BadPortType& _e) {
04744       Py_BLOCK_THREADS
04745       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
04746       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04747       PyErr_SetObject(excc, exci);
04748       Py_XDECREF(excc);
04749       Py_XDECREF(exci);
04750       return NULL;
04751     }
04752     catch (SALOME_Exception &e) {
04753       Py_BLOCK_THREADS
04754       PyErr_SetString(PyExc_RuntimeError,e.what());
04755       return NULL;
04756     }
04757     catch (SALOME::SALOME_Exception &e) {
04758       Py_BLOCK_THREADS
04759       //This one should be converted into a python corba exception
04760       PyErr_SetString(PyExc_RuntimeError,e.details.text);
04761       return NULL;
04762     }
04763     catch (const CORBA::SystemException& e) {
04764       Py_BLOCK_THREADS 
04765       return api->handleCxxSystemException(e);
04766     }
04767     catch(...) {
04768       Py_BLOCK_THREADS
04769       PyErr_SetString(PyExc_ValueError,"Unknown exception");
04770       return NULL;
04771     }
04772     Py_END_ALLOW_THREADS
04773   }
04774   resultobj = SWIG_Py_Void();
04775   return resultobj;
04776 fail:
04777   return NULL;
04778 }
04779 
04780 
04781 SWIGINTERN PyObject *DSC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04782   PyObject *obj;
04783   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
04784   SWIG_TypeNewClientData(SWIGTYPE_p_Engines__DSC, SWIG_NewClientData(obj));
04785   return SWIG_Py_Void();
04786 }
04787 
04788 SWIGINTERN PyObject *_wrap_new_PySupervCompo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04789   PyObject *resultobj = 0;
04790   CORBA::ORB_ptr arg1 ;
04791   PortableServer::POA_ptr arg2 ;
04792   Engines::Container_ptr arg3 ;
04793   char *arg4 = (char *) 0 ;
04794   char *arg5 = (char *) 0 ;
04795   int res4 ;
04796   char *buf4 = 0 ;
04797   int alloc4 = 0 ;
04798   int res5 ;
04799   char *buf5 = 0 ;
04800   int alloc5 = 0 ;
04801   PyObject * obj0 = 0 ;
04802   PyObject * obj1 = 0 ;
04803   PyObject * obj2 = 0 ;
04804   PyObject * obj3 = 0 ;
04805   PyObject * obj4 = 0 ;
04806   PySupervCompo *result = 0 ;
04807   
04808   if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_PySupervCompo",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
04809   {
04810     Py_BEGIN_ALLOW_THREADS
04811     try
04812     {
04813       CORBA::Object_var obj = api->pyObjRefToCxxObjRef(obj0,0);
04814       arg1 = CORBA::ORB::_narrow(obj);
04815     }
04816     catch(...)
04817     {
04818       Py_BLOCK_THREADS
04819       PyErr_SetString(PyExc_RuntimeError, "not a valid CORBA object ptr");
04820     }
04821     Py_END_ALLOW_THREADS
04822   }
04823   {
04824     Py_BEGIN_ALLOW_THREADS
04825     try
04826     {
04827       CORBA::Object_var obj = api->pyObjRefToCxxObjRef(obj1,0);
04828       arg2 = PortableServer::POA::_narrow(obj);
04829     }
04830     catch(...)
04831     {
04832       Py_BLOCK_THREADS
04833       PyErr_SetString(PyExc_RuntimeError, "not a valid CORBA object ptr");
04834     }
04835     Py_END_ALLOW_THREADS
04836   }
04837   {
04838     Py_BEGIN_ALLOW_THREADS
04839     try
04840     {
04841       CORBA::Object_var obj = api->pyObjRefToCxxObjRef(obj2,0);
04842       arg3 = Engines::Container::_narrow(obj);
04843     }
04844     catch(...)
04845     {
04846       Py_BLOCK_THREADS
04847       PyErr_SetString(PyExc_RuntimeError, "not a valid CORBA object ptr");
04848     }
04849     Py_END_ALLOW_THREADS
04850   }
04851   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
04852   if (!SWIG_IsOK(res4)) {
04853     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PySupervCompo" "', argument " "4"" of type '" "char const *""'");
04854   }
04855   arg4 = reinterpret_cast< char * >(buf4);
04856   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
04857   if (!SWIG_IsOK(res5)) {
04858     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PySupervCompo" "', argument " "5"" of type '" "char const *""'");
04859   }
04860   arg5 = reinterpret_cast< char * >(buf5);
04861   {
04862     Py_BEGIN_ALLOW_THREADS
04863     try {
04864       result = (PySupervCompo *)new PySupervCompo(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5);
04865     }
04866     catch(Engines::DSC::PortNotDefined& _e) {
04867       Py_BLOCK_THREADS
04868       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
04869       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04870       PyErr_SetObject(excc, exci);
04871       Py_XDECREF(excc);
04872       Py_XDECREF(exci);
04873       return NULL;
04874     }
04875     catch(Engines::DSC::PortNotConnected& _e) {
04876       Py_BLOCK_THREADS
04877       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
04878       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04879       PyErr_SetObject(excc, exci);
04880       Py_XDECREF(excc);
04881       Py_XDECREF(exci);
04882       return NULL;
04883     }
04884     catch(Engines::DSC::BadPortType& _e) {
04885       Py_BLOCK_THREADS
04886       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
04887       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04888       PyErr_SetObject(excc, exci);
04889       Py_XDECREF(excc);
04890       Py_XDECREF(exci);
04891       return NULL;
04892     }
04893     catch (SALOME_Exception &e) {
04894       Py_BLOCK_THREADS
04895       PyErr_SetString(PyExc_RuntimeError,e.what());
04896       return NULL;
04897     }
04898     catch (SALOME::SALOME_Exception &e) {
04899       Py_BLOCK_THREADS
04900       //This one should be converted into a python corba exception
04901       PyErr_SetString(PyExc_RuntimeError,e.details.text);
04902       return NULL;
04903     }
04904     catch (const CORBA::SystemException& e) {
04905       Py_BLOCK_THREADS 
04906       return api->handleCxxSystemException(e);
04907     }
04908     catch(...) {
04909       Py_BLOCK_THREADS
04910       PyErr_SetString(PyExc_ValueError,"Unknown exception");
04911       return NULL;
04912     }
04913     Py_END_ALLOW_THREADS
04914   }
04915   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PySupervCompo, SWIG_POINTER_NEW |  0 );
04916   {
04917     CORBA::release(arg1);
04918   }
04919   {
04920     CORBA::release(arg2);
04921   }
04922   {
04923     CORBA::release(arg3);
04924   }
04925   if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
04926   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
04927   return resultobj;
04928 fail:
04929   {
04930     CORBA::release(arg1);
04931   }
04932   {
04933     CORBA::release(arg2);
04934   }
04935   {
04936     CORBA::release(arg3);
04937   }
04938   if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
04939   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
04940   return NULL;
04941 }
04942 
04943 
04944 SWIGINTERN PyObject *_wrap_delete_PySupervCompo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04945   PyObject *resultobj = 0;
04946   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
04947   void *argp1 = 0 ;
04948   int res1 = 0 ;
04949   PyObject * obj0 = 0 ;
04950   
04951   if (!PyArg_ParseTuple(args,(char *)"O:delete_PySupervCompo",&obj0)) SWIG_fail;
04952   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, SWIG_POINTER_DISOWN |  0 );
04953   if (!SWIG_IsOK(res1)) {
04954     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySupervCompo" "', argument " "1"" of type '" "PySupervCompo *""'"); 
04955   }
04956   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
04957   {
04958     Py_BEGIN_ALLOW_THREADS
04959     try {
04960       delete arg1;
04961     }
04962     catch(Engines::DSC::PortNotDefined& _e) {
04963       Py_BLOCK_THREADS
04964       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
04965       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04966       PyErr_SetObject(excc, exci);
04967       Py_XDECREF(excc);
04968       Py_XDECREF(exci);
04969       return NULL;
04970     }
04971     catch(Engines::DSC::PortNotConnected& _e) {
04972       Py_BLOCK_THREADS
04973       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
04974       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04975       PyErr_SetObject(excc, exci);
04976       Py_XDECREF(excc);
04977       Py_XDECREF(exci);
04978       return NULL;
04979     }
04980     catch(Engines::DSC::BadPortType& _e) {
04981       Py_BLOCK_THREADS
04982       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
04983       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
04984       PyErr_SetObject(excc, exci);
04985       Py_XDECREF(excc);
04986       Py_XDECREF(exci);
04987       return NULL;
04988     }
04989     catch (SALOME_Exception &e) {
04990       Py_BLOCK_THREADS
04991       PyErr_SetString(PyExc_RuntimeError,e.what());
04992       return NULL;
04993     }
04994     catch (SALOME::SALOME_Exception &e) {
04995       Py_BLOCK_THREADS
04996       //This one should be converted into a python corba exception
04997       PyErr_SetString(PyExc_RuntimeError,e.details.text);
04998       return NULL;
04999     }
05000     catch (const CORBA::SystemException& e) {
05001       Py_BLOCK_THREADS 
05002       return api->handleCxxSystemException(e);
05003     }
05004     catch(...) {
05005       Py_BLOCK_THREADS
05006       PyErr_SetString(PyExc_ValueError,"Unknown exception");
05007       return NULL;
05008     }
05009     Py_END_ALLOW_THREADS
05010   }
05011   resultobj = SWIG_Py_Void();
05012   return resultobj;
05013 fail:
05014   return NULL;
05015 }
05016 
05017 
05018 SWIGINTERN PyObject *_wrap_PySupervCompo_init_service(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05019   PyObject *resultobj = 0;
05020   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
05021   char *arg2 = (char *) 0 ;
05022   void *argp1 = 0 ;
05023   int res1 = 0 ;
05024   int res2 ;
05025   char *buf2 = 0 ;
05026   int alloc2 = 0 ;
05027   PyObject * obj0 = 0 ;
05028   PyObject * obj1 = 0 ;
05029   CORBA::Boolean result;
05030   
05031   if (!PyArg_ParseTuple(args,(char *)"OO:PySupervCompo_init_service",&obj0,&obj1)) SWIG_fail;
05032   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
05033   if (!SWIG_IsOK(res1)) {
05034     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_init_service" "', argument " "1"" of type '" "PySupervCompo *""'"); 
05035   }
05036   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
05037   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05038   if (!SWIG_IsOK(res2)) {
05039     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_init_service" "', argument " "2"" of type '" "char const *""'");
05040   }
05041   arg2 = reinterpret_cast< char * >(buf2);
05042   {
05043     Py_BEGIN_ALLOW_THREADS
05044     try {
05045       result = (arg1)->init_service((char const *)arg2);
05046     }
05047     catch(Engines::DSC::PortNotDefined& _e) {
05048       Py_BLOCK_THREADS
05049       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
05050       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05051       PyErr_SetObject(excc, exci);
05052       Py_XDECREF(excc);
05053       Py_XDECREF(exci);
05054       return NULL;
05055     }
05056     catch(Engines::DSC::PortNotConnected& _e) {
05057       Py_BLOCK_THREADS
05058       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
05059       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05060       PyErr_SetObject(excc, exci);
05061       Py_XDECREF(excc);
05062       Py_XDECREF(exci);
05063       return NULL;
05064     }
05065     catch(Engines::DSC::BadPortType& _e) {
05066       Py_BLOCK_THREADS
05067       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
05068       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05069       PyErr_SetObject(excc, exci);
05070       Py_XDECREF(excc);
05071       Py_XDECREF(exci);
05072       return NULL;
05073     }
05074     catch (SALOME_Exception &e) {
05075       Py_BLOCK_THREADS
05076       PyErr_SetString(PyExc_RuntimeError,e.what());
05077       return NULL;
05078     }
05079     catch (SALOME::SALOME_Exception &e) {
05080       Py_BLOCK_THREADS
05081       //This one should be converted into a python corba exception
05082       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05083       return NULL;
05084     }
05085     catch (const CORBA::SystemException& e) {
05086       Py_BLOCK_THREADS 
05087       return api->handleCxxSystemException(e);
05088     }
05089     catch(...) {
05090       Py_BLOCK_THREADS
05091       PyErr_SetString(PyExc_ValueError,"Unknown exception");
05092       return NULL;
05093     }
05094     Py_END_ALLOW_THREADS
05095   }
05096   {
05097     resultobj=PyInt_FromLong(result ? 1 : 0);
05098   }
05099   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05100   return resultobj;
05101 fail:
05102   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05103   return NULL;
05104 }
05105 
05106 
05107 SWIGINTERN PyObject *_wrap_PySupervCompo_create_provides_data_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05108   PyObject *resultobj = 0;
05109   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
05110   char *arg2 = (char *) 0 ;
05111   void *argp1 = 0 ;
05112   int res1 = 0 ;
05113   int res2 ;
05114   char *buf2 = 0 ;
05115   int alloc2 = 0 ;
05116   PyObject * obj0 = 0 ;
05117   PyObject * obj1 = 0 ;
05118   provides_port *result = 0 ;
05119   
05120   if (!PyArg_ParseTuple(args,(char *)"OO:PySupervCompo_create_provides_data_port",&obj0,&obj1)) SWIG_fail;
05121   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
05122   if (!SWIG_IsOK(res1)) {
05123     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_create_provides_data_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
05124   }
05125   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
05126   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05127   if (!SWIG_IsOK(res2)) {
05128     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_create_provides_data_port" "', argument " "2"" of type '" "char const *""'");
05129   }
05130   arg2 = reinterpret_cast< char * >(buf2);
05131   {
05132     Py_BEGIN_ALLOW_THREADS
05133     try {
05134       result = (provides_port *)(arg1)->create_provides_data_port((char const *)arg2);
05135     }
05136     catch(Engines::DSC::PortNotDefined& _e) {
05137       Py_BLOCK_THREADS
05138       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
05139       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05140       PyErr_SetObject(excc, exci);
05141       Py_XDECREF(excc);
05142       Py_XDECREF(exci);
05143       return NULL;
05144     }
05145     catch(Engines::DSC::PortNotConnected& _e) {
05146       Py_BLOCK_THREADS
05147       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
05148       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05149       PyErr_SetObject(excc, exci);
05150       Py_XDECREF(excc);
05151       Py_XDECREF(exci);
05152       return NULL;
05153     }
05154     catch(Engines::DSC::BadPortType& _e) {
05155       Py_BLOCK_THREADS
05156       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
05157       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05158       PyErr_SetObject(excc, exci);
05159       Py_XDECREF(excc);
05160       Py_XDECREF(exci);
05161       return NULL;
05162     }
05163     catch (SALOME_Exception &e) {
05164       Py_BLOCK_THREADS
05165       PyErr_SetString(PyExc_RuntimeError,e.what());
05166       return NULL;
05167     }
05168     catch (SALOME::SALOME_Exception &e) {
05169       Py_BLOCK_THREADS
05170       //This one should be converted into a python corba exception
05171       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05172       return NULL;
05173     }
05174     catch (const CORBA::SystemException& e) {
05175       Py_BLOCK_THREADS 
05176       return api->handleCxxSystemException(e);
05177     }
05178     catch(...) {
05179       Py_BLOCK_THREADS
05180       PyErr_SetString(PyExc_ValueError,"Unknown exception");
05181       return NULL;
05182     }
05183     Py_END_ALLOW_THREADS
05184   }
05185   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_provides_port, 0 |  0 );
05186   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05187   return resultobj;
05188 fail:
05189   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05190   return NULL;
05191 }
05192 
05193 
05194 SWIGINTERN PyObject *_wrap_PySupervCompo_create_uses_data_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05195   PyObject *resultobj = 0;
05196   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
05197   char *arg2 = (char *) 0 ;
05198   void *argp1 = 0 ;
05199   int res1 = 0 ;
05200   int res2 ;
05201   char *buf2 = 0 ;
05202   int alloc2 = 0 ;
05203   PyObject * obj0 = 0 ;
05204   PyObject * obj1 = 0 ;
05205   uses_port *result = 0 ;
05206   
05207   if (!PyArg_ParseTuple(args,(char *)"OO:PySupervCompo_create_uses_data_port",&obj0,&obj1)) SWIG_fail;
05208   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
05209   if (!SWIG_IsOK(res1)) {
05210     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_create_uses_data_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
05211   }
05212   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
05213   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05214   if (!SWIG_IsOK(res2)) {
05215     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_create_uses_data_port" "', argument " "2"" of type '" "char const *""'");
05216   }
05217   arg2 = reinterpret_cast< char * >(buf2);
05218   {
05219     Py_BEGIN_ALLOW_THREADS
05220     try {
05221       result = (uses_port *)(arg1)->create_uses_data_port((char const *)arg2);
05222     }
05223     catch(Engines::DSC::PortNotDefined& _e) {
05224       Py_BLOCK_THREADS
05225       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
05226       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05227       PyErr_SetObject(excc, exci);
05228       Py_XDECREF(excc);
05229       Py_XDECREF(exci);
05230       return NULL;
05231     }
05232     catch(Engines::DSC::PortNotConnected& _e) {
05233       Py_BLOCK_THREADS
05234       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
05235       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05236       PyErr_SetObject(excc, exci);
05237       Py_XDECREF(excc);
05238       Py_XDECREF(exci);
05239       return NULL;
05240     }
05241     catch(Engines::DSC::BadPortType& _e) {
05242       Py_BLOCK_THREADS
05243       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
05244       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05245       PyErr_SetObject(excc, exci);
05246       Py_XDECREF(excc);
05247       Py_XDECREF(exci);
05248       return NULL;
05249     }
05250     catch (SALOME_Exception &e) {
05251       Py_BLOCK_THREADS
05252       PyErr_SetString(PyExc_RuntimeError,e.what());
05253       return NULL;
05254     }
05255     catch (SALOME::SALOME_Exception &e) {
05256       Py_BLOCK_THREADS
05257       //This one should be converted into a python corba exception
05258       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05259       return NULL;
05260     }
05261     catch (const CORBA::SystemException& e) {
05262       Py_BLOCK_THREADS 
05263       return api->handleCxxSystemException(e);
05264     }
05265     catch(...) {
05266       Py_BLOCK_THREADS
05267       PyErr_SetString(PyExc_ValueError,"Unknown exception");
05268       return NULL;
05269     }
05270     Py_END_ALLOW_THREADS
05271   }
05272   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uses_port, 0 |  0 );
05273   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05274   return resultobj;
05275 fail:
05276   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05277   return NULL;
05278 }
05279 
05280 
05281 SWIGINTERN PyObject *_wrap_PySupervCompo_add_port__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05282   PyObject *resultobj = 0;
05283   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
05284   char *arg2 = (char *) 0 ;
05285   char *arg3 = (char *) 0 ;
05286   char *arg4 = (char *) 0 ;
05287   void *argp1 = 0 ;
05288   int res1 = 0 ;
05289   int res2 ;
05290   char *buf2 = 0 ;
05291   int alloc2 = 0 ;
05292   int res3 ;
05293   char *buf3 = 0 ;
05294   int alloc3 = 0 ;
05295   int res4 ;
05296   char *buf4 = 0 ;
05297   int alloc4 = 0 ;
05298   PyObject * obj0 = 0 ;
05299   PyObject * obj1 = 0 ;
05300   PyObject * obj2 = 0 ;
05301   PyObject * obj3 = 0 ;
05302   
05303   if (!PyArg_ParseTuple(args,(char *)"OOOO:PySupervCompo_add_port",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
05304   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
05305   if (!SWIG_IsOK(res1)) {
05306     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_add_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
05307   }
05308   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
05309   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05310   if (!SWIG_IsOK(res2)) {
05311     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_add_port" "', argument " "2"" of type '" "char const *""'");
05312   }
05313   arg2 = reinterpret_cast< char * >(buf2);
05314   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
05315   if (!SWIG_IsOK(res3)) {
05316     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PySupervCompo_add_port" "', argument " "3"" of type '" "char const *""'");
05317   }
05318   arg3 = reinterpret_cast< char * >(buf3);
05319   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
05320   if (!SWIG_IsOK(res4)) {
05321     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PySupervCompo_add_port" "', argument " "4"" of type '" "char const *""'");
05322   }
05323   arg4 = reinterpret_cast< char * >(buf4);
05324   {
05325     Py_BEGIN_ALLOW_THREADS
05326     try {
05327       (arg1)->add_port((char const *)arg2,(char const *)arg3,(char const *)arg4);
05328     }
05329     catch(Engines::DSC::PortNotDefined& _e) {
05330       Py_BLOCK_THREADS
05331       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
05332       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05333       PyErr_SetObject(excc, exci);
05334       Py_XDECREF(excc);
05335       Py_XDECREF(exci);
05336       return NULL;
05337     }
05338     catch(Engines::DSC::PortNotConnected& _e) {
05339       Py_BLOCK_THREADS
05340       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
05341       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05342       PyErr_SetObject(excc, exci);
05343       Py_XDECREF(excc);
05344       Py_XDECREF(exci);
05345       return NULL;
05346     }
05347     catch(Engines::DSC::BadPortType& _e) {
05348       Py_BLOCK_THREADS
05349       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
05350       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05351       PyErr_SetObject(excc, exci);
05352       Py_XDECREF(excc);
05353       Py_XDECREF(exci);
05354       return NULL;
05355     }
05356     catch (SALOME_Exception &e) {
05357       Py_BLOCK_THREADS
05358       PyErr_SetString(PyExc_RuntimeError,e.what());
05359       return NULL;
05360     }
05361     catch (SALOME::SALOME_Exception &e) {
05362       Py_BLOCK_THREADS
05363       //This one should be converted into a python corba exception
05364       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05365       return NULL;
05366     }
05367     catch (const CORBA::SystemException& e) {
05368       Py_BLOCK_THREADS 
05369       return api->handleCxxSystemException(e);
05370     }
05371     catch(...) {
05372       Py_BLOCK_THREADS
05373       PyErr_SetString(PyExc_ValueError,"Unknown exception");
05374       return NULL;
05375     }
05376     Py_END_ALLOW_THREADS
05377   }
05378   resultobj = SWIG_Py_Void();
05379   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05380   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05381   if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
05382   return resultobj;
05383 fail:
05384   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05385   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05386   if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
05387   return NULL;
05388 }
05389 
05390 
05391 SWIGINTERN PyObject *_wrap_PySupervCompo_add_port__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05392   PyObject *resultobj = 0;
05393   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
05394   provides_port *arg2 = (provides_port *) 0 ;
05395   char *arg3 = (char *) 0 ;
05396   void *argp1 = 0 ;
05397   int res1 = 0 ;
05398   void *argp2 = 0 ;
05399   int res2 = 0 ;
05400   int res3 ;
05401   char *buf3 = 0 ;
05402   int alloc3 = 0 ;
05403   PyObject * obj0 = 0 ;
05404   PyObject * obj1 = 0 ;
05405   PyObject * obj2 = 0 ;
05406   
05407   if (!PyArg_ParseTuple(args,(char *)"OOO:PySupervCompo_add_port",&obj0,&obj1,&obj2)) SWIG_fail;
05408   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
05409   if (!SWIG_IsOK(res1)) {
05410     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_add_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
05411   }
05412   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
05413   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_provides_port, 0 |  0 );
05414   if (!SWIG_IsOK(res2)) {
05415     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_add_port" "', argument " "2"" of type '" "provides_port *""'"); 
05416   }
05417   arg2 = reinterpret_cast< provides_port * >(argp2);
05418   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
05419   if (!SWIG_IsOK(res3)) {
05420     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PySupervCompo_add_port" "', argument " "3"" of type '" "char const *""'");
05421   }
05422   arg3 = reinterpret_cast< char * >(buf3);
05423   {
05424     Py_BEGIN_ALLOW_THREADS
05425     try {
05426       (arg1)->add_port(arg2,(char const *)arg3);
05427     }
05428     catch(Engines::DSC::PortNotDefined& _e) {
05429       Py_BLOCK_THREADS
05430       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
05431       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05432       PyErr_SetObject(excc, exci);
05433       Py_XDECREF(excc);
05434       Py_XDECREF(exci);
05435       return NULL;
05436     }
05437     catch(Engines::DSC::PortNotConnected& _e) {
05438       Py_BLOCK_THREADS
05439       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
05440       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05441       PyErr_SetObject(excc, exci);
05442       Py_XDECREF(excc);
05443       Py_XDECREF(exci);
05444       return NULL;
05445     }
05446     catch(Engines::DSC::BadPortType& _e) {
05447       Py_BLOCK_THREADS
05448       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
05449       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05450       PyErr_SetObject(excc, exci);
05451       Py_XDECREF(excc);
05452       Py_XDECREF(exci);
05453       return NULL;
05454     }
05455     catch (SALOME_Exception &e) {
05456       Py_BLOCK_THREADS
05457       PyErr_SetString(PyExc_RuntimeError,e.what());
05458       return NULL;
05459     }
05460     catch (SALOME::SALOME_Exception &e) {
05461       Py_BLOCK_THREADS
05462       //This one should be converted into a python corba exception
05463       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05464       return NULL;
05465     }
05466     catch (const CORBA::SystemException& e) {
05467       Py_BLOCK_THREADS 
05468       return api->handleCxxSystemException(e);
05469     }
05470     catch(...) {
05471       Py_BLOCK_THREADS
05472       PyErr_SetString(PyExc_ValueError,"Unknown exception");
05473       return NULL;
05474     }
05475     Py_END_ALLOW_THREADS
05476   }
05477   resultobj = SWIG_Py_Void();
05478   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05479   return resultobj;
05480 fail:
05481   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05482   return NULL;
05483 }
05484 
05485 
05486 SWIGINTERN PyObject *_wrap_PySupervCompo_add_port__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05487   PyObject *resultobj = 0;
05488   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
05489   uses_port *arg2 = (uses_port *) 0 ;
05490   char *arg3 = (char *) 0 ;
05491   void *argp1 = 0 ;
05492   int res1 = 0 ;
05493   void *argp2 = 0 ;
05494   int res2 = 0 ;
05495   int res3 ;
05496   char *buf3 = 0 ;
05497   int alloc3 = 0 ;
05498   PyObject * obj0 = 0 ;
05499   PyObject * obj1 = 0 ;
05500   PyObject * obj2 = 0 ;
05501   
05502   if (!PyArg_ParseTuple(args,(char *)"OOO:PySupervCompo_add_port",&obj0,&obj1,&obj2)) SWIG_fail;
05503   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
05504   if (!SWIG_IsOK(res1)) {
05505     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_add_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
05506   }
05507   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
05508   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_uses_port, 0 |  0 );
05509   if (!SWIG_IsOK(res2)) {
05510     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_add_port" "', argument " "2"" of type '" "uses_port *""'"); 
05511   }
05512   arg2 = reinterpret_cast< uses_port * >(argp2);
05513   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
05514   if (!SWIG_IsOK(res3)) {
05515     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PySupervCompo_add_port" "', argument " "3"" of type '" "char const *""'");
05516   }
05517   arg3 = reinterpret_cast< char * >(buf3);
05518   {
05519     Py_BEGIN_ALLOW_THREADS
05520     try {
05521       (arg1)->add_port(arg2,(char const *)arg3);
05522     }
05523     catch(Engines::DSC::PortNotDefined& _e) {
05524       Py_BLOCK_THREADS
05525       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
05526       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05527       PyErr_SetObject(excc, exci);
05528       Py_XDECREF(excc);
05529       Py_XDECREF(exci);
05530       return NULL;
05531     }
05532     catch(Engines::DSC::PortNotConnected& _e) {
05533       Py_BLOCK_THREADS
05534       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
05535       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05536       PyErr_SetObject(excc, exci);
05537       Py_XDECREF(excc);
05538       Py_XDECREF(exci);
05539       return NULL;
05540     }
05541     catch(Engines::DSC::BadPortType& _e) {
05542       Py_BLOCK_THREADS
05543       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
05544       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05545       PyErr_SetObject(excc, exci);
05546       Py_XDECREF(excc);
05547       Py_XDECREF(exci);
05548       return NULL;
05549     }
05550     catch (SALOME_Exception &e) {
05551       Py_BLOCK_THREADS
05552       PyErr_SetString(PyExc_RuntimeError,e.what());
05553       return NULL;
05554     }
05555     catch (SALOME::SALOME_Exception &e) {
05556       Py_BLOCK_THREADS
05557       //This one should be converted into a python corba exception
05558       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05559       return NULL;
05560     }
05561     catch (const CORBA::SystemException& e) {
05562       Py_BLOCK_THREADS 
05563       return api->handleCxxSystemException(e);
05564     }
05565     catch(...) {
05566       Py_BLOCK_THREADS
05567       PyErr_SetString(PyExc_ValueError,"Unknown exception");
05568       return NULL;
05569     }
05570     Py_END_ALLOW_THREADS
05571   }
05572   resultobj = SWIG_Py_Void();
05573   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05574   return resultobj;
05575 fail:
05576   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05577   return NULL;
05578 }
05579 
05580 
05581 SWIGINTERN PyObject *_wrap_PySupervCompo_add_port(PyObject *self, PyObject *args) {
05582   int argc;
05583   PyObject *argv[5];
05584   int ii;
05585   
05586   if (!PyTuple_Check(args)) SWIG_fail;
05587   argc = (int)PyObject_Length(args);
05588   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
05589     argv[ii] = PyTuple_GET_ITEM(args,ii);
05590   }
05591   if (argc == 3) {
05592     int _v;
05593     void *vptr = 0;
05594     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_PySupervCompo, 0);
05595     _v = SWIG_CheckState(res);
05596     if (_v) {
05597       void *vptr = 0;
05598       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_provides_port, 0);
05599       _v = SWIG_CheckState(res);
05600       if (_v) {
05601         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
05602         _v = SWIG_CheckState(res);
05603         if (_v) {
05604           return _wrap_PySupervCompo_add_port__SWIG_2(self, args);
05605         }
05606       }
05607     }
05608   }
05609   if (argc == 3) {
05610     int _v;
05611     void *vptr = 0;
05612     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_PySupervCompo, 0);
05613     _v = SWIG_CheckState(res);
05614     if (_v) {
05615       void *vptr = 0;
05616       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_uses_port, 0);
05617       _v = SWIG_CheckState(res);
05618       if (_v) {
05619         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
05620         _v = SWIG_CheckState(res);
05621         if (_v) {
05622           return _wrap_PySupervCompo_add_port__SWIG_3(self, args);
05623         }
05624       }
05625     }
05626   }
05627   if (argc == 4) {
05628     int _v;
05629     void *vptr = 0;
05630     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_PySupervCompo, 0);
05631     _v = SWIG_CheckState(res);
05632     if (_v) {
05633       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
05634       _v = SWIG_CheckState(res);
05635       if (_v) {
05636         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
05637         _v = SWIG_CheckState(res);
05638         if (_v) {
05639           int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
05640           _v = SWIG_CheckState(res);
05641           if (_v) {
05642             return _wrap_PySupervCompo_add_port__SWIG_0(self, args);
05643           }
05644         }
05645       }
05646     }
05647   }
05648   
05649 fail:
05650   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySupervCompo_add_port'.\n"
05651     "  Possible C/C++ prototypes are:\n"
05652     "    add_port(PySupervCompo *,char const *,char const *,char const *)\n"
05653     "    add_port(PySupervCompo *,provides_port *,char const *)\n"
05654     "    add_port(PySupervCompo *,uses_port *,char const *)\n");
05655   return NULL;
05656 }
05657 
05658 
05659 SWIGINTERN PyObject *_wrap_PySupervCompo_get_provides_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05660   PyObject *resultobj = 0;
05661   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
05662   char *arg2 = (char *) 0 ;
05663   CORBA::Boolean arg3 ;
05664   void *argp1 = 0 ;
05665   int res1 = 0 ;
05666   int res2 ;
05667   char *buf2 = 0 ;
05668   int alloc2 = 0 ;
05669   PyObject * obj0 = 0 ;
05670   PyObject * obj1 = 0 ;
05671   PyObject * obj2 = 0 ;
05672   Ports::Port_ptr result;
05673   
05674   if (!PyArg_ParseTuple(args,(char *)"OOO:PySupervCompo_get_provides_port",&obj0,&obj1,&obj2)) SWIG_fail;
05675   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
05676   if (!SWIG_IsOK(res1)) {
05677     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_get_provides_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
05678   }
05679   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
05680   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05681   if (!SWIG_IsOK(res2)) {
05682     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_get_provides_port" "', argument " "2"" of type '" "char const *""'");
05683   }
05684   arg2 = reinterpret_cast< char * >(buf2);
05685   {
05686     arg3=(CORBA::Boolean)PyInt_AsLong(obj2);
05687   }
05688   {
05689     Py_BEGIN_ALLOW_THREADS
05690     try {
05691       result = (arg1)->get_provides_port((char const *)arg2,arg3);
05692     }
05693     catch(Engines::DSC::PortNotDefined& _e) {
05694       Py_BLOCK_THREADS
05695       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
05696       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05697       PyErr_SetObject(excc, exci);
05698       Py_XDECREF(excc);
05699       Py_XDECREF(exci);
05700       return NULL;
05701     }
05702     catch(Engines::DSC::PortNotConnected& _e) {
05703       Py_BLOCK_THREADS
05704       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
05705       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05706       PyErr_SetObject(excc, exci);
05707       Py_XDECREF(excc);
05708       Py_XDECREF(exci);
05709       return NULL;
05710     }
05711     catch(Engines::DSC::BadPortType& _e) {
05712       Py_BLOCK_THREADS
05713       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
05714       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05715       PyErr_SetObject(excc, exci);
05716       Py_XDECREF(excc);
05717       Py_XDECREF(exci);
05718       return NULL;
05719     }
05720     catch (SALOME_Exception &e) {
05721       Py_BLOCK_THREADS
05722       PyErr_SetString(PyExc_RuntimeError,e.what());
05723       return NULL;
05724     }
05725     catch (SALOME::SALOME_Exception &e) {
05726       Py_BLOCK_THREADS
05727       //This one should be converted into a python corba exception
05728       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05729       return NULL;
05730     }
05731     catch (const CORBA::SystemException& e) {
05732       Py_BLOCK_THREADS 
05733       return api->handleCxxSystemException(e);
05734     }
05735     catch(...) {
05736       Py_BLOCK_THREADS
05737       PyErr_SetString(PyExc_ValueError,"Unknown exception");
05738       return NULL;
05739     }
05740     Py_END_ALLOW_THREADS
05741   }
05742   {
05743     resultobj = api->cxxObjRefToPyObjRef(result, 1);
05744     //All output Ports::Port_ptr variables are duplicated by security. Need to release them for python.
05745     CORBA::release(result);
05746   }
05747   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05748   return resultobj;
05749 fail:
05750   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05751   return NULL;
05752 }
05753 
05754 
05755 SWIGINTERN PyObject *_wrap_PySupervCompo_connect_uses_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05756   PyObject *resultobj = 0;
05757   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
05758   char *arg2 = (char *) 0 ;
05759   Ports::Port_ptr arg3 ;
05760   void *argp1 = 0 ;
05761   int res1 = 0 ;
05762   int res2 ;
05763   char *buf2 = 0 ;
05764   int alloc2 = 0 ;
05765   PyObject * obj0 = 0 ;
05766   PyObject * obj1 = 0 ;
05767   PyObject * obj2 = 0 ;
05768   
05769   if (!PyArg_ParseTuple(args,(char *)"OOO:PySupervCompo_connect_uses_port",&obj0,&obj1,&obj2)) SWIG_fail;
05770   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
05771   if (!SWIG_IsOK(res1)) {
05772     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_connect_uses_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
05773   }
05774   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
05775   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05776   if (!SWIG_IsOK(res2)) {
05777     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_connect_uses_port" "', argument " "2"" of type '" "char const *""'");
05778   }
05779   arg2 = reinterpret_cast< char * >(buf2);
05780   {
05781     Py_BEGIN_ALLOW_THREADS
05782     try
05783     {
05784       CORBA::Object_var obj = api->pyObjRefToCxxObjRef(obj2,0);
05785       arg3 = Ports::Port::_narrow(obj);
05786     }
05787     catch(...)
05788     {
05789       Py_BLOCK_THREADS
05790       PyErr_SetString(PyExc_RuntimeError, "not a valid CORBA object ptr");
05791     }
05792     Py_END_ALLOW_THREADS
05793   }
05794   {
05795     Py_BEGIN_ALLOW_THREADS
05796     try {
05797       (arg1)->connect_uses_port((char const *)arg2,arg3);
05798     }
05799     catch(Engines::DSC::PortNotDefined& _e) {
05800       Py_BLOCK_THREADS
05801       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
05802       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05803       PyErr_SetObject(excc, exci);
05804       Py_XDECREF(excc);
05805       Py_XDECREF(exci);
05806       return NULL;
05807     }
05808     catch(Engines::DSC::PortNotConnected& _e) {
05809       Py_BLOCK_THREADS
05810       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
05811       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05812       PyErr_SetObject(excc, exci);
05813       Py_XDECREF(excc);
05814       Py_XDECREF(exci);
05815       return NULL;
05816     }
05817     catch(Engines::DSC::BadPortType& _e) {
05818       Py_BLOCK_THREADS
05819       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
05820       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05821       PyErr_SetObject(excc, exci);
05822       Py_XDECREF(excc);
05823       Py_XDECREF(exci);
05824       return NULL;
05825     }
05826     catch (SALOME_Exception &e) {
05827       Py_BLOCK_THREADS
05828       PyErr_SetString(PyExc_RuntimeError,e.what());
05829       return NULL;
05830     }
05831     catch (SALOME::SALOME_Exception &e) {
05832       Py_BLOCK_THREADS
05833       //This one should be converted into a python corba exception
05834       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05835       return NULL;
05836     }
05837     catch (const CORBA::SystemException& e) {
05838       Py_BLOCK_THREADS 
05839       return api->handleCxxSystemException(e);
05840     }
05841     catch(...) {
05842       Py_BLOCK_THREADS
05843       PyErr_SetString(PyExc_ValueError,"Unknown exception");
05844       return NULL;
05845     }
05846     Py_END_ALLOW_THREADS
05847   }
05848   resultobj = SWIG_Py_Void();
05849   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05850   {
05851     CORBA::release(arg3);
05852   }
05853   return resultobj;
05854 fail:
05855   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05856   {
05857     CORBA::release(arg3);
05858   }
05859   return NULL;
05860 }
05861 
05862 
05863 SWIGINTERN PyObject *_wrap_PySupervCompo_connect_provides_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05864   PyObject *resultobj = 0;
05865   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
05866   char *arg2 = (char *) 0 ;
05867   void *argp1 = 0 ;
05868   int res1 = 0 ;
05869   int res2 ;
05870   char *buf2 = 0 ;
05871   int alloc2 = 0 ;
05872   PyObject * obj0 = 0 ;
05873   PyObject * obj1 = 0 ;
05874   
05875   if (!PyArg_ParseTuple(args,(char *)"OO:PySupervCompo_connect_provides_port",&obj0,&obj1)) SWIG_fail;
05876   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
05877   if (!SWIG_IsOK(res1)) {
05878     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_connect_provides_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
05879   }
05880   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
05881   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05882   if (!SWIG_IsOK(res2)) {
05883     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_connect_provides_port" "', argument " "2"" of type '" "char const *""'");
05884   }
05885   arg2 = reinterpret_cast< char * >(buf2);
05886   {
05887     Py_BEGIN_ALLOW_THREADS
05888     try {
05889       (arg1)->connect_provides_port((char const *)arg2);
05890     }
05891     catch(Engines::DSC::PortNotDefined& _e) {
05892       Py_BLOCK_THREADS
05893       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
05894       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05895       PyErr_SetObject(excc, exci);
05896       Py_XDECREF(excc);
05897       Py_XDECREF(exci);
05898       return NULL;
05899     }
05900     catch(Engines::DSC::PortNotConnected& _e) {
05901       Py_BLOCK_THREADS
05902       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
05903       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05904       PyErr_SetObject(excc, exci);
05905       Py_XDECREF(excc);
05906       Py_XDECREF(exci);
05907       return NULL;
05908     }
05909     catch(Engines::DSC::BadPortType& _e) {
05910       Py_BLOCK_THREADS
05911       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
05912       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05913       PyErr_SetObject(excc, exci);
05914       Py_XDECREF(excc);
05915       Py_XDECREF(exci);
05916       return NULL;
05917     }
05918     catch (SALOME_Exception &e) {
05919       Py_BLOCK_THREADS
05920       PyErr_SetString(PyExc_RuntimeError,e.what());
05921       return NULL;
05922     }
05923     catch (SALOME::SALOME_Exception &e) {
05924       Py_BLOCK_THREADS
05925       //This one should be converted into a python corba exception
05926       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05927       return NULL;
05928     }
05929     catch (const CORBA::SystemException& e) {
05930       Py_BLOCK_THREADS 
05931       return api->handleCxxSystemException(e);
05932     }
05933     catch(...) {
05934       Py_BLOCK_THREADS
05935       PyErr_SetString(PyExc_ValueError,"Unknown exception");
05936       return NULL;
05937     }
05938     Py_END_ALLOW_THREADS
05939   }
05940   resultobj = SWIG_Py_Void();
05941   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05942   return resultobj;
05943 fail:
05944   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05945   return NULL;
05946 }
05947 
05948 
05949 SWIGINTERN PyObject *_wrap_PySupervCompo_disconnect_provides_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05950   PyObject *resultobj = 0;
05951   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
05952   char *arg2 = (char *) 0 ;
05953   Engines::DSC::Message arg3 ;
05954   void *argp1 = 0 ;
05955   int res1 = 0 ;
05956   int res2 ;
05957   char *buf2 = 0 ;
05958   int alloc2 = 0 ;
05959   int val3 ;
05960   int ecode3 = 0 ;
05961   PyObject * obj0 = 0 ;
05962   PyObject * obj1 = 0 ;
05963   PyObject * obj2 = 0 ;
05964   
05965   if (!PyArg_ParseTuple(args,(char *)"OOO:PySupervCompo_disconnect_provides_port",&obj0,&obj1,&obj2)) SWIG_fail;
05966   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
05967   if (!SWIG_IsOK(res1)) {
05968     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_disconnect_provides_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
05969   }
05970   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
05971   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05972   if (!SWIG_IsOK(res2)) {
05973     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_disconnect_provides_port" "', argument " "2"" of type '" "char const *""'");
05974   }
05975   arg2 = reinterpret_cast< char * >(buf2);
05976   ecode3 = SWIG_AsVal_int(obj2, &val3);
05977   if (!SWIG_IsOK(ecode3)) {
05978     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PySupervCompo_disconnect_provides_port" "', argument " "3"" of type '" "Engines::DSC::Message""'");
05979   } 
05980   arg3 = static_cast< Engines::DSC::Message >(val3);
05981   {
05982     Py_BEGIN_ALLOW_THREADS
05983     try {
05984       (arg1)->disconnect_provides_port((char const *)arg2,arg3);
05985     }
05986     catch(Engines::DSC::PortNotDefined& _e) {
05987       Py_BLOCK_THREADS
05988       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
05989       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05990       PyErr_SetObject(excc, exci);
05991       Py_XDECREF(excc);
05992       Py_XDECREF(exci);
05993       return NULL;
05994     }
05995     catch(Engines::DSC::PortNotConnected& _e) {
05996       Py_BLOCK_THREADS
05997       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
05998       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
05999       PyErr_SetObject(excc, exci);
06000       Py_XDECREF(excc);
06001       Py_XDECREF(exci);
06002       return NULL;
06003     }
06004     catch(Engines::DSC::BadPortType& _e) {
06005       Py_BLOCK_THREADS
06006       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
06007       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06008       PyErr_SetObject(excc, exci);
06009       Py_XDECREF(excc);
06010       Py_XDECREF(exci);
06011       return NULL;
06012     }
06013     catch (SALOME_Exception &e) {
06014       Py_BLOCK_THREADS
06015       PyErr_SetString(PyExc_RuntimeError,e.what());
06016       return NULL;
06017     }
06018     catch (SALOME::SALOME_Exception &e) {
06019       Py_BLOCK_THREADS
06020       //This one should be converted into a python corba exception
06021       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06022       return NULL;
06023     }
06024     catch (const CORBA::SystemException& e) {
06025       Py_BLOCK_THREADS 
06026       return api->handleCxxSystemException(e);
06027     }
06028     catch(...) {
06029       Py_BLOCK_THREADS
06030       PyErr_SetString(PyExc_ValueError,"Unknown exception");
06031       return NULL;
06032     }
06033     Py_END_ALLOW_THREADS
06034   }
06035   resultobj = SWIG_Py_Void();
06036   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06037   return resultobj;
06038 fail:
06039   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06040   return NULL;
06041 }
06042 
06043 
06044 SWIGINTERN PyObject *_wrap_PySupervCompo_disconnect_uses_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06045   PyObject *resultobj = 0;
06046   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
06047   char *arg2 = (char *) 0 ;
06048   Ports::Port_ptr arg3 ;
06049   Engines::DSC::Message arg4 ;
06050   void *argp1 = 0 ;
06051   int res1 = 0 ;
06052   int res2 ;
06053   char *buf2 = 0 ;
06054   int alloc2 = 0 ;
06055   int val4 ;
06056   int ecode4 = 0 ;
06057   PyObject * obj0 = 0 ;
06058   PyObject * obj1 = 0 ;
06059   PyObject * obj2 = 0 ;
06060   PyObject * obj3 = 0 ;
06061   
06062   if (!PyArg_ParseTuple(args,(char *)"OOOO:PySupervCompo_disconnect_uses_port",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
06063   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
06064   if (!SWIG_IsOK(res1)) {
06065     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_disconnect_uses_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
06066   }
06067   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
06068   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
06069   if (!SWIG_IsOK(res2)) {
06070     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_disconnect_uses_port" "', argument " "2"" of type '" "char const *""'");
06071   }
06072   arg2 = reinterpret_cast< char * >(buf2);
06073   {
06074     Py_BEGIN_ALLOW_THREADS
06075     try
06076     {
06077       CORBA::Object_var obj = api->pyObjRefToCxxObjRef(obj2,0);
06078       arg3 = Ports::Port::_narrow(obj);
06079     }
06080     catch(...)
06081     {
06082       Py_BLOCK_THREADS
06083       PyErr_SetString(PyExc_RuntimeError, "not a valid CORBA object ptr");
06084     }
06085     Py_END_ALLOW_THREADS
06086   }
06087   ecode4 = SWIG_AsVal_int(obj3, &val4);
06088   if (!SWIG_IsOK(ecode4)) {
06089     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PySupervCompo_disconnect_uses_port" "', argument " "4"" of type '" "Engines::DSC::Message""'");
06090   } 
06091   arg4 = static_cast< Engines::DSC::Message >(val4);
06092   {
06093     Py_BEGIN_ALLOW_THREADS
06094     try {
06095       (arg1)->disconnect_uses_port((char const *)arg2,arg3,arg4);
06096     }
06097     catch(Engines::DSC::PortNotDefined& _e) {
06098       Py_BLOCK_THREADS
06099       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
06100       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06101       PyErr_SetObject(excc, exci);
06102       Py_XDECREF(excc);
06103       Py_XDECREF(exci);
06104       return NULL;
06105     }
06106     catch(Engines::DSC::PortNotConnected& _e) {
06107       Py_BLOCK_THREADS
06108       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
06109       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06110       PyErr_SetObject(excc, exci);
06111       Py_XDECREF(excc);
06112       Py_XDECREF(exci);
06113       return NULL;
06114     }
06115     catch(Engines::DSC::BadPortType& _e) {
06116       Py_BLOCK_THREADS
06117       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
06118       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06119       PyErr_SetObject(excc, exci);
06120       Py_XDECREF(excc);
06121       Py_XDECREF(exci);
06122       return NULL;
06123     }
06124     catch (SALOME_Exception &e) {
06125       Py_BLOCK_THREADS
06126       PyErr_SetString(PyExc_RuntimeError,e.what());
06127       return NULL;
06128     }
06129     catch (SALOME::SALOME_Exception &e) {
06130       Py_BLOCK_THREADS
06131       //This one should be converted into a python corba exception
06132       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06133       return NULL;
06134     }
06135     catch (const CORBA::SystemException& e) {
06136       Py_BLOCK_THREADS 
06137       return api->handleCxxSystemException(e);
06138     }
06139     catch(...) {
06140       Py_BLOCK_THREADS
06141       PyErr_SetString(PyExc_ValueError,"Unknown exception");
06142       return NULL;
06143     }
06144     Py_END_ALLOW_THREADS
06145   }
06146   resultobj = SWIG_Py_Void();
06147   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06148   {
06149     CORBA::release(arg3);
06150   }
06151   return resultobj;
06152 fail:
06153   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06154   {
06155     CORBA::release(arg3);
06156   }
06157   return NULL;
06158 }
06159 
06160 
06161 SWIGINTERN PyObject *_wrap_PySupervCompo_get_port_properties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06162   PyObject *resultobj = 0;
06163   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
06164   char *arg2 = (char *) 0 ;
06165   void *argp1 = 0 ;
06166   int res1 = 0 ;
06167   int res2 ;
06168   char *buf2 = 0 ;
06169   int alloc2 = 0 ;
06170   PyObject * obj0 = 0 ;
06171   PyObject * obj1 = 0 ;
06172   Ports::PortProperties_ptr result;
06173   
06174   if (!PyArg_ParseTuple(args,(char *)"OO:PySupervCompo_get_port_properties",&obj0,&obj1)) SWIG_fail;
06175   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
06176   if (!SWIG_IsOK(res1)) {
06177     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_get_port_properties" "', argument " "1"" of type '" "PySupervCompo *""'"); 
06178   }
06179   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
06180   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
06181   if (!SWIG_IsOK(res2)) {
06182     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_get_port_properties" "', argument " "2"" of type '" "char const *""'");
06183   }
06184   arg2 = reinterpret_cast< char * >(buf2);
06185   {
06186     Py_BEGIN_ALLOW_THREADS
06187     try {
06188       result = (arg1)->get_port_properties((char const *)arg2);
06189     }
06190     catch(Engines::DSC::PortNotDefined& _e) {
06191       Py_BLOCK_THREADS
06192       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
06193       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06194       PyErr_SetObject(excc, exci);
06195       Py_XDECREF(excc);
06196       Py_XDECREF(exci);
06197       return NULL;
06198     }
06199     catch(Engines::DSC::PortNotConnected& _e) {
06200       Py_BLOCK_THREADS
06201       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
06202       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06203       PyErr_SetObject(excc, exci);
06204       Py_XDECREF(excc);
06205       Py_XDECREF(exci);
06206       return NULL;
06207     }
06208     catch(Engines::DSC::BadPortType& _e) {
06209       Py_BLOCK_THREADS
06210       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
06211       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06212       PyErr_SetObject(excc, exci);
06213       Py_XDECREF(excc);
06214       Py_XDECREF(exci);
06215       return NULL;
06216     }
06217     catch (SALOME_Exception &e) {
06218       Py_BLOCK_THREADS
06219       PyErr_SetString(PyExc_RuntimeError,e.what());
06220       return NULL;
06221     }
06222     catch (SALOME::SALOME_Exception &e) {
06223       Py_BLOCK_THREADS
06224       //This one should be converted into a python corba exception
06225       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06226       return NULL;
06227     }
06228     catch (const CORBA::SystemException& e) {
06229       Py_BLOCK_THREADS 
06230       return api->handleCxxSystemException(e);
06231     }
06232     catch(...) {
06233       Py_BLOCK_THREADS
06234       PyErr_SetString(PyExc_ValueError,"Unknown exception");
06235       return NULL;
06236     }
06237     Py_END_ALLOW_THREADS
06238   }
06239   {
06240     resultobj = api->cxxObjRefToPyObjRef(result, 1);
06241     //the _ptr is duplicated by the routine called. 
06242     //Need to release it for Python because the call to cxxObjRefToPyObjRef has created another ref with a count of 1
06243     CORBA::release(result);
06244   }
06245   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06246   return resultobj;
06247 fail:
06248   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06249   return NULL;
06250 }
06251 
06252 
06253 SWIGINTERN PyObject *_wrap_PySupervCompo_getInputFileToService(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06254   PyObject *resultobj = 0;
06255   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
06256   char *arg2 = (char *) 0 ;
06257   char *arg3 = (char *) 0 ;
06258   void *argp1 = 0 ;
06259   int res1 = 0 ;
06260   int res2 ;
06261   char *buf2 = 0 ;
06262   int alloc2 = 0 ;
06263   int res3 ;
06264   char *buf3 = 0 ;
06265   int alloc3 = 0 ;
06266   PyObject * obj0 = 0 ;
06267   PyObject * obj1 = 0 ;
06268   PyObject * obj2 = 0 ;
06269   Engines::Salome_file_ptr result;
06270   
06271   if (!PyArg_ParseTuple(args,(char *)"OOO:PySupervCompo_getInputFileToService",&obj0,&obj1,&obj2)) SWIG_fail;
06272   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
06273   if (!SWIG_IsOK(res1)) {
06274     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_getInputFileToService" "', argument " "1"" of type '" "PySupervCompo *""'"); 
06275   }
06276   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
06277   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
06278   if (!SWIG_IsOK(res2)) {
06279     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_getInputFileToService" "', argument " "2"" of type '" "char const *""'");
06280   }
06281   arg2 = reinterpret_cast< char * >(buf2);
06282   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
06283   if (!SWIG_IsOK(res3)) {
06284     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PySupervCompo_getInputFileToService" "', argument " "3"" of type '" "char const *""'");
06285   }
06286   arg3 = reinterpret_cast< char * >(buf3);
06287   {
06288     Py_BEGIN_ALLOW_THREADS
06289     try {
06290       result = (arg1)->getInputFileToService((char const *)arg2,(char const *)arg3);
06291     }
06292     catch(Engines::DSC::PortNotDefined& _e) {
06293       Py_BLOCK_THREADS
06294       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
06295       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06296       PyErr_SetObject(excc, exci);
06297       Py_XDECREF(excc);
06298       Py_XDECREF(exci);
06299       return NULL;
06300     }
06301     catch(Engines::DSC::PortNotConnected& _e) {
06302       Py_BLOCK_THREADS
06303       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
06304       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06305       PyErr_SetObject(excc, exci);
06306       Py_XDECREF(excc);
06307       Py_XDECREF(exci);
06308       return NULL;
06309     }
06310     catch(Engines::DSC::BadPortType& _e) {
06311       Py_BLOCK_THREADS
06312       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
06313       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06314       PyErr_SetObject(excc, exci);
06315       Py_XDECREF(excc);
06316       Py_XDECREF(exci);
06317       return NULL;
06318     }
06319     catch (SALOME_Exception &e) {
06320       Py_BLOCK_THREADS
06321       PyErr_SetString(PyExc_RuntimeError,e.what());
06322       return NULL;
06323     }
06324     catch (SALOME::SALOME_Exception &e) {
06325       Py_BLOCK_THREADS
06326       //This one should be converted into a python corba exception
06327       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06328       return NULL;
06329     }
06330     catch (const CORBA::SystemException& e) {
06331       Py_BLOCK_THREADS 
06332       return api->handleCxxSystemException(e);
06333     }
06334     catch(...) {
06335       Py_BLOCK_THREADS
06336       PyErr_SetString(PyExc_ValueError,"Unknown exception");
06337       return NULL;
06338     }
06339     Py_END_ALLOW_THREADS
06340   }
06341   {
06342     resultobj = api->cxxObjRefToPyObjRef(result, 1);
06343     //the _ptr is duplicated by the routine called. 
06344     //Need to release it for Python because the call to cxxObjRefToPyObjRef has created another ref with a count of 1
06345     CORBA::release(result);
06346   }
06347   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06348   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
06349   return resultobj;
06350 fail:
06351   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06352   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
06353   return NULL;
06354 }
06355 
06356 
06357 SWIGINTERN PyObject *_wrap_PySupervCompo_checkInputFilesToService(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06358   PyObject *resultobj = 0;
06359   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
06360   char *arg2 = (char *) 0 ;
06361   void *argp1 = 0 ;
06362   int res1 = 0 ;
06363   int res2 ;
06364   char *buf2 = 0 ;
06365   int alloc2 = 0 ;
06366   PyObject * obj0 = 0 ;
06367   PyObject * obj1 = 0 ;
06368   
06369   if (!PyArg_ParseTuple(args,(char *)"OO:PySupervCompo_checkInputFilesToService",&obj0,&obj1)) SWIG_fail;
06370   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
06371   if (!SWIG_IsOK(res1)) {
06372     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_checkInputFilesToService" "', argument " "1"" of type '" "PySupervCompo *""'"); 
06373   }
06374   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
06375   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
06376   if (!SWIG_IsOK(res2)) {
06377     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_checkInputFilesToService" "', argument " "2"" of type '" "char const *""'");
06378   }
06379   arg2 = reinterpret_cast< char * >(buf2);
06380   {
06381     Py_BEGIN_ALLOW_THREADS
06382     try {
06383       (arg1)->checkInputFilesToService((char const *)arg2);
06384     }
06385     catch(Engines::DSC::PortNotDefined& _e) {
06386       Py_BLOCK_THREADS
06387       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
06388       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06389       PyErr_SetObject(excc, exci);
06390       Py_XDECREF(excc);
06391       Py_XDECREF(exci);
06392       return NULL;
06393     }
06394     catch(Engines::DSC::PortNotConnected& _e) {
06395       Py_BLOCK_THREADS
06396       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
06397       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06398       PyErr_SetObject(excc, exci);
06399       Py_XDECREF(excc);
06400       Py_XDECREF(exci);
06401       return NULL;
06402     }
06403     catch(Engines::DSC::BadPortType& _e) {
06404       Py_BLOCK_THREADS
06405       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
06406       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06407       PyErr_SetObject(excc, exci);
06408       Py_XDECREF(excc);
06409       Py_XDECREF(exci);
06410       return NULL;
06411     }
06412     catch (SALOME_Exception &e) {
06413       Py_BLOCK_THREADS
06414       PyErr_SetString(PyExc_RuntimeError,e.what());
06415       return NULL;
06416     }
06417     catch (SALOME::SALOME_Exception &e) {
06418       Py_BLOCK_THREADS
06419       //This one should be converted into a python corba exception
06420       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06421       return NULL;
06422     }
06423     catch (const CORBA::SystemException& e) {
06424       Py_BLOCK_THREADS 
06425       return api->handleCxxSystemException(e);
06426     }
06427     catch(...) {
06428       Py_BLOCK_THREADS
06429       PyErr_SetString(PyExc_ValueError,"Unknown exception");
06430       return NULL;
06431     }
06432     Py_END_ALLOW_THREADS
06433   }
06434   resultobj = SWIG_Py_Void();
06435   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06436   return resultobj;
06437 fail:
06438   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06439   return NULL;
06440 }
06441 
06442 
06443 SWIGINTERN PyObject *_wrap_PySupervCompo_setInputFileToService(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06444   PyObject *resultobj = 0;
06445   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
06446   char *arg2 = (char *) 0 ;
06447   char *arg3 = (char *) 0 ;
06448   void *argp1 = 0 ;
06449   int res1 = 0 ;
06450   int res2 ;
06451   char *buf2 = 0 ;
06452   int alloc2 = 0 ;
06453   int res3 ;
06454   char *buf3 = 0 ;
06455   int alloc3 = 0 ;
06456   PyObject * obj0 = 0 ;
06457   PyObject * obj1 = 0 ;
06458   PyObject * obj2 = 0 ;
06459   Engines::Salome_file_ptr result;
06460   
06461   if (!PyArg_ParseTuple(args,(char *)"OOO:PySupervCompo_setInputFileToService",&obj0,&obj1,&obj2)) SWIG_fail;
06462   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
06463   if (!SWIG_IsOK(res1)) {
06464     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_setInputFileToService" "', argument " "1"" of type '" "PySupervCompo *""'"); 
06465   }
06466   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
06467   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
06468   if (!SWIG_IsOK(res2)) {
06469     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_setInputFileToService" "', argument " "2"" of type '" "char const *""'");
06470   }
06471   arg2 = reinterpret_cast< char * >(buf2);
06472   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
06473   if (!SWIG_IsOK(res3)) {
06474     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PySupervCompo_setInputFileToService" "', argument " "3"" of type '" "char const *""'");
06475   }
06476   arg3 = reinterpret_cast< char * >(buf3);
06477   {
06478     Py_BEGIN_ALLOW_THREADS
06479     try {
06480       result = (arg1)->setInputFileToService((char const *)arg2,(char const *)arg3);
06481     }
06482     catch(Engines::DSC::PortNotDefined& _e) {
06483       Py_BLOCK_THREADS
06484       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
06485       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06486       PyErr_SetObject(excc, exci);
06487       Py_XDECREF(excc);
06488       Py_XDECREF(exci);
06489       return NULL;
06490     }
06491     catch(Engines::DSC::PortNotConnected& _e) {
06492       Py_BLOCK_THREADS
06493       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
06494       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06495       PyErr_SetObject(excc, exci);
06496       Py_XDECREF(excc);
06497       Py_XDECREF(exci);
06498       return NULL;
06499     }
06500     catch(Engines::DSC::BadPortType& _e) {
06501       Py_BLOCK_THREADS
06502       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
06503       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06504       PyErr_SetObject(excc, exci);
06505       Py_XDECREF(excc);
06506       Py_XDECREF(exci);
06507       return NULL;
06508     }
06509     catch (SALOME_Exception &e) {
06510       Py_BLOCK_THREADS
06511       PyErr_SetString(PyExc_RuntimeError,e.what());
06512       return NULL;
06513     }
06514     catch (SALOME::SALOME_Exception &e) {
06515       Py_BLOCK_THREADS
06516       //This one should be converted into a python corba exception
06517       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06518       return NULL;
06519     }
06520     catch (const CORBA::SystemException& e) {
06521       Py_BLOCK_THREADS 
06522       return api->handleCxxSystemException(e);
06523     }
06524     catch(...) {
06525       Py_BLOCK_THREADS
06526       PyErr_SetString(PyExc_ValueError,"Unknown exception");
06527       return NULL;
06528     }
06529     Py_END_ALLOW_THREADS
06530   }
06531   {
06532     resultobj = api->cxxObjRefToPyObjRef(result, 1);
06533     //the _ptr is duplicated by the routine called. 
06534     //Need to release it for Python because the call to cxxObjRefToPyObjRef has created another ref with a count of 1
06535     CORBA::release(result);
06536   }
06537   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06538   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
06539   return resultobj;
06540 fail:
06541   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06542   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
06543   return NULL;
06544 }
06545 
06546 
06547 SWIGINTERN PyObject *_wrap_PySupervCompo_getOutputFileToService(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06548   PyObject *resultobj = 0;
06549   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
06550   char *arg2 = (char *) 0 ;
06551   char *arg3 = (char *) 0 ;
06552   void *argp1 = 0 ;
06553   int res1 = 0 ;
06554   int res2 ;
06555   char *buf2 = 0 ;
06556   int alloc2 = 0 ;
06557   int res3 ;
06558   char *buf3 = 0 ;
06559   int alloc3 = 0 ;
06560   PyObject * obj0 = 0 ;
06561   PyObject * obj1 = 0 ;
06562   PyObject * obj2 = 0 ;
06563   Engines::Salome_file_ptr result;
06564   
06565   if (!PyArg_ParseTuple(args,(char *)"OOO:PySupervCompo_getOutputFileToService",&obj0,&obj1,&obj2)) SWIG_fail;
06566   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
06567   if (!SWIG_IsOK(res1)) {
06568     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_getOutputFileToService" "', argument " "1"" of type '" "PySupervCompo *""'"); 
06569   }
06570   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
06571   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
06572   if (!SWIG_IsOK(res2)) {
06573     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_getOutputFileToService" "', argument " "2"" of type '" "char const *""'");
06574   }
06575   arg2 = reinterpret_cast< char * >(buf2);
06576   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
06577   if (!SWIG_IsOK(res3)) {
06578     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PySupervCompo_getOutputFileToService" "', argument " "3"" of type '" "char const *""'");
06579   }
06580   arg3 = reinterpret_cast< char * >(buf3);
06581   {
06582     Py_BEGIN_ALLOW_THREADS
06583     try {
06584       result = (arg1)->getOutputFileToService((char const *)arg2,(char const *)arg3);
06585     }
06586     catch(Engines::DSC::PortNotDefined& _e) {
06587       Py_BLOCK_THREADS
06588       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
06589       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06590       PyErr_SetObject(excc, exci);
06591       Py_XDECREF(excc);
06592       Py_XDECREF(exci);
06593       return NULL;
06594     }
06595     catch(Engines::DSC::PortNotConnected& _e) {
06596       Py_BLOCK_THREADS
06597       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
06598       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06599       PyErr_SetObject(excc, exci);
06600       Py_XDECREF(excc);
06601       Py_XDECREF(exci);
06602       return NULL;
06603     }
06604     catch(Engines::DSC::BadPortType& _e) {
06605       Py_BLOCK_THREADS
06606       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
06607       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06608       PyErr_SetObject(excc, exci);
06609       Py_XDECREF(excc);
06610       Py_XDECREF(exci);
06611       return NULL;
06612     }
06613     catch (SALOME_Exception &e) {
06614       Py_BLOCK_THREADS
06615       PyErr_SetString(PyExc_RuntimeError,e.what());
06616       return NULL;
06617     }
06618     catch (SALOME::SALOME_Exception &e) {
06619       Py_BLOCK_THREADS
06620       //This one should be converted into a python corba exception
06621       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06622       return NULL;
06623     }
06624     catch (const CORBA::SystemException& e) {
06625       Py_BLOCK_THREADS 
06626       return api->handleCxxSystemException(e);
06627     }
06628     catch(...) {
06629       Py_BLOCK_THREADS
06630       PyErr_SetString(PyExc_ValueError,"Unknown exception");
06631       return NULL;
06632     }
06633     Py_END_ALLOW_THREADS
06634   }
06635   {
06636     resultobj = api->cxxObjRefToPyObjRef(result, 1);
06637     //the _ptr is duplicated by the routine called. 
06638     //Need to release it for Python because the call to cxxObjRefToPyObjRef has created another ref with a count of 1
06639     CORBA::release(result);
06640   }
06641   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06642   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
06643   return resultobj;
06644 fail:
06645   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06646   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
06647   return NULL;
06648 }
06649 
06650 
06651 SWIGINTERN PyObject *_wrap_PySupervCompo_checkOutputFilesToService(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06652   PyObject *resultobj = 0;
06653   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
06654   char *arg2 = (char *) 0 ;
06655   void *argp1 = 0 ;
06656   int res1 = 0 ;
06657   int res2 ;
06658   char *buf2 = 0 ;
06659   int alloc2 = 0 ;
06660   PyObject * obj0 = 0 ;
06661   PyObject * obj1 = 0 ;
06662   
06663   if (!PyArg_ParseTuple(args,(char *)"OO:PySupervCompo_checkOutputFilesToService",&obj0,&obj1)) SWIG_fail;
06664   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
06665   if (!SWIG_IsOK(res1)) {
06666     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_checkOutputFilesToService" "', argument " "1"" of type '" "PySupervCompo *""'"); 
06667   }
06668   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
06669   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
06670   if (!SWIG_IsOK(res2)) {
06671     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_checkOutputFilesToService" "', argument " "2"" of type '" "char const *""'");
06672   }
06673   arg2 = reinterpret_cast< char * >(buf2);
06674   {
06675     Py_BEGIN_ALLOW_THREADS
06676     try {
06677       (arg1)->checkOutputFilesToService((char const *)arg2);
06678     }
06679     catch(Engines::DSC::PortNotDefined& _e) {
06680       Py_BLOCK_THREADS
06681       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
06682       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06683       PyErr_SetObject(excc, exci);
06684       Py_XDECREF(excc);
06685       Py_XDECREF(exci);
06686       return NULL;
06687     }
06688     catch(Engines::DSC::PortNotConnected& _e) {
06689       Py_BLOCK_THREADS
06690       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
06691       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06692       PyErr_SetObject(excc, exci);
06693       Py_XDECREF(excc);
06694       Py_XDECREF(exci);
06695       return NULL;
06696     }
06697     catch(Engines::DSC::BadPortType& _e) {
06698       Py_BLOCK_THREADS
06699       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
06700       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06701       PyErr_SetObject(excc, exci);
06702       Py_XDECREF(excc);
06703       Py_XDECREF(exci);
06704       return NULL;
06705     }
06706     catch (SALOME_Exception &e) {
06707       Py_BLOCK_THREADS
06708       PyErr_SetString(PyExc_RuntimeError,e.what());
06709       return NULL;
06710     }
06711     catch (SALOME::SALOME_Exception &e) {
06712       Py_BLOCK_THREADS
06713       //This one should be converted into a python corba exception
06714       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06715       return NULL;
06716     }
06717     catch (const CORBA::SystemException& e) {
06718       Py_BLOCK_THREADS 
06719       return api->handleCxxSystemException(e);
06720     }
06721     catch(...) {
06722       Py_BLOCK_THREADS
06723       PyErr_SetString(PyExc_ValueError,"Unknown exception");
06724       return NULL;
06725     }
06726     Py_END_ALLOW_THREADS
06727   }
06728   resultobj = SWIG_Py_Void();
06729   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06730   return resultobj;
06731 fail:
06732   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06733   return NULL;
06734 }
06735 
06736 
06737 SWIGINTERN PyObject *_wrap_PySupervCompo_setOutputFileToService(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06738   PyObject *resultobj = 0;
06739   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
06740   char *arg2 = (char *) 0 ;
06741   char *arg3 = (char *) 0 ;
06742   void *argp1 = 0 ;
06743   int res1 = 0 ;
06744   int res2 ;
06745   char *buf2 = 0 ;
06746   int alloc2 = 0 ;
06747   int res3 ;
06748   char *buf3 = 0 ;
06749   int alloc3 = 0 ;
06750   PyObject * obj0 = 0 ;
06751   PyObject * obj1 = 0 ;
06752   PyObject * obj2 = 0 ;
06753   Engines::Salome_file_ptr result;
06754   
06755   if (!PyArg_ParseTuple(args,(char *)"OOO:PySupervCompo_setOutputFileToService",&obj0,&obj1,&obj2)) SWIG_fail;
06756   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
06757   if (!SWIG_IsOK(res1)) {
06758     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_setOutputFileToService" "', argument " "1"" of type '" "PySupervCompo *""'"); 
06759   }
06760   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
06761   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
06762   if (!SWIG_IsOK(res2)) {
06763     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_setOutputFileToService" "', argument " "2"" of type '" "char const *""'");
06764   }
06765   arg2 = reinterpret_cast< char * >(buf2);
06766   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
06767   if (!SWIG_IsOK(res3)) {
06768     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PySupervCompo_setOutputFileToService" "', argument " "3"" of type '" "char const *""'");
06769   }
06770   arg3 = reinterpret_cast< char * >(buf3);
06771   {
06772     Py_BEGIN_ALLOW_THREADS
06773     try {
06774       result = (arg1)->setOutputFileToService((char const *)arg2,(char const *)arg3);
06775     }
06776     catch(Engines::DSC::PortNotDefined& _e) {
06777       Py_BLOCK_THREADS
06778       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
06779       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06780       PyErr_SetObject(excc, exci);
06781       Py_XDECREF(excc);
06782       Py_XDECREF(exci);
06783       return NULL;
06784     }
06785     catch(Engines::DSC::PortNotConnected& _e) {
06786       Py_BLOCK_THREADS
06787       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
06788       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06789       PyErr_SetObject(excc, exci);
06790       Py_XDECREF(excc);
06791       Py_XDECREF(exci);
06792       return NULL;
06793     }
06794     catch(Engines::DSC::BadPortType& _e) {
06795       Py_BLOCK_THREADS
06796       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
06797       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06798       PyErr_SetObject(excc, exci);
06799       Py_XDECREF(excc);
06800       Py_XDECREF(exci);
06801       return NULL;
06802     }
06803     catch (SALOME_Exception &e) {
06804       Py_BLOCK_THREADS
06805       PyErr_SetString(PyExc_RuntimeError,e.what());
06806       return NULL;
06807     }
06808     catch (SALOME::SALOME_Exception &e) {
06809       Py_BLOCK_THREADS
06810       //This one should be converted into a python corba exception
06811       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06812       return NULL;
06813     }
06814     catch (const CORBA::SystemException& e) {
06815       Py_BLOCK_THREADS 
06816       return api->handleCxxSystemException(e);
06817     }
06818     catch(...) {
06819       Py_BLOCK_THREADS
06820       PyErr_SetString(PyExc_ValueError,"Unknown exception");
06821       return NULL;
06822     }
06823     Py_END_ALLOW_THREADS
06824   }
06825   {
06826     resultobj = api->cxxObjRefToPyObjRef(result, 1);
06827     //the _ptr is duplicated by the routine called. 
06828     //Need to release it for Python because the call to cxxObjRefToPyObjRef has created another ref with a count of 1
06829     CORBA::release(result);
06830   }
06831   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06832   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
06833   return resultobj;
06834 fail:
06835   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
06836   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
06837   return NULL;
06838 }
06839 
06840 
06841 SWIGINTERN PyObject *_wrap_PySupervCompo_add_provides_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06842   PyObject *resultobj = 0;
06843   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
06844   Ports::Port_ptr arg2 ;
06845   char *arg3 = (char *) 0 ;
06846   Ports::PortProperties_ptr arg4 ;
06847   void *argp1 = 0 ;
06848   int res1 = 0 ;
06849   int res3 ;
06850   char *buf3 = 0 ;
06851   int alloc3 = 0 ;
06852   PyObject * obj0 = 0 ;
06853   PyObject * obj1 = 0 ;
06854   PyObject * obj2 = 0 ;
06855   PyObject * obj3 = 0 ;
06856   
06857   if (!PyArg_ParseTuple(args,(char *)"OOOO:PySupervCompo_add_provides_port",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
06858   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
06859   if (!SWIG_IsOK(res1)) {
06860     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_add_provides_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
06861   }
06862   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
06863   {
06864     Py_BEGIN_ALLOW_THREADS
06865     try
06866     {
06867       CORBA::Object_var obj = api->pyObjRefToCxxObjRef(obj1,0);
06868       arg2 = Ports::Port::_narrow(obj);
06869     }
06870     catch(...)
06871     {
06872       Py_BLOCK_THREADS
06873       PyErr_SetString(PyExc_RuntimeError, "not a valid CORBA object ptr");
06874     }
06875     Py_END_ALLOW_THREADS
06876   }
06877   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
06878   if (!SWIG_IsOK(res3)) {
06879     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PySupervCompo_add_provides_port" "', argument " "3"" of type '" "char const *""'");
06880   }
06881   arg3 = reinterpret_cast< char * >(buf3);
06882   {
06883     Py_BEGIN_ALLOW_THREADS
06884     try
06885     {
06886       CORBA::Object_var obj = api->pyObjRefToCxxObjRef(obj3,0);
06887       arg4 = Ports::PortProperties::_narrow(obj);
06888     }
06889     catch(...)
06890     {
06891       Py_BLOCK_THREADS
06892       PyErr_SetString(PyExc_RuntimeError, "not a valid CORBA object ptr");
06893     }
06894     Py_END_ALLOW_THREADS
06895   }
06896   {
06897     Py_BEGIN_ALLOW_THREADS
06898     try {
06899       (arg1)->add_provides_port(arg2,(char const *)arg3,arg4);
06900     }
06901     catch(Engines::DSC::PortNotDefined& _e) {
06902       Py_BLOCK_THREADS
06903       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
06904       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06905       PyErr_SetObject(excc, exci);
06906       Py_XDECREF(excc);
06907       Py_XDECREF(exci);
06908       return NULL;
06909     }
06910     catch(Engines::DSC::PortNotConnected& _e) {
06911       Py_BLOCK_THREADS
06912       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
06913       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06914       PyErr_SetObject(excc, exci);
06915       Py_XDECREF(excc);
06916       Py_XDECREF(exci);
06917       return NULL;
06918     }
06919     catch(Engines::DSC::BadPortType& _e) {
06920       Py_BLOCK_THREADS
06921       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
06922       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
06923       PyErr_SetObject(excc, exci);
06924       Py_XDECREF(excc);
06925       Py_XDECREF(exci);
06926       return NULL;
06927     }
06928     catch (SALOME_Exception &e) {
06929       Py_BLOCK_THREADS
06930       PyErr_SetString(PyExc_RuntimeError,e.what());
06931       return NULL;
06932     }
06933     catch (SALOME::SALOME_Exception &e) {
06934       Py_BLOCK_THREADS
06935       //This one should be converted into a python corba exception
06936       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06937       return NULL;
06938     }
06939     catch (const CORBA::SystemException& e) {
06940       Py_BLOCK_THREADS 
06941       return api->handleCxxSystemException(e);
06942     }
06943     catch(...) {
06944       Py_BLOCK_THREADS
06945       PyErr_SetString(PyExc_ValueError,"Unknown exception");
06946       return NULL;
06947     }
06948     Py_END_ALLOW_THREADS
06949   }
06950   resultobj = SWIG_Py_Void();
06951   {
06952     CORBA::release(arg2);
06953   }
06954   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
06955   {
06956     CORBA::release(arg4);
06957   }
06958   return resultobj;
06959 fail:
06960   {
06961     CORBA::release(arg2);
06962   }
06963   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
06964   {
06965     CORBA::release(arg4);
06966   }
06967   return NULL;
06968 }
06969 
06970 
06971 SWIGINTERN PyObject *_wrap_PySupervCompo_add_uses_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06972   PyObject *resultobj = 0;
06973   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
06974   char *arg2 = (char *) 0 ;
06975   char *arg3 = (char *) 0 ;
06976   Ports::PortProperties_ptr arg4 ;
06977   void *argp1 = 0 ;
06978   int res1 = 0 ;
06979   int res2 ;
06980   char *buf2 = 0 ;
06981   int alloc2 = 0 ;
06982   int res3 ;
06983   char *buf3 = 0 ;
06984   int alloc3 = 0 ;
06985   PyObject * obj0 = 0 ;
06986   PyObject * obj1 = 0 ;
06987   PyObject * obj2 = 0 ;
06988   PyObject * obj3 = 0 ;
06989   
06990   if (!PyArg_ParseTuple(args,(char *)"OOOO:PySupervCompo_add_uses_port",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
06991   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
06992   if (!SWIG_IsOK(res1)) {
06993     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_add_uses_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
06994   }
06995   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
06996   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
06997   if (!SWIG_IsOK(res2)) {
06998     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_add_uses_port" "', argument " "2"" of type '" "char const *""'");
06999   }
07000   arg2 = reinterpret_cast< char * >(buf2);
07001   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
07002   if (!SWIG_IsOK(res3)) {
07003     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PySupervCompo_add_uses_port" "', argument " "3"" of type '" "char const *""'");
07004   }
07005   arg3 = reinterpret_cast< char * >(buf3);
07006   {
07007     Py_BEGIN_ALLOW_THREADS
07008     try
07009     {
07010       CORBA::Object_var obj = api->pyObjRefToCxxObjRef(obj3,0);
07011       arg4 = Ports::PortProperties::_narrow(obj);
07012     }
07013     catch(...)
07014     {
07015       Py_BLOCK_THREADS
07016       PyErr_SetString(PyExc_RuntimeError, "not a valid CORBA object ptr");
07017     }
07018     Py_END_ALLOW_THREADS
07019   }
07020   {
07021     Py_BEGIN_ALLOW_THREADS
07022     try {
07023       (arg1)->add_uses_port((char const *)arg2,(char const *)arg3,arg4);
07024     }
07025     catch(Engines::DSC::PortNotDefined& _e) {
07026       Py_BLOCK_THREADS
07027       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
07028       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07029       PyErr_SetObject(excc, exci);
07030       Py_XDECREF(excc);
07031       Py_XDECREF(exci);
07032       return NULL;
07033     }
07034     catch(Engines::DSC::PortNotConnected& _e) {
07035       Py_BLOCK_THREADS
07036       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
07037       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07038       PyErr_SetObject(excc, exci);
07039       Py_XDECREF(excc);
07040       Py_XDECREF(exci);
07041       return NULL;
07042     }
07043     catch(Engines::DSC::BadPortType& _e) {
07044       Py_BLOCK_THREADS
07045       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
07046       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07047       PyErr_SetObject(excc, exci);
07048       Py_XDECREF(excc);
07049       Py_XDECREF(exci);
07050       return NULL;
07051     }
07052     catch (SALOME_Exception &e) {
07053       Py_BLOCK_THREADS
07054       PyErr_SetString(PyExc_RuntimeError,e.what());
07055       return NULL;
07056     }
07057     catch (SALOME::SALOME_Exception &e) {
07058       Py_BLOCK_THREADS
07059       //This one should be converted into a python corba exception
07060       PyErr_SetString(PyExc_RuntimeError,e.details.text);
07061       return NULL;
07062     }
07063     catch (const CORBA::SystemException& e) {
07064       Py_BLOCK_THREADS 
07065       return api->handleCxxSystemException(e);
07066     }
07067     catch(...) {
07068       Py_BLOCK_THREADS
07069       PyErr_SetString(PyExc_ValueError,"Unknown exception");
07070       return NULL;
07071     }
07072     Py_END_ALLOW_THREADS
07073   }
07074   resultobj = SWIG_Py_Void();
07075   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
07076   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
07077   {
07078     CORBA::release(arg4);
07079   }
07080   return resultobj;
07081 fail:
07082   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
07083   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
07084   {
07085     CORBA::release(arg4);
07086   }
07087   return NULL;
07088 }
07089 
07090 
07091 SWIGINTERN PyObject *_wrap_PySupervCompo_get_uses_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07092   PyObject *resultobj = 0;
07093   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
07094   char *arg2 = (char *) 0 ;
07095   void *argp1 = 0 ;
07096   int res1 = 0 ;
07097   int res2 ;
07098   char *buf2 = 0 ;
07099   int alloc2 = 0 ;
07100   PyObject * obj0 = 0 ;
07101   PyObject * obj1 = 0 ;
07102   Engines::DSC::uses_port *result = 0 ;
07103   
07104   if (!PyArg_ParseTuple(args,(char *)"OO:PySupervCompo_get_uses_port",&obj0,&obj1)) SWIG_fail;
07105   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
07106   if (!SWIG_IsOK(res1)) {
07107     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_get_uses_port" "', argument " "1"" of type '" "PySupervCompo *""'"); 
07108   }
07109   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
07110   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
07111   if (!SWIG_IsOK(res2)) {
07112     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_get_uses_port" "', argument " "2"" of type '" "char const *""'");
07113   }
07114   arg2 = reinterpret_cast< char * >(buf2);
07115   {
07116     Py_BEGIN_ALLOW_THREADS
07117     try {
07118       result = (Engines::DSC::uses_port *)(arg1)->get_uses_port((char const *)arg2);
07119     }
07120     catch(Engines::DSC::PortNotDefined& _e) {
07121       Py_BLOCK_THREADS
07122       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
07123       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07124       PyErr_SetObject(excc, exci);
07125       Py_XDECREF(excc);
07126       Py_XDECREF(exci);
07127       return NULL;
07128     }
07129     catch(Engines::DSC::PortNotConnected& _e) {
07130       Py_BLOCK_THREADS
07131       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
07132       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07133       PyErr_SetObject(excc, exci);
07134       Py_XDECREF(excc);
07135       Py_XDECREF(exci);
07136       return NULL;
07137     }
07138     catch(Engines::DSC::BadPortType& _e) {
07139       Py_BLOCK_THREADS
07140       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
07141       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07142       PyErr_SetObject(excc, exci);
07143       Py_XDECREF(excc);
07144       Py_XDECREF(exci);
07145       return NULL;
07146     }
07147     catch (SALOME_Exception &e) {
07148       Py_BLOCK_THREADS
07149       PyErr_SetString(PyExc_RuntimeError,e.what());
07150       return NULL;
07151     }
07152     catch (SALOME::SALOME_Exception &e) {
07153       Py_BLOCK_THREADS
07154       //This one should be converted into a python corba exception
07155       PyErr_SetString(PyExc_RuntimeError,e.details.text);
07156       return NULL;
07157     }
07158     catch (const CORBA::SystemException& e) {
07159       Py_BLOCK_THREADS 
07160       return api->handleCxxSystemException(e);
07161     }
07162     catch(...) {
07163       Py_BLOCK_THREADS
07164       PyErr_SetString(PyExc_ValueError,"Unknown exception");
07165       return NULL;
07166     }
07167     Py_END_ALLOW_THREADS
07168   }
07169   {
07170     resultobj = PyList_New(result->length());
07171     for (CORBA::ULong i=0; i < result->length() ; i++)
07172     PyList_SetItem(resultobj,i,api->cxxObjRefToPyObjRef((*result)[i], 1));
07173     //delete the copy (created by new) of uses port sequence
07174     delete result;
07175   }
07176   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
07177   return resultobj;
07178 fail:
07179   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
07180   return NULL;
07181 }
07182 
07183 
07184 SWIGINTERN PyObject *_wrap_PySupervCompo_is_connected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07185   PyObject *resultobj = 0;
07186   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
07187   char *arg2 = (char *) 0 ;
07188   void *argp1 = 0 ;
07189   int res1 = 0 ;
07190   int res2 ;
07191   char *buf2 = 0 ;
07192   int alloc2 = 0 ;
07193   PyObject * obj0 = 0 ;
07194   PyObject * obj1 = 0 ;
07195   CORBA::Boolean result;
07196   
07197   if (!PyArg_ParseTuple(args,(char *)"OO:PySupervCompo_is_connected",&obj0,&obj1)) SWIG_fail;
07198   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
07199   if (!SWIG_IsOK(res1)) {
07200     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_is_connected" "', argument " "1"" of type '" "PySupervCompo *""'"); 
07201   }
07202   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
07203   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
07204   if (!SWIG_IsOK(res2)) {
07205     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySupervCompo_is_connected" "', argument " "2"" of type '" "char const *""'");
07206   }
07207   arg2 = reinterpret_cast< char * >(buf2);
07208   {
07209     Py_BEGIN_ALLOW_THREADS
07210     try {
07211       result = (arg1)->is_connected((char const *)arg2);
07212     }
07213     catch(Engines::DSC::PortNotDefined& _e) {
07214       Py_BLOCK_THREADS
07215       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
07216       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07217       PyErr_SetObject(excc, exci);
07218       Py_XDECREF(excc);
07219       Py_XDECREF(exci);
07220       return NULL;
07221     }
07222     catch(Engines::DSC::PortNotConnected& _e) {
07223       Py_BLOCK_THREADS
07224       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
07225       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07226       PyErr_SetObject(excc, exci);
07227       Py_XDECREF(excc);
07228       Py_XDECREF(exci);
07229       return NULL;
07230     }
07231     catch(Engines::DSC::BadPortType& _e) {
07232       Py_BLOCK_THREADS
07233       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
07234       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07235       PyErr_SetObject(excc, exci);
07236       Py_XDECREF(excc);
07237       Py_XDECREF(exci);
07238       return NULL;
07239     }
07240     catch (SALOME_Exception &e) {
07241       Py_BLOCK_THREADS
07242       PyErr_SetString(PyExc_RuntimeError,e.what());
07243       return NULL;
07244     }
07245     catch (SALOME::SALOME_Exception &e) {
07246       Py_BLOCK_THREADS
07247       //This one should be converted into a python corba exception
07248       PyErr_SetString(PyExc_RuntimeError,e.details.text);
07249       return NULL;
07250     }
07251     catch (const CORBA::SystemException& e) {
07252       Py_BLOCK_THREADS 
07253       return api->handleCxxSystemException(e);
07254     }
07255     catch(...) {
07256       Py_BLOCK_THREADS
07257       PyErr_SetString(PyExc_ValueError,"Unknown exception");
07258       return NULL;
07259     }
07260     Py_END_ALLOW_THREADS
07261   }
07262   {
07263     resultobj=PyInt_FromLong(result ? 1 : 0);
07264   }
07265   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
07266   return resultobj;
07267 fail:
07268   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
07269   return NULL;
07270 }
07271 
07272 
07273 SWIGINTERN PyObject *_wrap_PySupervCompo_setTimeOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07274   PyObject *resultobj = 0;
07275   
07276   if (!PyArg_ParseTuple(args,(char *)":PySupervCompo_setTimeOut")) SWIG_fail;
07277   {
07278     Py_BEGIN_ALLOW_THREADS
07279     try {
07280       PySupervCompo::setTimeOut();
07281     }
07282     catch(Engines::DSC::PortNotDefined& _e) {
07283       Py_BLOCK_THREADS
07284       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
07285       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07286       PyErr_SetObject(excc, exci);
07287       Py_XDECREF(excc);
07288       Py_XDECREF(exci);
07289       return NULL;
07290     }
07291     catch(Engines::DSC::PortNotConnected& _e) {
07292       Py_BLOCK_THREADS
07293       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
07294       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07295       PyErr_SetObject(excc, exci);
07296       Py_XDECREF(excc);
07297       Py_XDECREF(exci);
07298       return NULL;
07299     }
07300     catch(Engines::DSC::BadPortType& _e) {
07301       Py_BLOCK_THREADS
07302       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
07303       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07304       PyErr_SetObject(excc, exci);
07305       Py_XDECREF(excc);
07306       Py_XDECREF(exci);
07307       return NULL;
07308     }
07309     catch (SALOME_Exception &e) {
07310       Py_BLOCK_THREADS
07311       PyErr_SetString(PyExc_RuntimeError,e.what());
07312       return NULL;
07313     }
07314     catch (SALOME::SALOME_Exception &e) {
07315       Py_BLOCK_THREADS
07316       //This one should be converted into a python corba exception
07317       PyErr_SetString(PyExc_RuntimeError,e.details.text);
07318       return NULL;
07319     }
07320     catch (const CORBA::SystemException& e) {
07321       Py_BLOCK_THREADS 
07322       return api->handleCxxSystemException(e);
07323     }
07324     catch(...) {
07325       Py_BLOCK_THREADS
07326       PyErr_SetString(PyExc_ValueError,"Unknown exception");
07327       return NULL;
07328     }
07329     Py_END_ALLOW_THREADS
07330   }
07331   resultobj = SWIG_Py_Void();
07332   return resultobj;
07333 fail:
07334   return NULL;
07335 }
07336 
07337 
07338 SWIGINTERN PyObject *_wrap_PySupervCompo_ptr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07339   PyObject *resultobj = 0;
07340   PySupervCompo *arg1 = (PySupervCompo *) 0 ;
07341   void *argp1 = 0 ;
07342   int res1 = 0 ;
07343   PyObject * obj0 = 0 ;
07344   long result;
07345   
07346   if (!PyArg_ParseTuple(args,(char *)"O:PySupervCompo_ptr",&obj0)) SWIG_fail;
07347   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PySupervCompo, 0 |  0 );
07348   if (!SWIG_IsOK(res1)) {
07349     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySupervCompo_ptr" "', argument " "1"" of type '" "PySupervCompo *""'"); 
07350   }
07351   arg1 = reinterpret_cast< PySupervCompo * >(argp1);
07352   {
07353     Py_BEGIN_ALLOW_THREADS
07354     try {
07355       result = (long)PySupervCompo_ptr(arg1);
07356     }
07357     catch(Engines::DSC::PortNotDefined& _e) {
07358       Py_BLOCK_THREADS
07359       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
07360       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07361       PyErr_SetObject(excc, exci);
07362       Py_XDECREF(excc);
07363       Py_XDECREF(exci);
07364       return NULL;
07365     }
07366     catch(Engines::DSC::PortNotConnected& _e) {
07367       Py_BLOCK_THREADS
07368       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
07369       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07370       PyErr_SetObject(excc, exci);
07371       Py_XDECREF(excc);
07372       Py_XDECREF(exci);
07373       return NULL;
07374     }
07375     catch(Engines::DSC::BadPortType& _e) {
07376       Py_BLOCK_THREADS
07377       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
07378       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07379       PyErr_SetObject(excc, exci);
07380       Py_XDECREF(excc);
07381       Py_XDECREF(exci);
07382       return NULL;
07383     }
07384     catch (SALOME_Exception &e) {
07385       Py_BLOCK_THREADS
07386       PyErr_SetString(PyExc_RuntimeError,e.what());
07387       return NULL;
07388     }
07389     catch (SALOME::SALOME_Exception &e) {
07390       Py_BLOCK_THREADS
07391       //This one should be converted into a python corba exception
07392       PyErr_SetString(PyExc_RuntimeError,e.details.text);
07393       return NULL;
07394     }
07395     catch (const CORBA::SystemException& e) {
07396       Py_BLOCK_THREADS 
07397       return api->handleCxxSystemException(e);
07398     }
07399     catch(...) {
07400       Py_BLOCK_THREADS
07401       PyErr_SetString(PyExc_ValueError,"Unknown exception");
07402       return NULL;
07403     }
07404     Py_END_ALLOW_THREADS
07405   }
07406   resultobj = SWIG_From_long(static_cast< long >(result));
07407   return resultobj;
07408 fail:
07409   return NULL;
07410 }
07411 
07412 
07413 SWIGINTERN PyObject *PySupervCompo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07414   PyObject *obj;
07415   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
07416   SWIG_TypeNewClientData(SWIGTYPE_p_PySupervCompo, SWIG_NewClientData(obj));
07417   return SWIG_Py_Void();
07418 }
07419 
07420 SWIGINTERN PyObject *_wrap_create_calcium_port(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07421   PyObject *resultobj = 0;
07422   Superv_Component_i *arg1 = (Superv_Component_i *) 0 ;
07423   char *arg2 = (char *) 0 ;
07424   char *arg3 = (char *) 0 ;
07425   char *arg4 = (char *) 0 ;
07426   char *arg5 = (char *) 0 ;
07427   void *argp1 = 0 ;
07428   int res1 = 0 ;
07429   int res2 ;
07430   char *buf2 = 0 ;
07431   int alloc2 = 0 ;
07432   int res3 ;
07433   char *buf3 = 0 ;
07434   int alloc3 = 0 ;
07435   int res4 ;
07436   char *buf4 = 0 ;
07437   int alloc4 = 0 ;
07438   int res5 ;
07439   char *buf5 = 0 ;
07440   int alloc5 = 0 ;
07441   PyObject * obj0 = 0 ;
07442   PyObject * obj1 = 0 ;
07443   PyObject * obj2 = 0 ;
07444   PyObject * obj3 = 0 ;
07445   PyObject * obj4 = 0 ;
07446   
07447   if (!PyArg_ParseTuple(args,(char *)"OOOOO:create_calcium_port",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
07448   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Superv_Component_i, 0 |  0 );
07449   if (!SWIG_IsOK(res1)) {
07450     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "create_calcium_port" "', argument " "1"" of type '" "Superv_Component_i *""'"); 
07451   }
07452   arg1 = reinterpret_cast< Superv_Component_i * >(argp1);
07453   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
07454   if (!SWIG_IsOK(res2)) {
07455     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "create_calcium_port" "', argument " "2"" of type '" "char *""'");
07456   }
07457   arg2 = reinterpret_cast< char * >(buf2);
07458   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
07459   if (!SWIG_IsOK(res3)) {
07460     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "create_calcium_port" "', argument " "3"" of type '" "char *""'");
07461   }
07462   arg3 = reinterpret_cast< char * >(buf3);
07463   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
07464   if (!SWIG_IsOK(res4)) {
07465     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "create_calcium_port" "', argument " "4"" of type '" "char *""'");
07466   }
07467   arg4 = reinterpret_cast< char * >(buf4);
07468   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
07469   if (!SWIG_IsOK(res5)) {
07470     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "create_calcium_port" "', argument " "5"" of type '" "char *""'");
07471   }
07472   arg5 = reinterpret_cast< char * >(buf5);
07473   {
07474     Py_BEGIN_ALLOW_THREADS
07475     try {
07476       create_calcium_port(arg1,arg2,arg3,arg4,arg5);
07477     }
07478     catch(Engines::DSC::PortNotDefined& _e) {
07479       Py_BLOCK_THREADS
07480       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
07481       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07482       PyErr_SetObject(excc, exci);
07483       Py_XDECREF(excc);
07484       Py_XDECREF(exci);
07485       return NULL;
07486     }
07487     catch(Engines::DSC::PortNotConnected& _e) {
07488       Py_BLOCK_THREADS
07489       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
07490       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07491       PyErr_SetObject(excc, exci);
07492       Py_XDECREF(excc);
07493       Py_XDECREF(exci);
07494       return NULL;
07495     }
07496     catch(Engines::DSC::BadPortType& _e) {
07497       Py_BLOCK_THREADS
07498       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
07499       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07500       PyErr_SetObject(excc, exci);
07501       Py_XDECREF(excc);
07502       Py_XDECREF(exci);
07503       return NULL;
07504     }
07505     catch (SALOME_Exception &e) {
07506       Py_BLOCK_THREADS
07507       PyErr_SetString(PyExc_RuntimeError,e.what());
07508       return NULL;
07509     }
07510     catch (SALOME::SALOME_Exception &e) {
07511       Py_BLOCK_THREADS
07512       //This one should be converted into a python corba exception
07513       PyErr_SetString(PyExc_RuntimeError,e.details.text);
07514       return NULL;
07515     }
07516     catch (const CORBA::SystemException& e) {
07517       Py_BLOCK_THREADS 
07518       return api->handleCxxSystemException(e);
07519     }
07520     catch(...) {
07521       Py_BLOCK_THREADS
07522       PyErr_SetString(PyExc_ValueError,"Unknown exception");
07523       return NULL;
07524     }
07525     Py_END_ALLOW_THREADS
07526   }
07527   resultobj = SWIG_Py_Void();
07528   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
07529   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
07530   if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
07531   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
07532   return resultobj;
07533 fail:
07534   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
07535   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
07536   if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
07537   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
07538   return NULL;
07539 }
07540 
07541 
07542 SWIGINTERN PyObject *_wrap_cp_cd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07543   PyObject *resultobj = 0;
07544   Superv_Component_i *arg1 = (Superv_Component_i *) 0 ;
07545   char *arg2 = (char *) 0 ;
07546   void *argp1 = 0 ;
07547   int res1 = 0 ;
07548   char temp2[1024+1] ;
07549   PyObject * obj0 = 0 ;
07550   int result;
07551   
07552   arg2 = (char *) temp2;
07553   if (!PyArg_ParseTuple(args,(char *)"O:cp_cd",&obj0)) SWIG_fail;
07554   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Superv_Component_i, 0 |  0 );
07555   if (!SWIG_IsOK(res1)) {
07556     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cp_cd" "', argument " "1"" of type '" "Superv_Component_i *""'"); 
07557   }
07558   arg1 = reinterpret_cast< Superv_Component_i * >(argp1);
07559   {
07560     Py_BEGIN_ALLOW_THREADS
07561     try {
07562       result = (int)cp_cd(arg1,arg2);
07563     }
07564     catch(Engines::DSC::PortNotDefined& _e) {
07565       Py_BLOCK_THREADS
07566       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
07567       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07568       PyErr_SetObject(excc, exci);
07569       Py_XDECREF(excc);
07570       Py_XDECREF(exci);
07571       return NULL;
07572     }
07573     catch(Engines::DSC::PortNotConnected& _e) {
07574       Py_BLOCK_THREADS
07575       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
07576       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07577       PyErr_SetObject(excc, exci);
07578       Py_XDECREF(excc);
07579       Py_XDECREF(exci);
07580       return NULL;
07581     }
07582     catch(Engines::DSC::BadPortType& _e) {
07583       Py_BLOCK_THREADS
07584       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
07585       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07586       PyErr_SetObject(excc, exci);
07587       Py_XDECREF(excc);
07588       Py_XDECREF(exci);
07589       return NULL;
07590     }
07591     catch (SALOME_Exception &e) {
07592       Py_BLOCK_THREADS
07593       PyErr_SetString(PyExc_RuntimeError,e.what());
07594       return NULL;
07595     }
07596     catch (SALOME::SALOME_Exception &e) {
07597       Py_BLOCK_THREADS
07598       //This one should be converted into a python corba exception
07599       PyErr_SetString(PyExc_RuntimeError,e.details.text);
07600       return NULL;
07601     }
07602     catch (const CORBA::SystemException& e) {
07603       Py_BLOCK_THREADS 
07604       return api->handleCxxSystemException(e);
07605     }
07606     catch(...) {
07607       Py_BLOCK_THREADS
07608       PyErr_SetString(PyExc_ValueError,"Unknown exception");
07609       return NULL;
07610     }
07611     Py_END_ALLOW_THREADS
07612   }
07613   resultobj = SWIG_From_int(static_cast< int >(result));
07614   arg2[1024] = 0;  
07615   resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg2));
07616   return resultobj;
07617 fail:
07618   return NULL;
07619 }
07620 
07621 
07622 SWIGINTERN PyObject *_wrap_cp_een(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07623   PyObject *resultobj = 0;
07624   Superv_Component_i *arg1 = (Superv_Component_i *) 0 ;
07625   int arg2 ;
07626   float arg3 ;
07627   int arg4 ;
07628   char *arg5 = (char *) 0 ;
07629   int arg6 ;
07630   int *arg7 = (int *) 0 ;
07631   void *argp1 = 0 ;
07632   int res1 = 0 ;
07633   int val2 ;
07634   int ecode2 = 0 ;
07635   float val3 ;
07636   int ecode3 = 0 ;
07637   int val4 ;
07638   int ecode4 = 0 ;
07639   int res5 ;
07640   char *buf5 = 0 ;
07641   int alloc5 = 0 ;
07642   int val6 ;
07643   int ecode6 = 0 ;
07644   ArrayObject *array7 = NULL ;
07645   int is_new_object7 ;
07646   PyObject * obj0 = 0 ;
07647   PyObject * obj1 = 0 ;
07648   PyObject * obj2 = 0 ;
07649   PyObject * obj3 = 0 ;
07650   PyObject * obj4 = 0 ;
07651   PyObject * obj5 = 0 ;
07652   PyObject * obj6 = 0 ;
07653   int result;
07654   
07655   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cp_een",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
07656   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Superv_Component_i, 0 |  0 );
07657   if (!SWIG_IsOK(res1)) {
07658     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cp_een" "', argument " "1"" of type '" "Superv_Component_i *""'"); 
07659   }
07660   arg1 = reinterpret_cast< Superv_Component_i * >(argp1);
07661   ecode2 = SWIG_AsVal_int(obj1, &val2);
07662   if (!SWIG_IsOK(ecode2)) {
07663     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cp_een" "', argument " "2"" of type '" "int""'");
07664   } 
07665   arg2 = static_cast< int >(val2);
07666   ecode3 = SWIG_AsVal_float(obj2, &val3);
07667   if (!SWIG_IsOK(ecode3)) {
07668     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cp_een" "', argument " "3"" of type '" "float""'");
07669   } 
07670   arg3 = static_cast< float >(val3);
07671   ecode4 = SWIG_AsVal_int(obj3, &val4);
07672   if (!SWIG_IsOK(ecode4)) {
07673     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cp_een" "', argument " "4"" of type '" "int""'");
07674   } 
07675   arg4 = static_cast< int >(val4);
07676   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
07677   if (!SWIG_IsOK(res5)) {
07678     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cp_een" "', argument " "5"" of type '" "char *""'");
07679   }
07680   arg5 = reinterpret_cast< char * >(buf5);
07681   ecode6 = SWIG_AsVal_int(obj5, &val6);
07682   if (!SWIG_IsOK(ecode6)) {
07683     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cp_een" "', argument " "6"" of type '" "int""'");
07684   } 
07685   arg6 = static_cast< int >(val6);
07686   {
07687     if ((SWIG_ConvertPtr(obj6, (void **) &arg7, SWIGTYPE_p_int,0)) == -1)
07688     {
07689 #ifdef WITH_NUMPY
07690       int size[1] = {
07691         -1
07692       };
07693       array7 = obj_to_array_contiguous_allow_conversion(obj6, PyArray_INT, &is_new_object7);
07694       if (!array7 || !require_dimensions(array7,1) || !require_size(array7,size,1)) SWIG_fail;
07695       arg7 = (int*) array7->data;
07696 #else
07697       SWIG_exception(SWIG_TypeError, "int* expected");
07698 #endif
07699     }
07700   }
07701   {
07702     Py_BEGIN_ALLOW_THREADS
07703     try {
07704       result = (int)cp_een(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
07705     }
07706     catch(Engines::DSC::PortNotDefined& _e) {
07707       Py_BLOCK_THREADS
07708       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
07709       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07710       PyErr_SetObject(excc, exci);
07711       Py_XDECREF(excc);
07712       Py_XDECREF(exci);
07713       return NULL;
07714     }
07715     catch(Engines::DSC::PortNotConnected& _e) {
07716       Py_BLOCK_THREADS
07717       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
07718       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07719       PyErr_SetObject(excc, exci);
07720       Py_XDECREF(excc);
07721       Py_XDECREF(exci);
07722       return NULL;
07723     }
07724     catch(Engines::DSC::BadPortType& _e) {
07725       Py_BLOCK_THREADS
07726       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
07727       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07728       PyErr_SetObject(excc, exci);
07729       Py_XDECREF(excc);
07730       Py_XDECREF(exci);
07731       return NULL;
07732     }
07733     catch (SALOME_Exception &e) {
07734       Py_BLOCK_THREADS
07735       PyErr_SetString(PyExc_RuntimeError,e.what());
07736       return NULL;
07737     }
07738     catch (SALOME::SALOME_Exception &e) {
07739       Py_BLOCK_THREADS
07740       //This one should be converted into a python corba exception
07741       PyErr_SetString(PyExc_RuntimeError,e.details.text);
07742       return NULL;
07743     }
07744     catch (const CORBA::SystemException& e) {
07745       Py_BLOCK_THREADS 
07746       return api->handleCxxSystemException(e);
07747     }
07748     catch(...) {
07749       Py_BLOCK_THREADS
07750       PyErr_SetString(PyExc_ValueError,"Unknown exception");
07751       return NULL;
07752     }
07753     Py_END_ALLOW_THREADS
07754   }
07755   resultobj = SWIG_From_int(static_cast< int >(result));
07756   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
07757   {
07758 #ifdef WITH_NUMPY
07759     if (is_new_object7 && array7) 
07760     {
07761       Py_DECREF(array7);
07762     }
07763 #endif
07764   }
07765   return resultobj;
07766 fail:
07767   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
07768   {
07769 #ifdef WITH_NUMPY
07770     if (is_new_object7 && array7) 
07771     {
07772       Py_DECREF(array7);
07773     }
07774 #endif
07775   }
07776   return NULL;
07777 }
07778 
07779 
07780 SWIGINTERN PyObject *_wrap_cp_edb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07781   PyObject *resultobj = 0;
07782   Superv_Component_i *arg1 = (Superv_Component_i *) 0 ;
07783   int arg2 ;
07784   double arg3 ;
07785   int arg4 ;
07786   char *arg5 = (char *) 0 ;
07787   int arg6 ;
07788   double *arg7 = (double *) 0 ;
07789   void *argp1 = 0 ;
07790   int res1 = 0 ;
07791   int val2 ;
07792   int ecode2 = 0 ;
07793   double val3 ;
07794   int ecode3 = 0 ;
07795   int val4 ;
07796   int ecode4 = 0 ;
07797   int res5 ;
07798   char *buf5 = 0 ;
07799   int alloc5 = 0 ;
07800   int val6 ;
07801   int ecode6 = 0 ;
07802   ArrayObject *array7 = NULL ;
07803   int is_new_object7 ;
07804   PyObject * obj0 = 0 ;
07805   PyObject * obj1 = 0 ;
07806   PyObject * obj2 = 0 ;
07807   PyObject * obj3 = 0 ;
07808   PyObject * obj4 = 0 ;
07809   PyObject * obj5 = 0 ;
07810   PyObject * obj6 = 0 ;
07811   int result;
07812   
07813   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cp_edb",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
07814   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Superv_Component_i, 0 |  0 );
07815   if (!SWIG_IsOK(res1)) {
07816     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cp_edb" "', argument " "1"" of type '" "Superv_Component_i *""'"); 
07817   }
07818   arg1 = reinterpret_cast< Superv_Component_i * >(argp1);
07819   ecode2 = SWIG_AsVal_int(obj1, &val2);
07820   if (!SWIG_IsOK(ecode2)) {
07821     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cp_edb" "', argument " "2"" of type '" "int""'");
07822   } 
07823   arg2 = static_cast< int >(val2);
07824   ecode3 = SWIG_AsVal_double(obj2, &val3);
07825   if (!SWIG_IsOK(ecode3)) {
07826     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cp_edb" "', argument " "3"" of type '" "double""'");
07827   } 
07828   arg3 = static_cast< double >(val3);
07829   ecode4 = SWIG_AsVal_int(obj3, &val4);
07830   if (!SWIG_IsOK(ecode4)) {
07831     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cp_edb" "', argument " "4"" of type '" "int""'");
07832   } 
07833   arg4 = static_cast< int >(val4);
07834   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
07835   if (!SWIG_IsOK(res5)) {
07836     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cp_edb" "', argument " "5"" of type '" "char *""'");
07837   }
07838   arg5 = reinterpret_cast< char * >(buf5);
07839   ecode6 = SWIG_AsVal_int(obj5, &val6);
07840   if (!SWIG_IsOK(ecode6)) {
07841     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cp_edb" "', argument " "6"" of type '" "int""'");
07842   } 
07843   arg6 = static_cast< int >(val6);
07844   {
07845     if ((SWIG_ConvertPtr(obj6, (void **) &arg7, SWIGTYPE_p_double,0)) == -1)
07846     {
07847 #ifdef WITH_NUMPY
07848       int size[1] = {
07849         -1
07850       };
07851       array7 = obj_to_array_contiguous_allow_conversion(obj6, PyArray_DOUBLE, &is_new_object7);
07852       if (!array7 || !require_dimensions(array7,1) || !require_size(array7,size,1)) SWIG_fail;
07853       arg7 = (double*) array7->data;
07854 #else
07855       SWIG_exception(SWIG_TypeError, "double* expected");
07856 #endif
07857     }
07858   }
07859   {
07860     Py_BEGIN_ALLOW_THREADS
07861     try {
07862       result = (int)cp_edb(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
07863     }
07864     catch(Engines::DSC::PortNotDefined& _e) {
07865       Py_BLOCK_THREADS
07866       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
07867       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07868       PyErr_SetObject(excc, exci);
07869       Py_XDECREF(excc);
07870       Py_XDECREF(exci);
07871       return NULL;
07872     }
07873     catch(Engines::DSC::PortNotConnected& _e) {
07874       Py_BLOCK_THREADS
07875       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
07876       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07877       PyErr_SetObject(excc, exci);
07878       Py_XDECREF(excc);
07879       Py_XDECREF(exci);
07880       return NULL;
07881     }
07882     catch(Engines::DSC::BadPortType& _e) {
07883       Py_BLOCK_THREADS
07884       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
07885       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
07886       PyErr_SetObject(excc, exci);
07887       Py_XDECREF(excc);
07888       Py_XDECREF(exci);
07889       return NULL;
07890     }
07891     catch (SALOME_Exception &e) {
07892       Py_BLOCK_THREADS
07893       PyErr_SetString(PyExc_RuntimeError,e.what());
07894       return NULL;
07895     }
07896     catch (SALOME::SALOME_Exception &e) {
07897       Py_BLOCK_THREADS
07898       //This one should be converted into a python corba exception
07899       PyErr_SetString(PyExc_RuntimeError,e.details.text);
07900       return NULL;
07901     }
07902     catch (const CORBA::SystemException& e) {
07903       Py_BLOCK_THREADS 
07904       return api->handleCxxSystemException(e);
07905     }
07906     catch(...) {
07907       Py_BLOCK_THREADS
07908       PyErr_SetString(PyExc_ValueError,"Unknown exception");
07909       return NULL;
07910     }
07911     Py_END_ALLOW_THREADS
07912   }
07913   resultobj = SWIG_From_int(static_cast< int >(result));
07914   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
07915   {
07916 #ifdef WITH_NUMPY
07917     if (is_new_object7 && array7) 
07918     {
07919       Py_DECREF(array7);
07920     }
07921 #endif
07922   }
07923   return resultobj;
07924 fail:
07925   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
07926   {
07927 #ifdef WITH_NUMPY
07928     if (is_new_object7 && array7) 
07929     {
07930       Py_DECREF(array7);
07931     }
07932 #endif
07933   }
07934   return NULL;
07935 }
07936 
07937 
07938 SWIGINTERN PyObject *_wrap_cp_ere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07939   PyObject *resultobj = 0;
07940   Superv_Component_i *arg1 = (Superv_Component_i *) 0 ;
07941   int arg2 ;
07942   float arg3 ;
07943   int arg4 ;
07944   char *arg5 = (char *) 0 ;
07945   int arg6 ;
07946   float *arg7 = (float *) 0 ;
07947   void *argp1 = 0 ;
07948   int res1 = 0 ;
07949   int val2 ;
07950   int ecode2 = 0 ;
07951   float val3 ;
07952   int ecode3 = 0 ;
07953   int val4 ;
07954   int ecode4 = 0 ;
07955   int res5 ;
07956   char *buf5 = 0 ;
07957   int alloc5 = 0 ;
07958   int val6 ;
07959   int ecode6 = 0 ;
07960   ArrayObject *array7 = NULL ;
07961   int is_new_object7 ;
07962   PyObject * obj0 = 0 ;
07963   PyObject * obj1 = 0 ;
07964   PyObject * obj2 = 0 ;
07965   PyObject * obj3 = 0 ;
07966   PyObject * obj4 = 0 ;
07967   PyObject * obj5 = 0 ;
07968   PyObject * obj6 = 0 ;
07969   int result;
07970   
07971   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cp_ere",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
07972   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Superv_Component_i, 0 |  0 );
07973   if (!SWIG_IsOK(res1)) {
07974     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cp_ere" "', argument " "1"" of type '" "Superv_Component_i *""'"); 
07975   }
07976   arg1 = reinterpret_cast< Superv_Component_i * >(argp1);
07977   ecode2 = SWIG_AsVal_int(obj1, &val2);
07978   if (!SWIG_IsOK(ecode2)) {
07979     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cp_ere" "', argument " "2"" of type '" "int""'");
07980   } 
07981   arg2 = static_cast< int >(val2);
07982   ecode3 = SWIG_AsVal_float(obj2, &val3);
07983   if (!SWIG_IsOK(ecode3)) {
07984     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cp_ere" "', argument " "3"" of type '" "float""'");
07985   } 
07986   arg3 = static_cast< float >(val3);
07987   ecode4 = SWIG_AsVal_int(obj3, &val4);
07988   if (!SWIG_IsOK(ecode4)) {
07989     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cp_ere" "', argument " "4"" of type '" "int""'");
07990   } 
07991   arg4 = static_cast< int >(val4);
07992   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
07993   if (!SWIG_IsOK(res5)) {
07994     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cp_ere" "', argument " "5"" of type '" "char *""'");
07995   }
07996   arg5 = reinterpret_cast< char * >(buf5);
07997   ecode6 = SWIG_AsVal_int(obj5, &val6);
07998   if (!SWIG_IsOK(ecode6)) {
07999     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cp_ere" "', argument " "6"" of type '" "int""'");
08000   } 
08001   arg6 = static_cast< int >(val6);
08002   {
08003     if ((SWIG_ConvertPtr(obj6, (void **) &arg7, SWIGTYPE_p_float,0)) == -1)
08004     {
08005 #ifdef WITH_NUMPY
08006       int size[1] = {
08007         -1
08008       };
08009       array7 = obj_to_array_contiguous_allow_conversion(obj6, PyArray_FLOAT, &is_new_object7);
08010       if (!array7 || !require_dimensions(array7,1) || !require_size(array7,size,1)) SWIG_fail;
08011       arg7 = (float*) array7->data;
08012 #else
08013       SWIG_exception(SWIG_TypeError, "float* expected");
08014 #endif
08015     }
08016   }
08017   {
08018     Py_BEGIN_ALLOW_THREADS
08019     try {
08020       result = (int)cp_ere(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
08021     }
08022     catch(Engines::DSC::PortNotDefined& _e) {
08023       Py_BLOCK_THREADS
08024       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
08025       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
08026       PyErr_SetObject(excc, exci);
08027       Py_XDECREF(excc);
08028       Py_XDECREF(exci);
08029       return NULL;
08030     }
08031     catch(Engines::DSC::PortNotConnected& _e) {
08032       Py_BLOCK_THREADS
08033       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
08034       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
08035       PyErr_SetObject(excc, exci);
08036       Py_XDECREF(excc);
08037       Py_XDECREF(exci);
08038       return NULL;
08039     }
08040     catch(Engines::DSC::BadPortType& _e) {
08041       Py_BLOCK_THREADS
08042       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
08043       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
08044       PyErr_SetObject(excc, exci);
08045       Py_XDECREF(excc);
08046       Py_XDECREF(exci);
08047       return NULL;
08048     }
08049     catch (SALOME_Exception &e) {
08050       Py_BLOCK_THREADS
08051       PyErr_SetString(PyExc_RuntimeError,e.what());
08052       return NULL;
08053     }
08054     catch (SALOME::SALOME_Exception &e) {
08055       Py_BLOCK_THREADS
08056       //This one should be converted into a python corba exception
08057       PyErr_SetString(PyExc_RuntimeError,e.details.text);
08058       return NULL;
08059     }
08060     catch (const CORBA::SystemException& e) {
08061       Py_BLOCK_THREADS 
08062       return api->handleCxxSystemException(e);
08063     }
08064     catch(...) {
08065       Py_BLOCK_THREADS
08066       PyErr_SetString(PyExc_ValueError,"Unknown exception");
08067       return NULL;
08068     }
08069     Py_END_ALLOW_THREADS
08070   }
08071   resultobj = SWIG_From_int(static_cast< int >(result));
08072   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
08073   {
08074 #ifdef WITH_NUMPY
08075     if (is_new_object7 && array7) 
08076     {
08077       Py_DECREF(array7);
08078     }
08079 #endif
08080   }
08081   return resultobj;
08082 fail:
08083   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
08084   {
08085 #ifdef WITH_NUMPY
08086     if (is_new_object7 && array7) 
08087     {
08088       Py_DECREF(array7);
08089     }
08090 #endif
08091   }
08092   return NULL;
08093 }
08094 
08095 
08096 SWIGINTERN PyObject *_wrap_cp_ecp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08097   PyObject *resultobj = 0;
08098   Superv_Component_i *arg1 = (Superv_Component_i *) 0 ;
08099   int arg2 ;
08100   float arg3 ;
08101   int arg4 ;
08102   char *arg5 = (char *) 0 ;
08103   int arg6 ;
08104   float *arg7 = (float *) 0 ;
08105   void *argp1 = 0 ;
08106   int res1 = 0 ;
08107   int val2 ;
08108   int ecode2 = 0 ;
08109   float val3 ;
08110   int ecode3 = 0 ;
08111   int val4 ;
08112   int ecode4 = 0 ;
08113   int res5 ;
08114   char *buf5 = 0 ;
08115   int alloc5 = 0 ;
08116   int val6 ;
08117   int ecode6 = 0 ;
08118   ArrayObject *array7 = NULL ;
08119   int is_new_object7 ;
08120   PyObject * obj0 = 0 ;
08121   PyObject * obj1 = 0 ;
08122   PyObject * obj2 = 0 ;
08123   PyObject * obj3 = 0 ;
08124   PyObject * obj4 = 0 ;
08125   PyObject * obj5 = 0 ;
08126   PyObject * obj6 = 0 ;
08127   int result;
08128   
08129   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cp_ecp",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
08130   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Superv_Component_i, 0 |  0 );
08131   if (!SWIG_IsOK(res1)) {
08132     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cp_ecp" "', argument " "1"" of type '" "Superv_Component_i *""'"); 
08133   }
08134   arg1 = reinterpret_cast< Superv_Component_i * >(argp1);
08135   ecode2 = SWIG_AsVal_int(obj1, &val2);
08136   if (!SWIG_IsOK(ecode2)) {
08137     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cp_ecp" "', argument " "2"" of type '" "int""'");
08138   } 
08139   arg2 = static_cast< int >(val2);
08140   ecode3 = SWIG_AsVal_float(obj2, &val3);
08141   if (!SWIG_IsOK(ecode3)) {
08142     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cp_ecp" "', argument " "3"" of type '" "float""'");
08143   } 
08144   arg3 = static_cast< float >(val3);
08145   ecode4 = SWIG_AsVal_int(obj3, &val4);
08146   if (!SWIG_IsOK(ecode4)) {
08147     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cp_ecp" "', argument " "4"" of type '" "int""'");
08148   } 
08149   arg4 = static_cast< int >(val4);
08150   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
08151   if (!SWIG_IsOK(res5)) {
08152     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cp_ecp" "', argument " "5"" of type '" "char *""'");
08153   }
08154   arg5 = reinterpret_cast< char * >(buf5);
08155   ecode6 = SWIG_AsVal_int(obj5, &val6);
08156   if (!SWIG_IsOK(ecode6)) {
08157     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cp_ecp" "', argument " "6"" of type '" "int""'");
08158   } 
08159   arg6 = static_cast< int >(val6);
08160   {
08161     if ((SWIG_ConvertPtr(obj6, (void **) &arg7, SWIGTYPE_p_float,0)) == -1)
08162     {
08163 #ifdef WITH_NUMPY
08164       int size[1] = {
08165         -1
08166       };
08167       array7 = obj_to_array_contiguous_allow_conversion(obj6, PyArray_CFLOAT, &is_new_object7);
08168       if (!array7 || !require_dimensions(array7,1) || !require_size(array7,size,1)) SWIG_fail;
08169       arg7 = (float*) array7->data;
08170 #else
08171       SWIG_exception(SWIG_TypeError, "complex array expected");
08172 #endif
08173     }
08174   }
08175   {
08176     Py_BEGIN_ALLOW_THREADS
08177     try {
08178       result = (int)cp_ecp(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
08179     }
08180     catch(Engines::DSC::PortNotDefined& _e) {
08181       Py_BLOCK_THREADS
08182       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
08183       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
08184       PyErr_SetObject(excc, exci);
08185       Py_XDECREF(excc);
08186       Py_XDECREF(exci);
08187       return NULL;
08188     }
08189     catch(Engines::DSC::PortNotConnected& _e) {
08190       Py_BLOCK_THREADS
08191       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
08192       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
08193       PyErr_SetObject(excc, exci);
08194       Py_XDECREF(excc);
08195       Py_XDECREF(exci);
08196       return NULL;
08197     }
08198     catch(Engines::DSC::BadPortType& _e) {
08199       Py_BLOCK_THREADS
08200       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
08201       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
08202       PyErr_SetObject(excc, exci);
08203       Py_XDECREF(excc);
08204       Py_XDECREF(exci);
08205       return NULL;
08206     }
08207     catch (SALOME_Exception &e) {
08208       Py_BLOCK_THREADS
08209       PyErr_SetString(PyExc_RuntimeError,e.what());
08210       return NULL;
08211     }
08212     catch (SALOME::SALOME_Exception &e) {
08213       Py_BLOCK_THREADS
08214       //This one should be converted into a python corba exception
08215       PyErr_SetString(PyExc_RuntimeError,e.details.text);
08216       return NULL;
08217     }
08218     catch (const CORBA::SystemException& e) {
08219       Py_BLOCK_THREADS 
08220       return api->handleCxxSystemException(e);
08221     }
08222     catch(...) {
08223       Py_BLOCK_THREADS
08224       PyErr_SetString(PyExc_ValueError,"Unknown exception");
08225       return NULL;
08226     }
08227     Py_END_ALLOW_THREADS
08228   }
08229   resultobj = SWIG_From_int(static_cast< int >(result));
08230   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
08231   {
08232 #ifdef WITH_NUMPY
08233     if (is_new_object7 && array7) 
08234     {
08235       Py_DECREF(array7);
08236     }
08237 #endif
08238   }
08239   return resultobj;
08240 fail:
08241   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
08242   {
08243 #ifdef WITH_NUMPY
08244     if (is_new_object7 && array7) 
08245     {
08246       Py_DECREF(array7);
08247     }
08248 #endif
08249   }
08250   return NULL;
08251 }
08252 
08253 
08254 SWIGINTERN PyObject *_wrap_cp_elo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08255   PyObject *resultobj = 0;
08256   Superv_Component_i *arg1 = (Superv_Component_i *) 0 ;
08257   int arg2 ;
08258   float arg3 ;
08259   int arg4 ;
08260   char *arg5 = (char *) 0 ;
08261   int arg6 ;
08262   int *arg7 = (int *) 0 ;
08263   void *argp1 = 0 ;
08264   int res1 = 0 ;
08265   int val2 ;
08266   int ecode2 = 0 ;
08267   float val3 ;
08268   int ecode3 = 0 ;
08269   int val4 ;
08270   int ecode4 = 0 ;
08271   int res5 ;
08272   char *buf5 = 0 ;
08273   int alloc5 = 0 ;
08274   int val6 ;
08275   int ecode6 = 0 ;
08276   ArrayObject *array7 = NULL ;
08277   int is_new_object7 ;
08278   PyObject * obj0 = 0 ;
08279   PyObject * obj1 = 0 ;
08280   PyObject * obj2 = 0 ;
08281   PyObject * obj3 = 0 ;
08282   PyObject * obj4 = 0 ;
08283   PyObject * obj5 = 0 ;
08284   PyObject * obj6 = 0 ;
08285   int result;
08286   
08287   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cp_elo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
08288   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Superv_Component_i, 0 |  0 );
08289   if (!SWIG_IsOK(res1)) {
08290     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cp_elo" "', argument " "1"" of type '" "Superv_Component_i *""'"); 
08291   }
08292   arg1 = reinterpret_cast< Superv_Component_i * >(argp1);
08293   ecode2 = SWIG_AsVal_int(obj1, &val2);
08294   if (!SWIG_IsOK(ecode2)) {
08295     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cp_elo" "', argument " "2"" of type '" "int""'");
08296   } 
08297   arg2 = static_cast< int >(val2);
08298   ecode3 = SWIG_AsVal_float(obj2, &val3);
08299   if (!SWIG_IsOK(ecode3)) {
08300     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cp_elo" "', argument " "3"" of type '" "float""'");
08301   } 
08302   arg3 = static_cast< float >(val3);
08303   ecode4 = SWIG_AsVal_int(obj3, &val4);
08304   if (!SWIG_IsOK(ecode4)) {
08305     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cp_elo" "', argument " "4"" of type '" "int""'");
08306   } 
08307   arg4 = static_cast< int >(val4);
08308   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
08309   if (!SWIG_IsOK(res5)) {
08310     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cp_elo" "', argument " "5"" of type '" "char *""'");
08311   }
08312   arg5 = reinterpret_cast< char * >(buf5);
08313   ecode6 = SWIG_AsVal_int(obj5, &val6);
08314   if (!SWIG_IsOK(ecode6)) {
08315     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cp_elo" "', argument " "6"" of type '" "int""'");
08316   } 
08317   arg6 = static_cast< int >(val6);
08318   {
08319     if ((SWIG_ConvertPtr(obj6, (void **) &arg7, SWIGTYPE_p_int,0)) == -1)
08320     {
08321 #ifdef WITH_NUMPY
08322       int size[1] = {
08323         -1
08324       };
08325       array7 = obj_to_array_contiguous_allow_conversion(obj6, PyArray_INT, &is_new_object7);
08326       if (!array7 || !require_dimensions(array7,1) || !require_size(array7,size,1)) SWIG_fail;
08327       arg7 = (int*) array7->data;
08328 #else
08329       SWIG_exception(SWIG_TypeError, "int* expected");
08330 #endif
08331     }
08332   }
08333   {
08334     Py_BEGIN_ALLOW_THREADS
08335     try {
08336       result = (int)cp_elo(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
08337     }
08338     catch(Engines::DSC::PortNotDefined& _e) {
08339       Py_BLOCK_THREADS
08340       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotDefined");
08341       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
08342       PyErr_SetObject(excc, exci);
08343       Py_XDECREF(excc);
08344       Py_XDECREF(exci);
08345       return NULL;
08346     }
08347     catch(Engines::DSC::PortNotConnected& _e) {
08348       Py_BLOCK_THREADS
08349       PyObject* excc = PyObject_GetAttrString(dsc, "PortNotConnected");
08350       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
08351       PyErr_SetObject(excc, exci);
08352       Py_XDECREF(excc);
08353       Py_XDECREF(exci);
08354       return NULL;
08355     }
08356     catch(Engines::DSC::BadPortType& _e) {
08357       Py_BLOCK_THREADS
08358       PyObject* excc = PyObject_GetAttrString(dsc, "BadPortType");
08359       PyObject* exci = PyEval_CallObject(excc, (PyObject *)NULL);
08360       PyErr_SetObject(excc, exci);
08361       Py_XDECREF(excc);
08362       Py_XDECREF(exci);
08363       return NULL;
08364     }
08365     catch (SALOME_Exception &e) {
08366       Py_BLOCK_THREADS
08367       PyErr_SetString(PyExc_RuntimeError,e.what());
08368       return NULL;
08369     }
08370     catch (SALOME::SALOME_Exception &e) {
08371       Py_BLOCK_THREADS
08372       //This one should be converted into a python corba exception
08373       PyErr_SetString(PyExc_RuntimeError,e.details.text);
08374       return NULL;
08375     }
08376     catch (const CORBA::SystemException& e) {
08377       Py_BLOCK_THREADS 
08378       return api->handleCxxSystemException(e);
08379     }
08380     catch(...) {
08381       Py_BLOCK_THREADS
08382       PyErr_SetString(PyExc_ValueError,"Unknown exception");
08383       return NULL;
08384     }
08385     Py_END_ALLOW_THREADS
08386   }
08387   resultobj = SWIG_From_int(static_cast< int >(result));
08388   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
08389   {
08390 #ifdef WITH_NUMPY
08391     if (is_new_object7 && array7) 
08392     {
08393       Py_DECREF(array7);
08394     }
08395 #endif
08396   }
08397   return resultobj;
08398 fail:
08399   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
08400   {
08401 #ifdef WITH_NUMPY
08402     if (is_new_object7 && array7) 
08403     {
08404       Py_DECREF(array7);
08405     }
08406 #endif
08407   }
08408   return NULL;
08409 }
08410 
08411 
08412 SWIGINTERN PyObject *_wrap_cp_ech(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08413   PyObject *resultobj = 0;
08414   Superv_Component_i *arg1 = (Superv_Component_i *) 0 ;
08415   int arg2 ;
08416   float arg3 ;
08417   int arg4 ;
08418   char *arg5 = (char *) 0 ;
08419   int arg6 ;
08420   char **arg7 = (char **) 0 ;
08421   int arg8 ;
08422   void *argp1 = 0 ;
08423   int res1 = 0 ;
08424   int val2 ;
08425   int ecode2 = 0 ;