Back to index

salome-kernel  6.5.0
swig_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 /* -------- TYPES TABLE (BEGIN) -------- */
02684 
02685 #define SWIGTYPE_p_CORBA__ORB_ptr swig_types[0]
02686 #define SWIGTYPE_p_Engines__ContainerParameters swig_types[1]
02687 #define SWIGTYPE_p_Engines__MachineParameters swig_types[2]
02688 #define SWIGTYPE_p_Engines__ResourceParameters swig_types[3]
02689 #define SWIGTYPE_p_IncompatibleComponent swig_types[4]
02690 #define SWIGTYPE_p_SALOME_Exception swig_types[5]
02691 #define SWIGTYPE_p_SALOME_FileTransferCORBA swig_types[6]
02692 #define SWIGTYPE_p_SALOME_LifeCycleCORBA swig_types[7]
02693 #define SWIGTYPE_p_SALOME_NamingService swig_types[8]
02694 #define SWIGTYPE_p_char swig_types[9]
02695 #define SWIGTYPE_p_std__exception swig_types[10]
02696 static swig_type_info *swig_types[12];
02697 static swig_module_info swig_module = {swig_types, 11, 0, 0, 0, 0};
02698 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
02699 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
02700 
02701 /* -------- TYPES TABLE (END) -------- */
02702 
02703 #if (PY_VERSION_HEX <= 0x02000000)
02704 # if !defined(SWIG_PYTHON_CLASSIC)
02705 #  error "This python version requires swig to be run with the '-classic' option"
02706 # endif
02707 #endif
02708 
02709 /*-----------------------------------------------
02710               @(target):= _libSALOME_LifeCycleCORBA.so
02711   ------------------------------------------------*/
02712 #if PY_VERSION_HEX >= 0x03000000
02713 #  define SWIG_init    PyInit__libSALOME_LifeCycleCORBA
02714 
02715 #else
02716 #  define SWIG_init    init_libSALOME_LifeCycleCORBA
02717 
02718 #endif
02719 #define SWIG_name    "_libSALOME_LifeCycleCORBA"
02720 
02721 #define SWIGVERSION 0x010340 
02722 #define SWIG_VERSION SWIGVERSION
02723 
02724 
02725 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
02726 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
02727 
02728 
02729 #include <stdexcept>
02730 
02731 
02732 namespace swig {
02733   class SwigPtr_PyObject {
02734   protected:
02735     PyObject *_obj;
02736 
02737   public:
02738     SwigPtr_PyObject() :_obj(0)
02739     {
02740     }
02741 
02742     SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
02743     {
02744       Py_XINCREF(_obj);      
02745     }
02746     
02747     SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
02748     {
02749       if (initial_ref) {
02750         Py_XINCREF(_obj);
02751       }
02752     }
02753     
02754     SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
02755     {
02756       Py_XINCREF(item._obj);
02757       Py_XDECREF(_obj);
02758       _obj = item._obj;
02759       return *this;      
02760     }
02761     
02762     ~SwigPtr_PyObject() 
02763     {
02764       Py_XDECREF(_obj);
02765     }
02766     
02767     operator PyObject *() const
02768     {
02769       return _obj;
02770     }
02771 
02772     PyObject *operator->() const
02773     {
02774       return _obj;
02775     }
02776   };
02777 }
02778 
02779 
02780 namespace swig {
02781   struct SwigVar_PyObject : SwigPtr_PyObject {
02782     SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
02783     
02784     SwigVar_PyObject & operator = (PyObject* obj)
02785     {
02786       Py_XDECREF(_obj);
02787       _obj = obj;
02788       return *this;      
02789     }
02790   };
02791 }
02792 
02793 
02794 #include <stdexcept>
02795 
02796 
02797 #include <string>
02798 
02799 
02800 #include "utilities.h"
02801 #include "SALOME_LifeCycleCORBA.hxx"
02802 #include "SALOME_FileTransferCORBA.hxx"
02803 #include "SALOME_NamingService.hxx"
02804 #include "ServiceUnreachable.hxx"
02805 #include "Utils_SALOME_Exception.hxx"
02806 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
02807 typedef int Py_ssize_t;
02808 #define PY_SSIZE_T_MAX INT_MAX
02809 #define PY_SSIZE_T_MIN INT_MIN
02810 #endif
02811 
02812 //--- from omniORBpy.h (not present on Debian Sarge packages)
02813 
02814 struct omniORBpyAPI {
02815 
02816   PyObject* (*cxxObjRefToPyObjRef)(const CORBA::Object_ptr cxx_obj,
02817                                    CORBA::Boolean hold_lock);
02818   // Convert a C++ object reference to a Python object reference.
02819   // If <hold_lock> is true, caller holds the Python interpreter lock.
02820 
02821   CORBA::Object_ptr (*pyObjRefToCxxObjRef)(PyObject* py_obj,
02822                                            CORBA::Boolean hold_lock);
02823   // Convert a Python object reference to a C++ object reference.
02824   // Raises BAD_PARAM if the Python object is not an object reference.
02825   // If <hold_lock> is true, caller holds the Python interpreter lock.
02826 
02827 
02828   omniORBpyAPI();
02829   // Constructor for the singleton. Sets up the function pointers.
02830 };
02831 
02832 omniORBpyAPI* api;
02833 
02834 
02835 
02836 SWIGINTERN swig_type_info*
02837 SWIG_pchar_descriptor(void)
02838 {
02839   static int init = 0;
02840   static swig_type_info* info = 0;
02841   if (!init) {
02842     info = SWIG_TypeQuery("_p_char");
02843     init = 1;
02844   }
02845   return info;
02846 }
02847 
02848 
02849 SWIGINTERN int
02850 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
02851 {
02852 #if PY_VERSION_HEX>=0x03000000
02853   if (PyUnicode_Check(obj))
02854 #else  
02855   if (PyString_Check(obj))
02856 #endif
02857   {
02858     char *cstr; Py_ssize_t len;
02859 #if PY_VERSION_HEX>=0x03000000
02860     if (!alloc && cptr) {
02861         /* We can't allow converting without allocation, since the internal
02862            representation of string in Python 3 is UCS-2/UCS-4 but we require
02863            a UTF-8 representation.
02864            TODO(bhy) More detailed explanation */
02865         return SWIG_RuntimeError;
02866     }
02867     obj = PyUnicode_AsUTF8String(obj);
02868     PyBytes_AsStringAndSize(obj, &cstr, &len);
02869     if(alloc) *alloc = SWIG_NEWOBJ;
02870 #else
02871     PyString_AsStringAndSize(obj, &cstr, &len);
02872 #endif
02873     if (cptr) {
02874       if (alloc) {
02875        /* 
02876           In python the user should not be able to modify the inner
02877           string representation. To warranty that, if you define
02878           SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
02879           buffer is always returned.
02880 
02881           The default behavior is just to return the pointer value,
02882           so, be careful.
02883        */ 
02884 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
02885        if (*alloc != SWIG_OLDOBJ) 
02886 #else
02887        if (*alloc == SWIG_NEWOBJ) 
02888 #endif
02889          {
02890            *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
02891            *alloc = SWIG_NEWOBJ;
02892          }
02893        else {
02894          *cptr = cstr;
02895          *alloc = SWIG_OLDOBJ;
02896        }
02897       } else {
02898         #if PY_VERSION_HEX>=0x03000000
02899         assert(0); /* Should never reach here in Python 3 */
02900         #endif
02901        *cptr = SWIG_Python_str_AsChar(obj);
02902       }
02903     }
02904     if (psize) *psize = len + 1;
02905 #if PY_VERSION_HEX>=0x03000000
02906     Py_XDECREF(obj);
02907 #endif
02908     return SWIG_OK;
02909   } else {
02910     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
02911     if (pchar_descriptor) {
02912       void* vptr = 0;
02913       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
02914        if (cptr) *cptr = (char *) vptr;
02915        if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
02916        if (alloc) *alloc = SWIG_OLDOBJ;
02917        return SWIG_OK;
02918       }
02919     }
02920   }
02921   return SWIG_TypeError;
02922 }
02923 
02924 
02925 
02926 
02927 
02928 #include <limits.h>
02929 #if !defined(SWIG_NO_LLONG_MAX)
02930 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
02931 #   define LLONG_MAX __LONG_LONG_MAX__
02932 #   define LLONG_MIN (-LLONG_MAX - 1LL)
02933 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
02934 # endif
02935 #endif
02936 
02937 
02938 SWIGINTERN int
02939 SWIG_AsVal_double (PyObject *obj, double *val)
02940 {
02941   int res = SWIG_TypeError;
02942   if (PyFloat_Check(obj)) {
02943     if (val) *val = PyFloat_AsDouble(obj);
02944     return SWIG_OK;
02945   } else if (PyInt_Check(obj)) {
02946     if (val) *val = PyInt_AsLong(obj);
02947     return SWIG_OK;
02948   } else if (PyLong_Check(obj)) {
02949     double v = PyLong_AsDouble(obj);
02950     if (!PyErr_Occurred()) {
02951       if (val) *val = v;
02952       return SWIG_OK;
02953     } else {
02954       PyErr_Clear();
02955     }
02956   }
02957 #ifdef SWIG_PYTHON_CAST_MODE
02958   {
02959     int dispatch = 0;
02960     double d = PyFloat_AsDouble(obj);
02961     if (!PyErr_Occurred()) {
02962       if (val) *val = d;
02963       return SWIG_AddCast(SWIG_OK);
02964     } else {
02965       PyErr_Clear();
02966     }
02967     if (!dispatch) {
02968       long v = PyLong_AsLong(obj);
02969       if (!PyErr_Occurred()) {
02970        if (val) *val = v;
02971        return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
02972       } else {
02973        PyErr_Clear();
02974       }
02975     }
02976   }
02977 #endif
02978   return res;
02979 }
02980 
02981 
02982 #include <float.h>
02983 
02984 
02985 #include <math.h>
02986 
02987 
02988 SWIGINTERNINLINE int
02989 SWIG_CanCastAsInteger(double *d, double min, double max) {
02990   double x = *d;
02991   if ((min <= x && x <= max)) {
02992    double fx = floor(x);
02993    double cx = ceil(x);
02994    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
02995    if ((errno == EDOM) || (errno == ERANGE)) {
02996      errno = 0;
02997    } else {
02998      double summ, reps, diff;
02999      if (rd < x) {
03000        diff = x - rd;
03001      } else if (rd > x) {
03002        diff = rd - x;
03003      } else {
03004        return 1;
03005      }
03006      summ = rd + x;
03007      reps = diff/summ;
03008      if (reps < 8*DBL_EPSILON) {
03009        *d = rd;
03010        return 1;
03011      }
03012    }
03013   }
03014   return 0;
03015 }
03016 
03017 
03018 SWIGINTERN int
03019 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
03020 {
03021   if (PyInt_Check(obj)) {
03022     long v = PyInt_AsLong(obj);
03023     if (v >= 0) {
03024       if (val) *val = v;
03025       return SWIG_OK;
03026     } else {
03027       return SWIG_OverflowError;
03028     }
03029   } else if (PyLong_Check(obj)) {
03030     unsigned long v = PyLong_AsUnsignedLong(obj);
03031     if (!PyErr_Occurred()) {
03032       if (val) *val = v;
03033       return SWIG_OK;
03034     } else {
03035       PyErr_Clear();
03036     }
03037   }
03038 #ifdef SWIG_PYTHON_CAST_MODE
03039   {
03040     int dispatch = 0;
03041     unsigned long v = PyLong_AsUnsignedLong(obj);
03042     if (!PyErr_Occurred()) {
03043       if (val) *val = v;
03044       return SWIG_AddCast(SWIG_OK);
03045     } else {
03046       PyErr_Clear();
03047     }
03048     if (!dispatch) {
03049       double d;
03050       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
03051       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
03052        if (val) *val = (unsigned long)(d);
03053        return res;
03054       }
03055     }
03056   }
03057 #endif
03058   return SWIG_TypeError;
03059 }
03060 
03061 
03062 SWIGINTERN int
03063 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
03064 {
03065   unsigned long v;
03066   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
03067   if (SWIG_IsOK(res)) {
03068     if ((v > UINT_MAX)) {
03069       return SWIG_OverflowError;
03070     } else {
03071       if (val) *val = static_cast< unsigned int >(v);
03072     }
03073   }  
03074   return res;
03075 }
03076 
03077 
03078 SWIGINTERNINLINE PyObject *
03079 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
03080 {
03081   if (carray) {
03082     if (size > INT_MAX) {
03083       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
03084       return pchar_descriptor ? 
03085        SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
03086     } else {
03087 #if PY_VERSION_HEX >= 0x03000000
03088       return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
03089 #else
03090       return PyString_FromStringAndSize(carray, static_cast< int >(size));
03091 #endif
03092     }
03093   } else {
03094     return SWIG_Py_Void();
03095   }
03096 }
03097 
03098 
03099 SWIGINTERNINLINE PyObject * 
03100 SWIG_FromCharPtr(const char *cptr)
03101 { 
03102   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
03103 }
03104 
03105 
03106 SWIGINTERN int
03107 SWIG_AsVal_long (PyObject *obj, long* val)
03108 {
03109   if (PyInt_Check(obj)) {
03110     if (val) *val = PyInt_AsLong(obj);
03111     return SWIG_OK;
03112   } else if (PyLong_Check(obj)) {
03113     long v = PyLong_AsLong(obj);
03114     if (!PyErr_Occurred()) {
03115       if (val) *val = v;
03116       return SWIG_OK;
03117     } else {
03118       PyErr_Clear();
03119     }
03120   }
03121 #ifdef SWIG_PYTHON_CAST_MODE
03122   {
03123     int dispatch = 0;
03124     long v = PyInt_AsLong(obj);
03125     if (!PyErr_Occurred()) {
03126       if (val) *val = v;
03127       return SWIG_AddCast(SWIG_OK);
03128     } else {
03129       PyErr_Clear();
03130     }
03131     if (!dispatch) {
03132       double d;
03133       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
03134       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
03135        if (val) *val = (long)(d);
03136        return res;
03137       }
03138     }
03139   }
03140 #endif
03141   return SWIG_TypeError;
03142 }
03143 
03144 
03145 SWIGINTERN int
03146 SWIG_AsVal_int (PyObject * obj, int *val)
03147 {
03148   long v;
03149   int res = SWIG_AsVal_long (obj, &v);
03150   if (SWIG_IsOK(res)) {
03151     if ((v < INT_MIN || v > INT_MAX)) {
03152       return SWIG_OverflowError;
03153     } else {
03154       if (val) *val = static_cast< int >(v);
03155     }
03156   }  
03157   return res;
03158 }
03159 
03160 
03161 SWIGINTERNINLINE PyObject*
03162   SWIG_From_bool  (bool value)
03163 {
03164   return PyBool_FromLong(value ? 1 : 0);
03165 }
03166 
03167 
03168   #define SWIG_From_long   PyInt_FromLong 
03169 
03170 
03171 SWIGINTERNINLINE PyObject *
03172 SWIG_From_int  (int value)
03173 {    
03174   return SWIG_From_long  (value);
03175 }
03176 
03177 
03178 SWIGINTERN int
03179 SWIG_AsPtr_std_string (PyObject * obj, std::string **val) 
03180 {
03181   char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
03182   if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
03183     if (buf) {
03184       if (val) *val = new std::string(buf, size - 1);
03185       if (alloc == SWIG_NEWOBJ) delete[] buf;
03186       return SWIG_NEWOBJ;
03187     } else {
03188       if (val) *val = 0;
03189       return SWIG_OLDOBJ;
03190     }
03191   } else {
03192     static int init = 0;
03193     static swig_type_info* descriptor = 0;
03194     if (!init) {
03195       descriptor = SWIG_TypeQuery("std::string" " *");
03196       init = 1;
03197     }
03198     if (descriptor) {
03199       std::string *vptr;
03200       int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
03201       if (SWIG_IsOK(res) && val) *val = vptr;
03202       return res;
03203     }
03204   }
03205   return SWIG_ERROR;
03206 }
03207 
03208 
03209 SWIGINTERNINLINE PyObject *
03210 SWIG_From_std_string  (const std::string& s)
03211 {
03212   if (s.size()) {
03213     return SWIG_FromCharPtrAndSize(s.data(), s.size());
03214   } else {
03215     return SWIG_FromCharPtrAndSize(s.c_str(), 0);
03216   }
03217 }
03218 
03219 #ifdef __cplusplus
03220 extern "C" {
03221 #endif
03222 SWIGINTERN PyObject *_wrap_makeText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03223   PyObject *resultobj = 0;
03224   char *arg1 = (char *) 0 ;
03225   char *arg2 = (char *) 0 ;
03226   unsigned int arg3 ;
03227   int res1 ;
03228   char *buf1 = 0 ;
03229   int alloc1 = 0 ;
03230   int res2 ;
03231   char *buf2 = 0 ;
03232   int alloc2 = 0 ;
03233   unsigned int val3 ;
03234   int ecode3 = 0 ;
03235   PyObject * obj0 = 0 ;
03236   PyObject * obj1 = 0 ;
03237   PyObject * obj2 = 0 ;
03238   char *result = 0 ;
03239   
03240   if (!PyArg_ParseTuple(args,(char *)"OOO:makeText",&obj0,&obj1,&obj2)) SWIG_fail;
03241   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
03242   if (!SWIG_IsOK(res1)) {
03243     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "makeText" "', argument " "1"" of type '" "char const *""'");
03244   }
03245   arg1 = reinterpret_cast< char * >(buf1);
03246   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
03247   if (!SWIG_IsOK(res2)) {
03248     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "makeText" "', argument " "2"" of type '" "char const *""'");
03249   }
03250   arg2 = reinterpret_cast< char * >(buf2);
03251   ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
03252   if (!SWIG_IsOK(ecode3)) {
03253     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "makeText" "', argument " "3"" of type '" "unsigned int""'");
03254   } 
03255   arg3 = static_cast< unsigned int >(val3);
03256   result = (char *)makeText((char const *)arg1,(char const *)arg2,arg3);
03257   resultobj = SWIG_FromCharPtr((const char *)result);
03258   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
03259   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03260   return resultobj;
03261 fail:
03262   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
03263   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03264   return NULL;
03265 }
03266 
03267 
03268 SWIGINTERN PyObject *_wrap_new_SALOME_Exception__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03269   PyObject *resultobj = 0;
03270   char *arg1 = (char *) 0 ;
03271   char *arg2 = (char *) 0 ;
03272   unsigned int arg3 ;
03273   int res1 ;
03274   char *buf1 = 0 ;
03275   int alloc1 = 0 ;
03276   int res2 ;
03277   char *buf2 = 0 ;
03278   int alloc2 = 0 ;
03279   unsigned int val3 ;
03280   int ecode3 = 0 ;
03281   PyObject * obj0 = 0 ;
03282   PyObject * obj1 = 0 ;
03283   PyObject * obj2 = 0 ;
03284   SALOME_Exception *result = 0 ;
03285   
03286   if (!PyArg_ParseTuple(args,(char *)"OOO:new_SALOME_Exception",&obj0,&obj1,&obj2)) SWIG_fail;
03287   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
03288   if (!SWIG_IsOK(res1)) {
03289     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SALOME_Exception" "', argument " "1"" of type '" "char const *""'");
03290   }
03291   arg1 = reinterpret_cast< char * >(buf1);
03292   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
03293   if (!SWIG_IsOK(res2)) {
03294     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SALOME_Exception" "', argument " "2"" of type '" "char const *""'");
03295   }
03296   arg2 = reinterpret_cast< char * >(buf2);
03297   ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
03298   if (!SWIG_IsOK(ecode3)) {
03299     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SALOME_Exception" "', argument " "3"" of type '" "unsigned int""'");
03300   } 
03301   arg3 = static_cast< unsigned int >(val3);
03302   result = (SALOME_Exception *)new SALOME_Exception((char const *)arg1,(char const *)arg2,arg3);
03303   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SALOME_Exception, SWIG_POINTER_NEW |  0 );
03304   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
03305   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03306   return resultobj;
03307 fail:
03308   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
03309   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03310   return NULL;
03311 }
03312 
03313 
03314 SWIGINTERN PyObject *_wrap_new_SALOME_Exception__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03315   PyObject *resultobj = 0;
03316   char *arg1 = (char *) 0 ;
03317   char *arg2 = (char *) 0 ;
03318   int res1 ;
03319   char *buf1 = 0 ;
03320   int alloc1 = 0 ;
03321   int res2 ;
03322   char *buf2 = 0 ;
03323   int alloc2 = 0 ;
03324   PyObject * obj0 = 0 ;
03325   PyObject * obj1 = 0 ;
03326   SALOME_Exception *result = 0 ;
03327   
03328   if (!PyArg_ParseTuple(args,(char *)"OO:new_SALOME_Exception",&obj0,&obj1)) SWIG_fail;
03329   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
03330   if (!SWIG_IsOK(res1)) {
03331     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SALOME_Exception" "', argument " "1"" of type '" "char const *""'");
03332   }
03333   arg1 = reinterpret_cast< char * >(buf1);
03334   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
03335   if (!SWIG_IsOK(res2)) {
03336     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SALOME_Exception" "', argument " "2"" of type '" "char const *""'");
03337   }
03338   arg2 = reinterpret_cast< char * >(buf2);
03339   result = (SALOME_Exception *)new SALOME_Exception((char const *)arg1,(char const *)arg2);
03340   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SALOME_Exception, SWIG_POINTER_NEW |  0 );
03341   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
03342   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03343   return resultobj;
03344 fail:
03345   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
03346   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03347   return NULL;
03348 }
03349 
03350 
03351 SWIGINTERN PyObject *_wrap_new_SALOME_Exception__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03352   PyObject *resultobj = 0;
03353   char *arg1 = (char *) 0 ;
03354   int res1 ;
03355   char *buf1 = 0 ;
03356   int alloc1 = 0 ;
03357   PyObject * obj0 = 0 ;
03358   SALOME_Exception *result = 0 ;
03359   
03360   if (!PyArg_ParseTuple(args,(char *)"O:new_SALOME_Exception",&obj0)) SWIG_fail;
03361   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
03362   if (!SWIG_IsOK(res1)) {
03363     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SALOME_Exception" "', argument " "1"" of type '" "char const *""'");
03364   }
03365   arg1 = reinterpret_cast< char * >(buf1);
03366   result = (SALOME_Exception *)new SALOME_Exception((char const *)arg1);
03367   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SALOME_Exception, SWIG_POINTER_NEW |  0 );
03368   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
03369   return resultobj;
03370 fail:
03371   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
03372   return NULL;
03373 }
03374 
03375 
03376 SWIGINTERN PyObject *_wrap_new_SALOME_Exception__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03377   PyObject *resultobj = 0;
03378   SALOME_Exception *arg1 = 0 ;
03379   void *argp1 = 0 ;
03380   int res1 = 0 ;
03381   PyObject * obj0 = 0 ;
03382   SALOME_Exception *result = 0 ;
03383   
03384   if (!PyArg_ParseTuple(args,(char *)"O:new_SALOME_Exception",&obj0)) SWIG_fail;
03385   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SALOME_Exception,  0  | 0);
03386   if (!SWIG_IsOK(res1)) {
03387     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SALOME_Exception" "', argument " "1"" of type '" "SALOME_Exception const &""'"); 
03388   }
03389   if (!argp1) {
03390     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SALOME_Exception" "', argument " "1"" of type '" "SALOME_Exception const &""'"); 
03391   }
03392   arg1 = reinterpret_cast< SALOME_Exception * >(argp1);
03393   result = (SALOME_Exception *)new SALOME_Exception((SALOME_Exception const &)*arg1);
03394   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SALOME_Exception, SWIG_POINTER_NEW |  0 );
03395   return resultobj;
03396 fail:
03397   return NULL;
03398 }
03399 
03400 
03401 SWIGINTERN PyObject *_wrap_new_SALOME_Exception(PyObject *self, PyObject *args) {
03402   int argc;
03403   PyObject *argv[4];
03404   int ii;
03405   
03406   if (!PyTuple_Check(args)) SWIG_fail;
03407   argc = (int)PyObject_Length(args);
03408   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
03409     argv[ii] = PyTuple_GET_ITEM(args,ii);
03410   }
03411   if (argc == 1) {
03412     int _v;
03413     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SALOME_Exception, 0);
03414     _v = SWIG_CheckState(res);
03415     if (_v) {
03416       return _wrap_new_SALOME_Exception__SWIG_3(self, args);
03417     }
03418   }
03419   if (argc == 1) {
03420     int _v;
03421     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
03422     _v = SWIG_CheckState(res);
03423     if (_v) {
03424       return _wrap_new_SALOME_Exception__SWIG_2(self, args);
03425     }
03426   }
03427   if (argc == 2) {
03428     int _v;
03429     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
03430     _v = SWIG_CheckState(res);
03431     if (_v) {
03432       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
03433       _v = SWIG_CheckState(res);
03434       if (_v) {
03435         return _wrap_new_SALOME_Exception__SWIG_1(self, args);
03436       }
03437     }
03438   }
03439   if (argc == 3) {
03440     int _v;
03441     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
03442     _v = SWIG_CheckState(res);
03443     if (_v) {
03444       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
03445       _v = SWIG_CheckState(res);
03446       if (_v) {
03447         {
03448           int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
03449           _v = SWIG_CheckState(res);
03450         }
03451         if (_v) {
03452           return _wrap_new_SALOME_Exception__SWIG_0(self, args);
03453         }
03454       }
03455     }
03456   }
03457   
03458 fail:
03459   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SALOME_Exception'.\n"
03460     "  Possible C/C++ prototypes are:\n"
03461     "    SALOME_Exception(char const *,char const *,unsigned int const)\n"
03462     "    SALOME_Exception(char const *,char const *)\n"
03463     "    SALOME_Exception(char const *)\n"
03464     "    SALOME_Exception(SALOME_Exception const &)\n");
03465   return NULL;
03466 }
03467 
03468 
03469 SWIGINTERN PyObject *_wrap_delete_SALOME_Exception(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03470   PyObject *resultobj = 0;
03471   SALOME_Exception *arg1 = (SALOME_Exception *) 0 ;
03472   void *argp1 = 0 ;
03473   int res1 = 0 ;
03474   PyObject * obj0 = 0 ;
03475   
03476   if (!PyArg_ParseTuple(args,(char *)"O:delete_SALOME_Exception",&obj0)) SWIG_fail;
03477   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_Exception, SWIG_POINTER_DISOWN |  0 );
03478   if (!SWIG_IsOK(res1)) {
03479     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SALOME_Exception" "', argument " "1"" of type '" "SALOME_Exception *""'"); 
03480   }
03481   arg1 = reinterpret_cast< SALOME_Exception * >(argp1);
03482   delete arg1;
03483   resultobj = SWIG_Py_Void();
03484   return resultobj;
03485 fail:
03486   return NULL;
03487 }
03488 
03489 
03490 SWIGINTERN PyObject *_wrap_SALOME_Exception_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03491   PyObject *resultobj = 0;
03492   SALOME_Exception *arg1 = (SALOME_Exception *) 0 ;
03493   void *argp1 = 0 ;
03494   int res1 = 0 ;
03495   PyObject * obj0 = 0 ;
03496   char *result = 0 ;
03497   
03498   if (!PyArg_ParseTuple(args,(char *)"O:SALOME_Exception_what",&obj0)) SWIG_fail;
03499   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_Exception, 0 |  0 );
03500   if (!SWIG_IsOK(res1)) {
03501     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_Exception_what" "', argument " "1"" of type '" "SALOME_Exception const *""'"); 
03502   }
03503   arg1 = reinterpret_cast< SALOME_Exception * >(argp1);
03504   result = (char *)((SALOME_Exception const *)arg1)->what();
03505   resultobj = SWIG_FromCharPtr((const char *)result);
03506   return resultobj;
03507 fail:
03508   return NULL;
03509 }
03510 
03511 
03512 SWIGINTERN PyObject *SALOME_Exception_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03513   PyObject *obj;
03514   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
03515   SWIG_TypeNewClientData(SWIGTYPE_p_SALOME_Exception, SWIG_NewClientData(obj));
03516   return SWIG_Py_Void();
03517 }
03518 
03519 SWIGINTERN PyObject *_wrap_new_IncompatibleComponent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03520   PyObject *resultobj = 0;
03521   IncompatibleComponent *result = 0 ;
03522   
03523   if (!PyArg_ParseTuple(args,(char *)":new_IncompatibleComponent")) SWIG_fail;
03524   {
03525     Py_BEGIN_ALLOW_THREADS
03526     try {
03527       result = (IncompatibleComponent *)new IncompatibleComponent();
03528     }
03529     catch (ServiceUnreachable) {
03530       Py_BLOCK_THREADS
03531       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
03532       return NULL;
03533     }
03534     catch (SALOME_Exception &e) {
03535       Py_BLOCK_THREADS
03536       PyErr_SetString(PyExc_RuntimeError,e.what());
03537       return NULL;
03538     }
03539     catch (SALOME::SALOME_Exception &e) {
03540       Py_BLOCK_THREADS
03541       PyErr_SetString(PyExc_RuntimeError,e.details.text);
03542       return NULL;
03543     }
03544     catch (...) {
03545       Py_BLOCK_THREADS
03546       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
03547       return NULL;
03548     }
03549     Py_END_ALLOW_THREADS
03550   }
03551   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IncompatibleComponent, SWIG_POINTER_NEW |  0 );
03552   return resultobj;
03553 fail:
03554   return NULL;
03555 }
03556 
03557 
03558 SWIGINTERN PyObject *_wrap_new_IncompatibleComponent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03559   PyObject *resultobj = 0;
03560   IncompatibleComponent *arg1 = 0 ;
03561   void *argp1 = 0 ;
03562   int res1 = 0 ;
03563   PyObject * obj0 = 0 ;
03564   IncompatibleComponent *result = 0 ;
03565   
03566   if (!PyArg_ParseTuple(args,(char *)"O:new_IncompatibleComponent",&obj0)) SWIG_fail;
03567   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_IncompatibleComponent,  0  | 0);
03568   if (!SWIG_IsOK(res1)) {
03569     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IncompatibleComponent" "', argument " "1"" of type '" "IncompatibleComponent const &""'"); 
03570   }
03571   if (!argp1) {
03572     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IncompatibleComponent" "', argument " "1"" of type '" "IncompatibleComponent const &""'"); 
03573   }
03574   arg1 = reinterpret_cast< IncompatibleComponent * >(argp1);
03575   {
03576     Py_BEGIN_ALLOW_THREADS
03577     try {
03578       result = (IncompatibleComponent *)new IncompatibleComponent((IncompatibleComponent const &)*arg1);
03579     }
03580     catch (ServiceUnreachable) {
03581       Py_BLOCK_THREADS
03582       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
03583       return NULL;
03584     }
03585     catch (SALOME_Exception &e) {
03586       Py_BLOCK_THREADS
03587       PyErr_SetString(PyExc_RuntimeError,e.what());
03588       return NULL;
03589     }
03590     catch (SALOME::SALOME_Exception &e) {
03591       Py_BLOCK_THREADS
03592       PyErr_SetString(PyExc_RuntimeError,e.details.text);
03593       return NULL;
03594     }
03595     catch (...) {
03596       Py_BLOCK_THREADS
03597       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
03598       return NULL;
03599     }
03600     Py_END_ALLOW_THREADS
03601   }
03602   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IncompatibleComponent, SWIG_POINTER_NEW |  0 );
03603   return resultobj;
03604 fail:
03605   return NULL;
03606 }
03607 
03608 
03609 SWIGINTERN PyObject *_wrap_new_IncompatibleComponent(PyObject *self, PyObject *args) {
03610   int argc;
03611   PyObject *argv[2];
03612   int ii;
03613   
03614   if (!PyTuple_Check(args)) SWIG_fail;
03615   argc = (int)PyObject_Length(args);
03616   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
03617     argv[ii] = PyTuple_GET_ITEM(args,ii);
03618   }
03619   if (argc == 0) {
03620     return _wrap_new_IncompatibleComponent__SWIG_0(self, args);
03621   }
03622   if (argc == 1) {
03623     int _v;
03624     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_IncompatibleComponent, 0);
03625     _v = SWIG_CheckState(res);
03626     if (_v) {
03627       return _wrap_new_IncompatibleComponent__SWIG_1(self, args);
03628     }
03629   }
03630   
03631 fail:
03632   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IncompatibleComponent'.\n"
03633     "  Possible C/C++ prototypes are:\n"
03634     "    IncompatibleComponent()\n"
03635     "    IncompatibleComponent(IncompatibleComponent const &)\n");
03636   return NULL;
03637 }
03638 
03639 
03640 SWIGINTERN PyObject *_wrap_delete_IncompatibleComponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03641   PyObject *resultobj = 0;
03642   IncompatibleComponent *arg1 = (IncompatibleComponent *) 0 ;
03643   void *argp1 = 0 ;
03644   int res1 = 0 ;
03645   PyObject * obj0 = 0 ;
03646   
03647   if (!PyArg_ParseTuple(args,(char *)"O:delete_IncompatibleComponent",&obj0)) SWIG_fail;
03648   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_IncompatibleComponent, SWIG_POINTER_DISOWN |  0 );
03649   if (!SWIG_IsOK(res1)) {
03650     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncompatibleComponent" "', argument " "1"" of type '" "IncompatibleComponent *""'"); 
03651   }
03652   arg1 = reinterpret_cast< IncompatibleComponent * >(argp1);
03653   {
03654     Py_BEGIN_ALLOW_THREADS
03655     try {
03656       delete arg1;
03657     }
03658     catch (ServiceUnreachable) {
03659       Py_BLOCK_THREADS
03660       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
03661       return NULL;
03662     }
03663     catch (SALOME_Exception &e) {
03664       Py_BLOCK_THREADS
03665       PyErr_SetString(PyExc_RuntimeError,e.what());
03666       return NULL;
03667     }
03668     catch (SALOME::SALOME_Exception &e) {
03669       Py_BLOCK_THREADS
03670       PyErr_SetString(PyExc_RuntimeError,e.details.text);
03671       return NULL;
03672     }
03673     catch (...) {
03674       Py_BLOCK_THREADS
03675       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
03676       return NULL;
03677     }
03678     Py_END_ALLOW_THREADS
03679   }
03680   resultobj = SWIG_Py_Void();
03681   return resultobj;
03682 fail:
03683   return NULL;
03684 }
03685 
03686 
03687 SWIGINTERN PyObject *IncompatibleComponent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03688   PyObject *obj;
03689   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
03690   SWIG_TypeNewClientData(SWIGTYPE_p_IncompatibleComponent, SWIG_NewClientData(obj));
03691   return SWIG_Py_Void();
03692 }
03693 
03694 SWIGINTERN PyObject *_wrap_new_SALOME_LifeCycleCORBA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03695   PyObject *resultobj = 0;
03696   SALOME_NamingService *arg1 = (SALOME_NamingService *) 0 ;
03697   void *argp1 = 0 ;
03698   int res1 = 0 ;
03699   PyObject * obj0 = 0 ;
03700   SALOME_LifeCycleCORBA *result = 0 ;
03701   
03702   if (!PyArg_ParseTuple(args,(char *)"O:new_SALOME_LifeCycleCORBA",&obj0)) SWIG_fail;
03703   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_NamingService, 0 |  0 );
03704   if (!SWIG_IsOK(res1)) {
03705     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SALOME_LifeCycleCORBA" "', argument " "1"" of type '" "SALOME_NamingService *""'"); 
03706   }
03707   arg1 = reinterpret_cast< SALOME_NamingService * >(argp1);
03708   {
03709     Py_BEGIN_ALLOW_THREADS
03710     try {
03711       result = (SALOME_LifeCycleCORBA *)new SALOME_LifeCycleCORBA(arg1);
03712     }
03713     catch (ServiceUnreachable) {
03714       Py_BLOCK_THREADS
03715       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
03716       return NULL;
03717     }
03718     catch (SALOME_Exception &e) {
03719       Py_BLOCK_THREADS
03720       PyErr_SetString(PyExc_RuntimeError,e.what());
03721       return NULL;
03722     }
03723     catch (SALOME::SALOME_Exception &e) {
03724       Py_BLOCK_THREADS
03725       PyErr_SetString(PyExc_RuntimeError,e.details.text);
03726       return NULL;
03727     }
03728     catch (...) {
03729       Py_BLOCK_THREADS
03730       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
03731       return NULL;
03732     }
03733     Py_END_ALLOW_THREADS
03734   }
03735   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SALOME_LifeCycleCORBA, SWIG_POINTER_NEW |  0 );
03736   return resultobj;
03737 fail:
03738   return NULL;
03739 }
03740 
03741 
03742 SWIGINTERN PyObject *_wrap_new_SALOME_LifeCycleCORBA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03743   PyObject *resultobj = 0;
03744   SALOME_LifeCycleCORBA *result = 0 ;
03745   
03746   if (!PyArg_ParseTuple(args,(char *)":new_SALOME_LifeCycleCORBA")) SWIG_fail;
03747   {
03748     Py_BEGIN_ALLOW_THREADS
03749     try {
03750       result = (SALOME_LifeCycleCORBA *)new SALOME_LifeCycleCORBA();
03751     }
03752     catch (ServiceUnreachable) {
03753       Py_BLOCK_THREADS
03754       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
03755       return NULL;
03756     }
03757     catch (SALOME_Exception &e) {
03758       Py_BLOCK_THREADS
03759       PyErr_SetString(PyExc_RuntimeError,e.what());
03760       return NULL;
03761     }
03762     catch (SALOME::SALOME_Exception &e) {
03763       Py_BLOCK_THREADS
03764       PyErr_SetString(PyExc_RuntimeError,e.details.text);
03765       return NULL;
03766     }
03767     catch (...) {
03768       Py_BLOCK_THREADS
03769       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
03770       return NULL;
03771     }
03772     Py_END_ALLOW_THREADS
03773   }
03774   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SALOME_LifeCycleCORBA, SWIG_POINTER_NEW |  0 );
03775   return resultobj;
03776 fail:
03777   return NULL;
03778 }
03779 
03780 
03781 SWIGINTERN PyObject *_wrap_new_SALOME_LifeCycleCORBA(PyObject *self, PyObject *args) {
03782   int argc;
03783   PyObject *argv[2];
03784   int ii;
03785   
03786   if (!PyTuple_Check(args)) SWIG_fail;
03787   argc = (int)PyObject_Length(args);
03788   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
03789     argv[ii] = PyTuple_GET_ITEM(args,ii);
03790   }
03791   if (argc == 0) {
03792     return _wrap_new_SALOME_LifeCycleCORBA__SWIG_1(self, args);
03793   }
03794   if (argc == 1) {
03795     int _v;
03796     void *vptr = 0;
03797     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_NamingService, 0);
03798     _v = SWIG_CheckState(res);
03799     if (_v) {
03800       return _wrap_new_SALOME_LifeCycleCORBA__SWIG_0(self, args);
03801     }
03802   }
03803   
03804 fail:
03805   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SALOME_LifeCycleCORBA'.\n"
03806     "  Possible C/C++ prototypes are:\n"
03807     "    SALOME_LifeCycleCORBA(SALOME_NamingService *)\n"
03808     "    SALOME_LifeCycleCORBA()\n");
03809   return NULL;
03810 }
03811 
03812 
03813 SWIGINTERN PyObject *_wrap_delete_SALOME_LifeCycleCORBA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03814   PyObject *resultobj = 0;
03815   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
03816   void *argp1 = 0 ;
03817   int res1 = 0 ;
03818   PyObject * obj0 = 0 ;
03819   
03820   if (!PyArg_ParseTuple(args,(char *)"O:delete_SALOME_LifeCycleCORBA",&obj0)) SWIG_fail;
03821   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, SWIG_POINTER_DISOWN |  0 );
03822   if (!SWIG_IsOK(res1)) {
03823     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SALOME_LifeCycleCORBA" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
03824   }
03825   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
03826   {
03827     Py_BEGIN_ALLOW_THREADS
03828     try {
03829       delete arg1;
03830     }
03831     catch (ServiceUnreachable) {
03832       Py_BLOCK_THREADS
03833       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
03834       return NULL;
03835     }
03836     catch (SALOME_Exception &e) {
03837       Py_BLOCK_THREADS
03838       PyErr_SetString(PyExc_RuntimeError,e.what());
03839       return NULL;
03840     }
03841     catch (SALOME::SALOME_Exception &e) {
03842       Py_BLOCK_THREADS
03843       PyErr_SetString(PyExc_RuntimeError,e.details.text);
03844       return NULL;
03845     }
03846     catch (...) {
03847       Py_BLOCK_THREADS
03848       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
03849       return NULL;
03850     }
03851     Py_END_ALLOW_THREADS
03852   }
03853   resultobj = SWIG_Py_Void();
03854   return resultobj;
03855 fail:
03856   return NULL;
03857 }
03858 
03859 
03860 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_FindComponent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03861   PyObject *resultobj = 0;
03862   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
03863   Engines::MachineParameters *arg2 = 0 ;
03864   char *arg3 = (char *) 0 ;
03865   int arg4 ;
03866   void *argp1 = 0 ;
03867   int res1 = 0 ;
03868   int res3 ;
03869   char *buf3 = 0 ;
03870   int alloc3 = 0 ;
03871   int val4 ;
03872   int ecode4 = 0 ;
03873   PyObject * obj0 = 0 ;
03874   PyObject * obj1 = 0 ;
03875   PyObject * obj2 = 0 ;
03876   PyObject * obj3 = 0 ;
03877   Engines::EngineComponent_ptr result;
03878   
03879   if (!PyArg_ParseTuple(args,(char *)"OOOO:SALOME_LifeCycleCORBA_FindComponent",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
03880   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
03881   if (!SWIG_IsOK(res1)) {
03882     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_FindComponent" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
03883   }
03884   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
03885   {
03886     //printf("typemap in on Engines::MachineParameters\n");
03887     MESSAGE("typemap in on Engines::MachineParameters");
03888     if (PyDict_Check(obj1) == 1)
03889     {
03890       Engines::MachineParameters *param = new Engines::MachineParameters ;
03891       SALOME_LifeCycleCORBA::preSet(*param);
03892       
03893       PyObject *key, *value;
03894       Py_ssize_t pos = 0;
03895       while (PyDict_Next(obj1, &pos, &key, &value))
03896       {
03897         char* keystr = PyString_AsString(key);
03898         if (strcmp(keystr,"container_name")==0)
03899         {
03900           param->container_name = CORBA::string_dup(PyString_AsString(value));
03901         }
03902         else if (strcmp(keystr,"hostname")==0)
03903         {
03904           param->hostname = CORBA::string_dup(PyString_AsString(value));
03905         }
03906         else if (strcmp(keystr,"OS")==0)
03907         {
03908           param->OS = CORBA::string_dup(PyString_AsString(value));
03909         }
03910         else if (strcmp(keystr,"mem_mb")==0)
03911         {
03912           param->mem_mb = PyLong_AsLong(value);
03913         }
03914         else if (strcmp(keystr,"cpu_clock")==0)
03915         {
03916           param->cpu_clock = PyLong_AsLong(value);
03917         }
03918         else if (strcmp(keystr,"nb_proc_per_node")==0)
03919         {
03920           param->nb_proc_per_node = PyLong_AsLong(value);
03921         }
03922         else if (strcmp(keystr,"nb_node")==0)
03923         {
03924           param->nb_node = PyLong_AsLong(value);
03925         }
03926         else if (strcmp(keystr,"isMPI")==0)
03927         {
03928           param->isMPI = PyLong_AsLong(value);
03929         }
03930         else if (strcmp(keystr,"workingdir")==0)
03931         param->workingdir = CORBA::string_dup(PyString_AsString(value));
03932         else if (strcmp(keystr,"mode")==0)
03933         param->mode = CORBA::string_dup(PyString_AsString(value));
03934         else if (strcmp(keystr,"policy")==0)
03935         param->policy = CORBA::string_dup(PyString_AsString(value));
03936         else if (strcmp(keystr,"parallelLib")==0)
03937         {
03938           param->parallelLib = CORBA::string_dup(PyString_AsString(value));
03939         }
03940         else if (strcmp(keystr,"nb_component_nodes")==0)
03941         {
03942           param->nb_component_nodes = PyLong_AsLong(value);
03943         }
03944       }
03945       arg2 = param;
03946     }
03947     else 
03948     {
03949       MESSAGE("Not a dictionnary");
03950       PyErr_SetString(PyExc_TypeError,"Must Be a Python Dictionnary");
03951       return NULL;
03952     }
03953   }
03954   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
03955   if (!SWIG_IsOK(res3)) {
03956     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_FindComponent" "', argument " "3"" of type '" "char const *""'");
03957   }
03958   arg3 = reinterpret_cast< char * >(buf3);
03959   ecode4 = SWIG_AsVal_int(obj3, &val4);
03960   if (!SWIG_IsOK(ecode4)) {
03961     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SALOME_LifeCycleCORBA_FindComponent" "', argument " "4"" of type '" "int""'");
03962   } 
03963   arg4 = static_cast< int >(val4);
03964   {
03965     Py_BEGIN_ALLOW_THREADS
03966     try {
03967       result = (arg1)->FindComponent((Engines::MachineParameters const &)*arg2,(char const *)arg3,arg4);
03968     }
03969     catch (ServiceUnreachable) {
03970       Py_BLOCK_THREADS
03971       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
03972       return NULL;
03973     }
03974     catch (SALOME_Exception &e) {
03975       Py_BLOCK_THREADS
03976       PyErr_SetString(PyExc_RuntimeError,e.what());
03977       return NULL;
03978     }
03979     catch (SALOME::SALOME_Exception &e) {
03980       Py_BLOCK_THREADS
03981       PyErr_SetString(PyExc_RuntimeError,e.details.text);
03982       return NULL;
03983     }
03984     catch (...) {
03985       Py_BLOCK_THREADS
03986       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
03987       return NULL;
03988     }
03989     Py_END_ALLOW_THREADS
03990   }
03991   {
03992     MESSAGE("typemap out on CORBA object ptr");
03993     SCRUTE(result);
03994     resultobj = api->cxxObjRefToPyObjRef(result, 1);
03995     SCRUTE(resultobj);
03996   }
03997   {
03998     MESSAGE("delete arg2");
03999     delete arg2;
04000   }
04001   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04002   return resultobj;
04003 fail:
04004   {
04005     MESSAGE("delete arg2");
04006     delete arg2;
04007   }
04008   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04009   return NULL;
04010 }
04011 
04012 
04013 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_FindComponent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04014   PyObject *resultobj = 0;
04015   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
04016   Engines::MachineParameters *arg2 = 0 ;
04017   char *arg3 = (char *) 0 ;
04018   void *argp1 = 0 ;
04019   int res1 = 0 ;
04020   int res3 ;
04021   char *buf3 = 0 ;
04022   int alloc3 = 0 ;
04023   PyObject * obj0 = 0 ;
04024   PyObject * obj1 = 0 ;
04025   PyObject * obj2 = 0 ;
04026   Engines::EngineComponent_ptr result;
04027   
04028   if (!PyArg_ParseTuple(args,(char *)"OOO:SALOME_LifeCycleCORBA_FindComponent",&obj0,&obj1,&obj2)) SWIG_fail;
04029   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
04030   if (!SWIG_IsOK(res1)) {
04031     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_FindComponent" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
04032   }
04033   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
04034   {
04035     //printf("typemap in on Engines::MachineParameters\n");
04036     MESSAGE("typemap in on Engines::MachineParameters");
04037     if (PyDict_Check(obj1) == 1)
04038     {
04039       Engines::MachineParameters *param = new Engines::MachineParameters ;
04040       SALOME_LifeCycleCORBA::preSet(*param);
04041       
04042       PyObject *key, *value;
04043       Py_ssize_t pos = 0;
04044       while (PyDict_Next(obj1, &pos, &key, &value))
04045       {
04046         char* keystr = PyString_AsString(key);
04047         if (strcmp(keystr,"container_name")==0)
04048         {
04049           param->container_name = CORBA::string_dup(PyString_AsString(value));
04050         }
04051         else if (strcmp(keystr,"hostname")==0)
04052         {
04053           param->hostname = CORBA::string_dup(PyString_AsString(value));
04054         }
04055         else if (strcmp(keystr,"OS")==0)
04056         {
04057           param->OS = CORBA::string_dup(PyString_AsString(value));
04058         }
04059         else if (strcmp(keystr,"mem_mb")==0)
04060         {
04061           param->mem_mb = PyLong_AsLong(value);
04062         }
04063         else if (strcmp(keystr,"cpu_clock")==0)
04064         {
04065           param->cpu_clock = PyLong_AsLong(value);
04066         }
04067         else if (strcmp(keystr,"nb_proc_per_node")==0)
04068         {
04069           param->nb_proc_per_node = PyLong_AsLong(value);
04070         }
04071         else if (strcmp(keystr,"nb_node")==0)
04072         {
04073           param->nb_node = PyLong_AsLong(value);
04074         }
04075         else if (strcmp(keystr,"isMPI")==0)
04076         {
04077           param->isMPI = PyLong_AsLong(value);
04078         }
04079         else if (strcmp(keystr,"workingdir")==0)
04080         param->workingdir = CORBA::string_dup(PyString_AsString(value));
04081         else if (strcmp(keystr,"mode")==0)
04082         param->mode = CORBA::string_dup(PyString_AsString(value));
04083         else if (strcmp(keystr,"policy")==0)
04084         param->policy = CORBA::string_dup(PyString_AsString(value));
04085         else if (strcmp(keystr,"parallelLib")==0)
04086         {
04087           param->parallelLib = CORBA::string_dup(PyString_AsString(value));
04088         }
04089         else if (strcmp(keystr,"nb_component_nodes")==0)
04090         {
04091           param->nb_component_nodes = PyLong_AsLong(value);
04092         }
04093       }
04094       arg2 = param;
04095     }
04096     else 
04097     {
04098       MESSAGE("Not a dictionnary");
04099       PyErr_SetString(PyExc_TypeError,"Must Be a Python Dictionnary");
04100       return NULL;
04101     }
04102   }
04103   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
04104   if (!SWIG_IsOK(res3)) {
04105     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_FindComponent" "', argument " "3"" of type '" "char const *""'");
04106   }
04107   arg3 = reinterpret_cast< char * >(buf3);
04108   {
04109     Py_BEGIN_ALLOW_THREADS
04110     try {
04111       result = (arg1)->FindComponent((Engines::MachineParameters const &)*arg2,(char const *)arg3);
04112     }
04113     catch (ServiceUnreachable) {
04114       Py_BLOCK_THREADS
04115       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
04116       return NULL;
04117     }
04118     catch (SALOME_Exception &e) {
04119       Py_BLOCK_THREADS
04120       PyErr_SetString(PyExc_RuntimeError,e.what());
04121       return NULL;
04122     }
04123     catch (SALOME::SALOME_Exception &e) {
04124       Py_BLOCK_THREADS
04125       PyErr_SetString(PyExc_RuntimeError,e.details.text);
04126       return NULL;
04127     }
04128     catch (...) {
04129       Py_BLOCK_THREADS
04130       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
04131       return NULL;
04132     }
04133     Py_END_ALLOW_THREADS
04134   }
04135   {
04136     MESSAGE("typemap out on CORBA object ptr");
04137     SCRUTE(result);
04138     resultobj = api->cxxObjRefToPyObjRef(result, 1);
04139     SCRUTE(resultobj);
04140   }
04141   {
04142     MESSAGE("delete arg2");
04143     delete arg2;
04144   }
04145   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04146   return resultobj;
04147 fail:
04148   {
04149     MESSAGE("delete arg2");
04150     delete arg2;
04151   }
04152   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04153   return NULL;
04154 }
04155 
04156 
04157 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_FindComponent(PyObject *self, PyObject *args) {
04158   int argc;
04159   PyObject *argv[5];
04160   int ii;
04161   
04162   if (!PyTuple_Check(args)) SWIG_fail;
04163   argc = (int)PyObject_Length(args);
04164   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
04165     argv[ii] = PyTuple_GET_ITEM(args,ii);
04166   }
04167   if (argc == 3) {
04168     int _v;
04169     void *vptr = 0;
04170     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_LifeCycleCORBA, 0);
04171     _v = SWIG_CheckState(res);
04172     if (_v) {
04173       {
04174         _v = PyDict_Check(argv[1])? 1 : 0;
04175       }
04176       if (_v) {
04177         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
04178         _v = SWIG_CheckState(res);
04179         if (_v) {
04180           return _wrap_SALOME_LifeCycleCORBA_FindComponent__SWIG_1(self, args);
04181         }
04182       }
04183     }
04184   }
04185   if (argc == 4) {
04186     int _v;
04187     void *vptr = 0;
04188     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_LifeCycleCORBA, 0);
04189     _v = SWIG_CheckState(res);
04190     if (_v) {
04191       {
04192         _v = PyDict_Check(argv[1])? 1 : 0;
04193       }
04194       if (_v) {
04195         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
04196         _v = SWIG_CheckState(res);
04197         if (_v) {
04198           {
04199             int res = SWIG_AsVal_int(argv[3], NULL);
04200             _v = SWIG_CheckState(res);
04201           }
04202           if (_v) {
04203             return _wrap_SALOME_LifeCycleCORBA_FindComponent__SWIG_0(self, args);
04204           }
04205         }
04206       }
04207     }
04208   }
04209   
04210 fail:
04211   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SALOME_LifeCycleCORBA_FindComponent'.\n"
04212     "  Possible C/C++ prototypes are:\n"
04213     "    FindComponent(SALOME_LifeCycleCORBA *,Engines::MachineParameters const &,char const *,int)\n"
04214     "    FindComponent(SALOME_LifeCycleCORBA *,Engines::MachineParameters const &,char const *)\n");
04215   return NULL;
04216 }
04217 
04218 
04219 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_LoadComponent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04220   PyObject *resultobj = 0;
04221   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
04222   Engines::MachineParameters *arg2 = 0 ;
04223   char *arg3 = (char *) 0 ;
04224   int arg4 ;
04225   void *argp1 = 0 ;
04226   int res1 = 0 ;
04227   int res3 ;
04228   char *buf3 = 0 ;
04229   int alloc3 = 0 ;
04230   int val4 ;
04231   int ecode4 = 0 ;
04232   PyObject * obj0 = 0 ;
04233   PyObject * obj1 = 0 ;
04234   PyObject * obj2 = 0 ;
04235   PyObject * obj3 = 0 ;
04236   Engines::EngineComponent_ptr result;
04237   
04238   if (!PyArg_ParseTuple(args,(char *)"OOOO:SALOME_LifeCycleCORBA_LoadComponent",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
04239   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
04240   if (!SWIG_IsOK(res1)) {
04241     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_LoadComponent" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
04242   }
04243   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
04244   {
04245     //printf("typemap in on Engines::MachineParameters\n");
04246     MESSAGE("typemap in on Engines::MachineParameters");
04247     if (PyDict_Check(obj1) == 1)
04248     {
04249       Engines::MachineParameters *param = new Engines::MachineParameters ;
04250       SALOME_LifeCycleCORBA::preSet(*param);
04251       
04252       PyObject *key, *value;
04253       Py_ssize_t pos = 0;
04254       while (PyDict_Next(obj1, &pos, &key, &value))
04255       {
04256         char* keystr = PyString_AsString(key);
04257         if (strcmp(keystr,"container_name")==0)
04258         {
04259           param->container_name = CORBA::string_dup(PyString_AsString(value));
04260         }
04261         else if (strcmp(keystr,"hostname")==0)
04262         {
04263           param->hostname = CORBA::string_dup(PyString_AsString(value));
04264         }
04265         else if (strcmp(keystr,"OS")==0)
04266         {
04267           param->OS = CORBA::string_dup(PyString_AsString(value));
04268         }
04269         else if (strcmp(keystr,"mem_mb")==0)
04270         {
04271           param->mem_mb = PyLong_AsLong(value);
04272         }
04273         else if (strcmp(keystr,"cpu_clock")==0)
04274         {
04275           param->cpu_clock = PyLong_AsLong(value);
04276         }
04277         else if (strcmp(keystr,"nb_proc_per_node")==0)
04278         {
04279           param->nb_proc_per_node = PyLong_AsLong(value);
04280         }
04281         else if (strcmp(keystr,"nb_node")==0)
04282         {
04283           param->nb_node = PyLong_AsLong(value);
04284         }
04285         else if (strcmp(keystr,"isMPI")==0)
04286         {
04287           param->isMPI = PyLong_AsLong(value);
04288         }
04289         else if (strcmp(keystr,"workingdir")==0)
04290         param->workingdir = CORBA::string_dup(PyString_AsString(value));
04291         else if (strcmp(keystr,"mode")==0)
04292         param->mode = CORBA::string_dup(PyString_AsString(value));
04293         else if (strcmp(keystr,"policy")==0)
04294         param->policy = CORBA::string_dup(PyString_AsString(value));
04295         else if (strcmp(keystr,"parallelLib")==0)
04296         {
04297           param->parallelLib = CORBA::string_dup(PyString_AsString(value));
04298         }
04299         else if (strcmp(keystr,"nb_component_nodes")==0)
04300         {
04301           param->nb_component_nodes = PyLong_AsLong(value);
04302         }
04303       }
04304       arg2 = param;
04305     }
04306     else 
04307     {
04308       MESSAGE("Not a dictionnary");
04309       PyErr_SetString(PyExc_TypeError,"Must Be a Python Dictionnary");
04310       return NULL;
04311     }
04312   }
04313   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
04314   if (!SWIG_IsOK(res3)) {
04315     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_LoadComponent" "', argument " "3"" of type '" "char const *""'");
04316   }
04317   arg3 = reinterpret_cast< char * >(buf3);
04318   ecode4 = SWIG_AsVal_int(obj3, &val4);
04319   if (!SWIG_IsOK(ecode4)) {
04320     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SALOME_LifeCycleCORBA_LoadComponent" "', argument " "4"" of type '" "int""'");
04321   } 
04322   arg4 = static_cast< int >(val4);
04323   {
04324     Py_BEGIN_ALLOW_THREADS
04325     try {
04326       result = (arg1)->LoadComponent((Engines::MachineParameters const &)*arg2,(char const *)arg3,arg4);
04327     }
04328     catch (ServiceUnreachable) {
04329       Py_BLOCK_THREADS
04330       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
04331       return NULL;
04332     }
04333     catch (SALOME_Exception &e) {
04334       Py_BLOCK_THREADS
04335       PyErr_SetString(PyExc_RuntimeError,e.what());
04336       return NULL;
04337     }
04338     catch (SALOME::SALOME_Exception &e) {
04339       Py_BLOCK_THREADS
04340       PyErr_SetString(PyExc_RuntimeError,e.details.text);
04341       return NULL;
04342     }
04343     catch (...) {
04344       Py_BLOCK_THREADS
04345       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
04346       return NULL;
04347     }
04348     Py_END_ALLOW_THREADS
04349   }
04350   {
04351     MESSAGE("typemap out on CORBA object ptr");
04352     SCRUTE(result);
04353     resultobj = api->cxxObjRefToPyObjRef(result, 1);
04354     SCRUTE(resultobj);
04355   }
04356   {
04357     MESSAGE("delete arg2");
04358     delete arg2;
04359   }
04360   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04361   return resultobj;
04362 fail:
04363   {
04364     MESSAGE("delete arg2");
04365     delete arg2;
04366   }
04367   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04368   return NULL;
04369 }
04370 
04371 
04372 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_LoadComponent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04373   PyObject *resultobj = 0;
04374   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
04375   Engines::MachineParameters *arg2 = 0 ;
04376   char *arg3 = (char *) 0 ;
04377   void *argp1 = 0 ;
04378   int res1 = 0 ;
04379   int res3 ;
04380   char *buf3 = 0 ;
04381   int alloc3 = 0 ;
04382   PyObject * obj0 = 0 ;
04383   PyObject * obj1 = 0 ;
04384   PyObject * obj2 = 0 ;
04385   Engines::EngineComponent_ptr result;
04386   
04387   if (!PyArg_ParseTuple(args,(char *)"OOO:SALOME_LifeCycleCORBA_LoadComponent",&obj0,&obj1,&obj2)) SWIG_fail;
04388   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
04389   if (!SWIG_IsOK(res1)) {
04390     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_LoadComponent" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
04391   }
04392   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
04393   {
04394     //printf("typemap in on Engines::MachineParameters\n");
04395     MESSAGE("typemap in on Engines::MachineParameters");
04396     if (PyDict_Check(obj1) == 1)
04397     {
04398       Engines::MachineParameters *param = new Engines::MachineParameters ;
04399       SALOME_LifeCycleCORBA::preSet(*param);
04400       
04401       PyObject *key, *value;
04402       Py_ssize_t pos = 0;
04403       while (PyDict_Next(obj1, &pos, &key, &value))
04404       {
04405         char* keystr = PyString_AsString(key);
04406         if (strcmp(keystr,"container_name")==0)
04407         {
04408           param->container_name = CORBA::string_dup(PyString_AsString(value));
04409         }
04410         else if (strcmp(keystr,"hostname")==0)
04411         {
04412           param->hostname = CORBA::string_dup(PyString_AsString(value));
04413         }
04414         else if (strcmp(keystr,"OS")==0)
04415         {
04416           param->OS = CORBA::string_dup(PyString_AsString(value));
04417         }
04418         else if (strcmp(keystr,"mem_mb")==0)
04419         {
04420           param->mem_mb = PyLong_AsLong(value);
04421         }
04422         else if (strcmp(keystr,"cpu_clock")==0)
04423         {
04424           param->cpu_clock = PyLong_AsLong(value);
04425         }
04426         else if (strcmp(keystr,"nb_proc_per_node")==0)
04427         {
04428           param->nb_proc_per_node = PyLong_AsLong(value);
04429         }
04430         else if (strcmp(keystr,"nb_node")==0)
04431         {
04432           param->nb_node = PyLong_AsLong(value);
04433         }
04434         else if (strcmp(keystr,"isMPI")==0)
04435         {
04436           param->isMPI = PyLong_AsLong(value);
04437         }
04438         else if (strcmp(keystr,"workingdir")==0)
04439         param->workingdir = CORBA::string_dup(PyString_AsString(value));
04440         else if (strcmp(keystr,"mode")==0)
04441         param->mode = CORBA::string_dup(PyString_AsString(value));
04442         else if (strcmp(keystr,"policy")==0)
04443         param->policy = CORBA::string_dup(PyString_AsString(value));
04444         else if (strcmp(keystr,"parallelLib")==0)
04445         {
04446           param->parallelLib = CORBA::string_dup(PyString_AsString(value));
04447         }
04448         else if (strcmp(keystr,"nb_component_nodes")==0)
04449         {
04450           param->nb_component_nodes = PyLong_AsLong(value);
04451         }
04452       }
04453       arg2 = param;
04454     }
04455     else 
04456     {
04457       MESSAGE("Not a dictionnary");
04458       PyErr_SetString(PyExc_TypeError,"Must Be a Python Dictionnary");
04459       return NULL;
04460     }
04461   }
04462   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
04463   if (!SWIG_IsOK(res3)) {
04464     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_LoadComponent" "', argument " "3"" of type '" "char const *""'");
04465   }
04466   arg3 = reinterpret_cast< char * >(buf3);
04467   {
04468     Py_BEGIN_ALLOW_THREADS
04469     try {
04470       result = (arg1)->LoadComponent((Engines::MachineParameters const &)*arg2,(char const *)arg3);
04471     }
04472     catch (ServiceUnreachable) {
04473       Py_BLOCK_THREADS
04474       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
04475       return NULL;
04476     }
04477     catch (SALOME_Exception &e) {
04478       Py_BLOCK_THREADS
04479       PyErr_SetString(PyExc_RuntimeError,e.what());
04480       return NULL;
04481     }
04482     catch (SALOME::SALOME_Exception &e) {
04483       Py_BLOCK_THREADS
04484       PyErr_SetString(PyExc_RuntimeError,e.details.text);
04485       return NULL;
04486     }
04487     catch (...) {
04488       Py_BLOCK_THREADS
04489       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
04490       return NULL;
04491     }
04492     Py_END_ALLOW_THREADS
04493   }
04494   {
04495     MESSAGE("typemap out on CORBA object ptr");
04496     SCRUTE(result);
04497     resultobj = api->cxxObjRefToPyObjRef(result, 1);
04498     SCRUTE(resultobj);
04499   }
04500   {
04501     MESSAGE("delete arg2");
04502     delete arg2;
04503   }
04504   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04505   return resultobj;
04506 fail:
04507   {
04508     MESSAGE("delete arg2");
04509     delete arg2;
04510   }
04511   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04512   return NULL;
04513 }
04514 
04515 
04516 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_LoadComponent(PyObject *self, PyObject *args) {
04517   int argc;
04518   PyObject *argv[5];
04519   int ii;
04520   
04521   if (!PyTuple_Check(args)) SWIG_fail;
04522   argc = (int)PyObject_Length(args);
04523   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
04524     argv[ii] = PyTuple_GET_ITEM(args,ii);
04525   }
04526   if (argc == 3) {
04527     int _v;
04528     void *vptr = 0;
04529     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_LifeCycleCORBA, 0);
04530     _v = SWIG_CheckState(res);
04531     if (_v) {
04532       {
04533         _v = PyDict_Check(argv[1])? 1 : 0;
04534       }
04535       if (_v) {
04536         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
04537         _v = SWIG_CheckState(res);
04538         if (_v) {
04539           return _wrap_SALOME_LifeCycleCORBA_LoadComponent__SWIG_1(self, args);
04540         }
04541       }
04542     }
04543   }
04544   if (argc == 4) {
04545     int _v;
04546     void *vptr = 0;
04547     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_LifeCycleCORBA, 0);
04548     _v = SWIG_CheckState(res);
04549     if (_v) {
04550       {
04551         _v = PyDict_Check(argv[1])? 1 : 0;
04552       }
04553       if (_v) {
04554         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
04555         _v = SWIG_CheckState(res);
04556         if (_v) {
04557           {
04558             int res = SWIG_AsVal_int(argv[3], NULL);
04559             _v = SWIG_CheckState(res);
04560           }
04561           if (_v) {
04562             return _wrap_SALOME_LifeCycleCORBA_LoadComponent__SWIG_0(self, args);
04563           }
04564         }
04565       }
04566     }
04567   }
04568   
04569 fail:
04570   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SALOME_LifeCycleCORBA_LoadComponent'.\n"
04571     "  Possible C/C++ prototypes are:\n"
04572     "    LoadComponent(SALOME_LifeCycleCORBA *,Engines::MachineParameters const &,char const *,int)\n"
04573     "    LoadComponent(SALOME_LifeCycleCORBA *,Engines::MachineParameters const &,char const *)\n");
04574   return NULL;
04575 }
04576 
04577 
04578 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04579   PyObject *resultobj = 0;
04580   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
04581   Engines::MachineParameters *arg2 = 0 ;
04582   char *arg3 = (char *) 0 ;
04583   int arg4 ;
04584   void *argp1 = 0 ;
04585   int res1 = 0 ;
04586   int res3 ;
04587   char *buf3 = 0 ;
04588   int alloc3 = 0 ;
04589   int val4 ;
04590   int ecode4 = 0 ;
04591   PyObject * obj0 = 0 ;
04592   PyObject * obj1 = 0 ;
04593   PyObject * obj2 = 0 ;
04594   PyObject * obj3 = 0 ;
04595   Engines::EngineComponent_ptr result;
04596   
04597   if (!PyArg_ParseTuple(args,(char *)"OOOO:SALOME_LifeCycleCORBA_FindOrLoad_Component",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
04598   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
04599   if (!SWIG_IsOK(res1)) {
04600     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
04601   }
04602   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
04603   {
04604     //printf("typemap in on Engines::MachineParameters\n");
04605     MESSAGE("typemap in on Engines::MachineParameters");
04606     if (PyDict_Check(obj1) == 1)
04607     {
04608       Engines::MachineParameters *param = new Engines::MachineParameters ;
04609       SALOME_LifeCycleCORBA::preSet(*param);
04610       
04611       PyObject *key, *value;
04612       Py_ssize_t pos = 0;
04613       while (PyDict_Next(obj1, &pos, &key, &value))
04614       {
04615         char* keystr = PyString_AsString(key);
04616         if (strcmp(keystr,"container_name")==0)
04617         {
04618           param->container_name = CORBA::string_dup(PyString_AsString(value));
04619         }
04620         else if (strcmp(keystr,"hostname")==0)
04621         {
04622           param->hostname = CORBA::string_dup(PyString_AsString(value));
04623         }
04624         else if (strcmp(keystr,"OS")==0)
04625         {
04626           param->OS = CORBA::string_dup(PyString_AsString(value));
04627         }
04628         else if (strcmp(keystr,"mem_mb")==0)
04629         {
04630           param->mem_mb = PyLong_AsLong(value);
04631         }
04632         else if (strcmp(keystr,"cpu_clock")==0)
04633         {
04634           param->cpu_clock = PyLong_AsLong(value);
04635         }
04636         else if (strcmp(keystr,"nb_proc_per_node")==0)
04637         {
04638           param->nb_proc_per_node = PyLong_AsLong(value);
04639         }
04640         else if (strcmp(keystr,"nb_node")==0)
04641         {
04642           param->nb_node = PyLong_AsLong(value);
04643         }
04644         else if (strcmp(keystr,"isMPI")==0)
04645         {
04646           param->isMPI = PyLong_AsLong(value);
04647         }
04648         else if (strcmp(keystr,"workingdir")==0)
04649         param->workingdir = CORBA::string_dup(PyString_AsString(value));
04650         else if (strcmp(keystr,"mode")==0)
04651         param->mode = CORBA::string_dup(PyString_AsString(value));
04652         else if (strcmp(keystr,"policy")==0)
04653         param->policy = CORBA::string_dup(PyString_AsString(value));
04654         else if (strcmp(keystr,"parallelLib")==0)
04655         {
04656           param->parallelLib = CORBA::string_dup(PyString_AsString(value));
04657         }
04658         else if (strcmp(keystr,"nb_component_nodes")==0)
04659         {
04660           param->nb_component_nodes = PyLong_AsLong(value);
04661         }
04662       }
04663       arg2 = param;
04664     }
04665     else 
04666     {
04667       MESSAGE("Not a dictionnary");
04668       PyErr_SetString(PyExc_TypeError,"Must Be a Python Dictionnary");
04669       return NULL;
04670     }
04671   }
04672   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
04673   if (!SWIG_IsOK(res3)) {
04674     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "3"" of type '" "char const *""'");
04675   }
04676   arg3 = reinterpret_cast< char * >(buf3);
04677   ecode4 = SWIG_AsVal_int(obj3, &val4);
04678   if (!SWIG_IsOK(ecode4)) {
04679     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "4"" of type '" "int""'");
04680   } 
04681   arg4 = static_cast< int >(val4);
04682   {
04683     Py_BEGIN_ALLOW_THREADS
04684     try {
04685       result = (arg1)->FindOrLoad_Component((Engines::MachineParameters const &)*arg2,(char const *)arg3,arg4);
04686     }
04687     catch (ServiceUnreachable) {
04688       Py_BLOCK_THREADS
04689       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
04690       return NULL;
04691     }
04692     catch (SALOME_Exception &e) {
04693       Py_BLOCK_THREADS
04694       PyErr_SetString(PyExc_RuntimeError,e.what());
04695       return NULL;
04696     }
04697     catch (SALOME::SALOME_Exception &e) {
04698       Py_BLOCK_THREADS
04699       PyErr_SetString(PyExc_RuntimeError,e.details.text);
04700       return NULL;
04701     }
04702     catch (...) {
04703       Py_BLOCK_THREADS
04704       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
04705       return NULL;
04706     }
04707     Py_END_ALLOW_THREADS
04708   }
04709   {
04710     MESSAGE("typemap out on CORBA object ptr");
04711     SCRUTE(result);
04712     resultobj = api->cxxObjRefToPyObjRef(result, 1);
04713     SCRUTE(resultobj);
04714   }
04715   {
04716     MESSAGE("delete arg2");
04717     delete arg2;
04718   }
04719   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04720   return resultobj;
04721 fail:
04722   {
04723     MESSAGE("delete arg2");
04724     delete arg2;
04725   }
04726   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04727   return NULL;
04728 }
04729 
04730 
04731 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04732   PyObject *resultobj = 0;
04733   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
04734   Engines::MachineParameters *arg2 = 0 ;
04735   char *arg3 = (char *) 0 ;
04736   void *argp1 = 0 ;
04737   int res1 = 0 ;
04738   int res3 ;
04739   char *buf3 = 0 ;
04740   int alloc3 = 0 ;
04741   PyObject * obj0 = 0 ;
04742   PyObject * obj1 = 0 ;
04743   PyObject * obj2 = 0 ;
04744   Engines::EngineComponent_ptr result;
04745   
04746   if (!PyArg_ParseTuple(args,(char *)"OOO:SALOME_LifeCycleCORBA_FindOrLoad_Component",&obj0,&obj1,&obj2)) SWIG_fail;
04747   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
04748   if (!SWIG_IsOK(res1)) {
04749     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
04750   }
04751   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
04752   {
04753     //printf("typemap in on Engines::MachineParameters\n");
04754     MESSAGE("typemap in on Engines::MachineParameters");
04755     if (PyDict_Check(obj1) == 1)
04756     {
04757       Engines::MachineParameters *param = new Engines::MachineParameters ;
04758       SALOME_LifeCycleCORBA::preSet(*param);
04759       
04760       PyObject *key, *value;
04761       Py_ssize_t pos = 0;
04762       while (PyDict_Next(obj1, &pos, &key, &value))
04763       {
04764         char* keystr = PyString_AsString(key);
04765         if (strcmp(keystr,"container_name")==0)
04766         {
04767           param->container_name = CORBA::string_dup(PyString_AsString(value));
04768         }
04769         else if (strcmp(keystr,"hostname")==0)
04770         {
04771           param->hostname = CORBA::string_dup(PyString_AsString(value));
04772         }
04773         else if (strcmp(keystr,"OS")==0)
04774         {
04775           param->OS = CORBA::string_dup(PyString_AsString(value));
04776         }
04777         else if (strcmp(keystr,"mem_mb")==0)
04778         {
04779           param->mem_mb = PyLong_AsLong(value);
04780         }
04781         else if (strcmp(keystr,"cpu_clock")==0)
04782         {
04783           param->cpu_clock = PyLong_AsLong(value);
04784         }
04785         else if (strcmp(keystr,"nb_proc_per_node")==0)
04786         {
04787           param->nb_proc_per_node = PyLong_AsLong(value);
04788         }
04789         else if (strcmp(keystr,"nb_node")==0)
04790         {
04791           param->nb_node = PyLong_AsLong(value);
04792         }
04793         else if (strcmp(keystr,"isMPI")==0)
04794         {
04795           param->isMPI = PyLong_AsLong(value);
04796         }
04797         else if (strcmp(keystr,"workingdir")==0)
04798         param->workingdir = CORBA::string_dup(PyString_AsString(value));
04799         else if (strcmp(keystr,"mode")==0)
04800         param->mode = CORBA::string_dup(PyString_AsString(value));
04801         else if (strcmp(keystr,"policy")==0)
04802         param->policy = CORBA::string_dup(PyString_AsString(value));
04803         else if (strcmp(keystr,"parallelLib")==0)
04804         {
04805           param->parallelLib = CORBA::string_dup(PyString_AsString(value));
04806         }
04807         else if (strcmp(keystr,"nb_component_nodes")==0)
04808         {
04809           param->nb_component_nodes = PyLong_AsLong(value);
04810         }
04811       }
04812       arg2 = param;
04813     }
04814     else 
04815     {
04816       MESSAGE("Not a dictionnary");
04817       PyErr_SetString(PyExc_TypeError,"Must Be a Python Dictionnary");
04818       return NULL;
04819     }
04820   }
04821   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
04822   if (!SWIG_IsOK(res3)) {
04823     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "3"" of type '" "char const *""'");
04824   }
04825   arg3 = reinterpret_cast< char * >(buf3);
04826   {
04827     Py_BEGIN_ALLOW_THREADS
04828     try {
04829       result = (arg1)->FindOrLoad_Component((Engines::MachineParameters const &)*arg2,(char const *)arg3);
04830     }
04831     catch (ServiceUnreachable) {
04832       Py_BLOCK_THREADS
04833       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
04834       return NULL;
04835     }
04836     catch (SALOME_Exception &e) {
04837       Py_BLOCK_THREADS
04838       PyErr_SetString(PyExc_RuntimeError,e.what());
04839       return NULL;
04840     }
04841     catch (SALOME::SALOME_Exception &e) {
04842       Py_BLOCK_THREADS
04843       PyErr_SetString(PyExc_RuntimeError,e.details.text);
04844       return NULL;
04845     }
04846     catch (...) {
04847       Py_BLOCK_THREADS
04848       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
04849       return NULL;
04850     }
04851     Py_END_ALLOW_THREADS
04852   }
04853   {
04854     MESSAGE("typemap out on CORBA object ptr");
04855     SCRUTE(result);
04856     resultobj = api->cxxObjRefToPyObjRef(result, 1);
04857     SCRUTE(resultobj);
04858   }
04859   {
04860     MESSAGE("delete arg2");
04861     delete arg2;
04862   }
04863   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04864   return resultobj;
04865 fail:
04866   {
04867     MESSAGE("delete arg2");
04868     delete arg2;
04869   }
04870   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04871   return NULL;
04872 }
04873 
04874 
04875 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04876   PyObject *resultobj = 0;
04877   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
04878   Engines::ContainerParameters *arg2 = 0 ;
04879   char *arg3 = (char *) 0 ;
04880   int arg4 ;
04881   void *argp1 = 0 ;
04882   int res1 = 0 ;
04883   void *argp2 = 0 ;
04884   int res2 = 0 ;
04885   int res3 ;
04886   char *buf3 = 0 ;
04887   int alloc3 = 0 ;
04888   int val4 ;
04889   int ecode4 = 0 ;
04890   PyObject * obj0 = 0 ;
04891   PyObject * obj1 = 0 ;
04892   PyObject * obj2 = 0 ;
04893   PyObject * obj3 = 0 ;
04894   Engines::EngineComponent_ptr result;
04895   
04896   if (!PyArg_ParseTuple(args,(char *)"OOOO:SALOME_LifeCycleCORBA_FindOrLoad_Component",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
04897   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
04898   if (!SWIG_IsOK(res1)) {
04899     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
04900   }
04901   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
04902   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Engines__ContainerParameters,  0  | 0);
04903   if (!SWIG_IsOK(res2)) {
04904     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "2"" of type '" "Engines::ContainerParameters const &""'"); 
04905   }
04906   if (!argp2) {
04907     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "2"" of type '" "Engines::ContainerParameters const &""'"); 
04908   }
04909   arg2 = reinterpret_cast< Engines::ContainerParameters * >(argp2);
04910   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
04911   if (!SWIG_IsOK(res3)) {
04912     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "3"" of type '" "char const *""'");
04913   }
04914   arg3 = reinterpret_cast< char * >(buf3);
04915   ecode4 = SWIG_AsVal_int(obj3, &val4);
04916   if (!SWIG_IsOK(ecode4)) {
04917     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "4"" of type '" "int""'");
04918   } 
04919   arg4 = static_cast< int >(val4);
04920   {
04921     Py_BEGIN_ALLOW_THREADS
04922     try {
04923       result = (arg1)->FindOrLoad_Component((Engines::ContainerParameters const &)*arg2,(char const *)arg3,arg4);
04924     }
04925     catch (ServiceUnreachable) {
04926       Py_BLOCK_THREADS
04927       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
04928       return NULL;
04929     }
04930     catch (SALOME_Exception &e) {
04931       Py_BLOCK_THREADS
04932       PyErr_SetString(PyExc_RuntimeError,e.what());
04933       return NULL;
04934     }
04935     catch (SALOME::SALOME_Exception &e) {
04936       Py_BLOCK_THREADS
04937       PyErr_SetString(PyExc_RuntimeError,e.details.text);
04938       return NULL;
04939     }
04940     catch (...) {
04941       Py_BLOCK_THREADS
04942       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
04943       return NULL;
04944     }
04945     Py_END_ALLOW_THREADS
04946   }
04947   {
04948     MESSAGE("typemap out on CORBA object ptr");
04949     SCRUTE(result);
04950     resultobj = api->cxxObjRefToPyObjRef(result, 1);
04951     SCRUTE(resultobj);
04952   }
04953   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04954   return resultobj;
04955 fail:
04956   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
04957   return NULL;
04958 }
04959 
04960 
04961 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04962   PyObject *resultobj = 0;
04963   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
04964   Engines::ContainerParameters *arg2 = 0 ;
04965   char *arg3 = (char *) 0 ;
04966   void *argp1 = 0 ;
04967   int res1 = 0 ;
04968   void *argp2 = 0 ;
04969   int res2 = 0 ;
04970   int res3 ;
04971   char *buf3 = 0 ;
04972   int alloc3 = 0 ;
04973   PyObject * obj0 = 0 ;
04974   PyObject * obj1 = 0 ;
04975   PyObject * obj2 = 0 ;
04976   Engines::EngineComponent_ptr result;
04977   
04978   if (!PyArg_ParseTuple(args,(char *)"OOO:SALOME_LifeCycleCORBA_FindOrLoad_Component",&obj0,&obj1,&obj2)) SWIG_fail;
04979   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
04980   if (!SWIG_IsOK(res1)) {
04981     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
04982   }
04983   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
04984   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Engines__ContainerParameters,  0  | 0);
04985   if (!SWIG_IsOK(res2)) {
04986     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "2"" of type '" "Engines::ContainerParameters const &""'"); 
04987   }
04988   if (!argp2) {
04989     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "2"" of type '" "Engines::ContainerParameters const &""'"); 
04990   }
04991   arg2 = reinterpret_cast< Engines::ContainerParameters * >(argp2);
04992   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
04993   if (!SWIG_IsOK(res3)) {
04994     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "3"" of type '" "char const *""'");
04995   }
04996   arg3 = reinterpret_cast< char * >(buf3);
04997   {
04998     Py_BEGIN_ALLOW_THREADS
04999     try {
05000       result = (arg1)->FindOrLoad_Component((Engines::ContainerParameters const &)*arg2,(char const *)arg3);
05001     }
05002     catch (ServiceUnreachable) {
05003       Py_BLOCK_THREADS
05004       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05005       return NULL;
05006     }
05007     catch (SALOME_Exception &e) {
05008       Py_BLOCK_THREADS
05009       PyErr_SetString(PyExc_RuntimeError,e.what());
05010       return NULL;
05011     }
05012     catch (SALOME::SALOME_Exception &e) {
05013       Py_BLOCK_THREADS
05014       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05015       return NULL;
05016     }
05017     catch (...) {
05018       Py_BLOCK_THREADS
05019       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05020       return NULL;
05021     }
05022     Py_END_ALLOW_THREADS
05023   }
05024   {
05025     MESSAGE("typemap out on CORBA object ptr");
05026     SCRUTE(result);
05027     resultobj = api->cxxObjRefToPyObjRef(result, 1);
05028     SCRUTE(resultobj);
05029   }
05030   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05031   return resultobj;
05032 fail:
05033   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05034   return NULL;
05035 }
05036 
05037 
05038 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05039   PyObject *resultobj = 0;
05040   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
05041   char *arg2 = (char *) 0 ;
05042   char *arg3 = (char *) 0 ;
05043   void *argp1 = 0 ;
05044   int res1 = 0 ;
05045   int res2 ;
05046   char *buf2 = 0 ;
05047   int alloc2 = 0 ;
05048   int res3 ;
05049   char *buf3 = 0 ;
05050   int alloc3 = 0 ;
05051   PyObject * obj0 = 0 ;
05052   PyObject * obj1 = 0 ;
05053   PyObject * obj2 = 0 ;
05054   Engines::EngineComponent_ptr result;
05055   
05056   if (!PyArg_ParseTuple(args,(char *)"OOO:SALOME_LifeCycleCORBA_FindOrLoad_Component",&obj0,&obj1,&obj2)) SWIG_fail;
05057   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
05058   if (!SWIG_IsOK(res1)) {
05059     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
05060   }
05061   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
05062   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05063   if (!SWIG_IsOK(res2)) {
05064     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "2"" of type '" "char const *""'");
05065   }
05066   arg2 = reinterpret_cast< char * >(buf2);
05067   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
05068   if (!SWIG_IsOK(res3)) {
05069     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_FindOrLoad_Component" "', argument " "3"" of type '" "char const *""'");
05070   }
05071   arg3 = reinterpret_cast< char * >(buf3);
05072   {
05073     Py_BEGIN_ALLOW_THREADS
05074     try {
05075       result = (arg1)->FindOrLoad_Component((char const *)arg2,(char const *)arg3);
05076     }
05077     catch (ServiceUnreachable) {
05078       Py_BLOCK_THREADS
05079       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05080       return NULL;
05081     }
05082     catch (SALOME_Exception &e) {
05083       Py_BLOCK_THREADS
05084       PyErr_SetString(PyExc_RuntimeError,e.what());
05085       return NULL;
05086     }
05087     catch (SALOME::SALOME_Exception &e) {
05088       Py_BLOCK_THREADS
05089       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05090       return NULL;
05091     }
05092     catch (...) {
05093       Py_BLOCK_THREADS
05094       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05095       return NULL;
05096     }
05097     Py_END_ALLOW_THREADS
05098   }
05099   {
05100     MESSAGE("typemap out on CORBA object ptr");
05101     SCRUTE(result);
05102     resultobj = api->cxxObjRefToPyObjRef(result, 1);
05103     SCRUTE(resultobj);
05104   }
05105   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05106   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05107   return resultobj;
05108 fail:
05109   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05110   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05111   return NULL;
05112 }
05113 
05114 
05115 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component(PyObject *self, PyObject *args) {
05116   int argc;
05117   PyObject *argv[5];
05118   int ii;
05119   
05120   if (!PyTuple_Check(args)) SWIG_fail;
05121   argc = (int)PyObject_Length(args);
05122   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
05123     argv[ii] = PyTuple_GET_ITEM(args,ii);
05124   }
05125   if (argc == 3) {
05126     int _v;
05127     void *vptr = 0;
05128     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_LifeCycleCORBA, 0);
05129     _v = SWIG_CheckState(res);
05130     if (_v) {
05131       {
05132         _v = PyDict_Check(argv[1])? 1 : 0;
05133       }
05134       if (_v) {
05135         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
05136         _v = SWIG_CheckState(res);
05137         if (_v) {
05138           return _wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component__SWIG_1(self, args);
05139         }
05140       }
05141     }
05142   }
05143   if (argc == 3) {
05144     int _v;
05145     void *vptr = 0;
05146     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_LifeCycleCORBA, 0);
05147     _v = SWIG_CheckState(res);
05148     if (_v) {
05149       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Engines__ContainerParameters, 0);
05150       _v = SWIG_CheckState(res);
05151       if (_v) {
05152         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
05153         _v = SWIG_CheckState(res);
05154         if (_v) {
05155           return _wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component__SWIG_3(self, args);
05156         }
05157       }
05158     }
05159   }
05160   if (argc == 3) {
05161     int _v;
05162     void *vptr = 0;
05163     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_LifeCycleCORBA, 0);
05164     _v = SWIG_CheckState(res);
05165     if (_v) {
05166       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
05167       _v = SWIG_CheckState(res);
05168       if (_v) {
05169         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
05170         _v = SWIG_CheckState(res);
05171         if (_v) {
05172           return _wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component__SWIG_4(self, args);
05173         }
05174       }
05175     }
05176   }
05177   if (argc == 4) {
05178     int _v;
05179     void *vptr = 0;
05180     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_LifeCycleCORBA, 0);
05181     _v = SWIG_CheckState(res);
05182     if (_v) {
05183       {
05184         _v = PyDict_Check(argv[1])? 1 : 0;
05185       }
05186       if (_v) {
05187         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
05188         _v = SWIG_CheckState(res);
05189         if (_v) {
05190           {
05191             int res = SWIG_AsVal_int(argv[3], NULL);
05192             _v = SWIG_CheckState(res);
05193           }
05194           if (_v) {
05195             return _wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component__SWIG_0(self, args);
05196           }
05197         }
05198       }
05199     }
05200   }
05201   if (argc == 4) {
05202     int _v;
05203     void *vptr = 0;
05204     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_LifeCycleCORBA, 0);
05205     _v = SWIG_CheckState(res);
05206     if (_v) {
05207       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Engines__ContainerParameters, 0);
05208       _v = SWIG_CheckState(res);
05209       if (_v) {
05210         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
05211         _v = SWIG_CheckState(res);
05212         if (_v) {
05213           {
05214             int res = SWIG_AsVal_int(argv[3], NULL);
05215             _v = SWIG_CheckState(res);
05216           }
05217           if (_v) {
05218             return _wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component__SWIG_2(self, args);
05219           }
05220         }
05221       }
05222     }
05223   }
05224   
05225 fail:
05226   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SALOME_LifeCycleCORBA_FindOrLoad_Component'.\n"
05227     "  Possible C/C++ prototypes are:\n"
05228     "    FindOrLoad_Component(SALOME_LifeCycleCORBA *,Engines::MachineParameters const &,char const *,int)\n"
05229     "    FindOrLoad_Component(SALOME_LifeCycleCORBA *,Engines::MachineParameters const &,char const *)\n"
05230     "    FindOrLoad_Component(SALOME_LifeCycleCORBA *,Engines::ContainerParameters const &,char const *,int)\n"
05231     "    FindOrLoad_Component(SALOME_LifeCycleCORBA *,Engines::ContainerParameters const &,char const *)\n"
05232     "    FindOrLoad_Component(SALOME_LifeCycleCORBA *,char const *,char const *)\n");
05233   return NULL;
05234 }
05235 
05236 
05237 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_Load_ParallelComponent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05238   PyObject *resultobj = 0;
05239   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
05240   Engines::ContainerParameters *arg2 = 0 ;
05241   char *arg3 = (char *) 0 ;
05242   int arg4 ;
05243   void *argp1 = 0 ;
05244   int res1 = 0 ;
05245   void *argp2 = 0 ;
05246   int res2 = 0 ;
05247   int res3 ;
05248   char *buf3 = 0 ;
05249   int alloc3 = 0 ;
05250   int val4 ;
05251   int ecode4 = 0 ;
05252   PyObject * obj0 = 0 ;
05253   PyObject * obj1 = 0 ;
05254   PyObject * obj2 = 0 ;
05255   PyObject * obj3 = 0 ;
05256   Engines::EngineComponent_ptr result;
05257   
05258   if (!PyArg_ParseTuple(args,(char *)"OOOO:SALOME_LifeCycleCORBA_Load_ParallelComponent",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
05259   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
05260   if (!SWIG_IsOK(res1)) {
05261     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_Load_ParallelComponent" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
05262   }
05263   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
05264   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Engines__ContainerParameters,  0  | 0);
05265   if (!SWIG_IsOK(res2)) {
05266     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SALOME_LifeCycleCORBA_Load_ParallelComponent" "', argument " "2"" of type '" "Engines::ContainerParameters const &""'"); 
05267   }
05268   if (!argp2) {
05269     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SALOME_LifeCycleCORBA_Load_ParallelComponent" "', argument " "2"" of type '" "Engines::ContainerParameters const &""'"); 
05270   }
05271   arg2 = reinterpret_cast< Engines::ContainerParameters * >(argp2);
05272   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
05273   if (!SWIG_IsOK(res3)) {
05274     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_Load_ParallelComponent" "', argument " "3"" of type '" "char const *""'");
05275   }
05276   arg3 = reinterpret_cast< char * >(buf3);
05277   ecode4 = SWIG_AsVal_int(obj3, &val4);
05278   if (!SWIG_IsOK(ecode4)) {
05279     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SALOME_LifeCycleCORBA_Load_ParallelComponent" "', argument " "4"" of type '" "int""'");
05280   } 
05281   arg4 = static_cast< int >(val4);
05282   {
05283     Py_BEGIN_ALLOW_THREADS
05284     try {
05285       result = (arg1)->Load_ParallelComponent((Engines::ContainerParameters const &)*arg2,(char const *)arg3,arg4);
05286     }
05287     catch (ServiceUnreachable) {
05288       Py_BLOCK_THREADS
05289       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05290       return NULL;
05291     }
05292     catch (SALOME_Exception &e) {
05293       Py_BLOCK_THREADS
05294       PyErr_SetString(PyExc_RuntimeError,e.what());
05295       return NULL;
05296     }
05297     catch (SALOME::SALOME_Exception &e) {
05298       Py_BLOCK_THREADS
05299       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05300       return NULL;
05301     }
05302     catch (...) {
05303       Py_BLOCK_THREADS
05304       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05305       return NULL;
05306     }
05307     Py_END_ALLOW_THREADS
05308   }
05309   {
05310     MESSAGE("typemap out on CORBA object ptr");
05311     SCRUTE(result);
05312     resultobj = api->cxxObjRefToPyObjRef(result, 1);
05313     SCRUTE(resultobj);
05314   }
05315   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05316   return resultobj;
05317 fail:
05318   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05319   return NULL;
05320 }
05321 
05322 
05323 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_isKnownComponentClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05324   PyObject *resultobj = 0;
05325   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
05326   char *arg2 = (char *) 0 ;
05327   void *argp1 = 0 ;
05328   int res1 = 0 ;
05329   int res2 ;
05330   char *buf2 = 0 ;
05331   int alloc2 = 0 ;
05332   PyObject * obj0 = 0 ;
05333   PyObject * obj1 = 0 ;
05334   bool result;
05335   
05336   if (!PyArg_ParseTuple(args,(char *)"OO:SALOME_LifeCycleCORBA_isKnownComponentClass",&obj0,&obj1)) SWIG_fail;
05337   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
05338   if (!SWIG_IsOK(res1)) {
05339     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_isKnownComponentClass" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
05340   }
05341   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
05342   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05343   if (!SWIG_IsOK(res2)) {
05344     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SALOME_LifeCycleCORBA_isKnownComponentClass" "', argument " "2"" of type '" "char const *""'");
05345   }
05346   arg2 = reinterpret_cast< char * >(buf2);
05347   {
05348     Py_BEGIN_ALLOW_THREADS
05349     try {
05350       result = (bool)(arg1)->isKnownComponentClass((char const *)arg2);
05351     }
05352     catch (ServiceUnreachable) {
05353       Py_BLOCK_THREADS
05354       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05355       return NULL;
05356     }
05357     catch (SALOME_Exception &e) {
05358       Py_BLOCK_THREADS
05359       PyErr_SetString(PyExc_RuntimeError,e.what());
05360       return NULL;
05361     }
05362     catch (SALOME::SALOME_Exception &e) {
05363       Py_BLOCK_THREADS
05364       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05365       return NULL;
05366     }
05367     catch (...) {
05368       Py_BLOCK_THREADS
05369       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05370       return NULL;
05371     }
05372     Py_END_ALLOW_THREADS
05373   }
05374   resultobj = SWIG_From_bool(static_cast< bool >(result));
05375   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05376   return resultobj;
05377 fail:
05378   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05379   return NULL;
05380 }
05381 
05382 
05383 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_isMpiContainer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05384   PyObject *resultobj = 0;
05385   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
05386   Engines::ContainerParameters *arg2 = 0 ;
05387   void *argp1 = 0 ;
05388   int res1 = 0 ;
05389   void *argp2 = 0 ;
05390   int res2 = 0 ;
05391   PyObject * obj0 = 0 ;
05392   PyObject * obj1 = 0 ;
05393   bool result;
05394   
05395   if (!PyArg_ParseTuple(args,(char *)"OO:SALOME_LifeCycleCORBA_isMpiContainer",&obj0,&obj1)) SWIG_fail;
05396   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
05397   if (!SWIG_IsOK(res1)) {
05398     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_isMpiContainer" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
05399   }
05400   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
05401   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Engines__ContainerParameters,  0  | 0);
05402   if (!SWIG_IsOK(res2)) {
05403     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SALOME_LifeCycleCORBA_isMpiContainer" "', argument " "2"" of type '" "Engines::ContainerParameters const &""'"); 
05404   }
05405   if (!argp2) {
05406     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SALOME_LifeCycleCORBA_isMpiContainer" "', argument " "2"" of type '" "Engines::ContainerParameters const &""'"); 
05407   }
05408   arg2 = reinterpret_cast< Engines::ContainerParameters * >(argp2);
05409   {
05410     Py_BEGIN_ALLOW_THREADS
05411     try {
05412       try {
05413         result = (bool)(arg1)->isMpiContainer((Engines::ContainerParameters const &)*arg2);
05414       }
05415       catch(IncompatibleComponent &_e) {
05416         SWIG_Python_Raise(SWIG_NewPointerObj((new IncompatibleComponent(static_cast< const IncompatibleComponent& >(_e))),SWIGTYPE_p_IncompatibleComponent,SWIG_POINTER_OWN), "IncompatibleComponent", SWIGTYPE_p_IncompatibleComponent); SWIG_fail;
05417       }
05418       
05419     }
05420     catch (ServiceUnreachable) {
05421       Py_BLOCK_THREADS
05422       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05423       return NULL;
05424     }
05425     catch (SALOME_Exception &e) {
05426       Py_BLOCK_THREADS
05427       PyErr_SetString(PyExc_RuntimeError,e.what());
05428       return NULL;
05429     }
05430     catch (SALOME::SALOME_Exception &e) {
05431       Py_BLOCK_THREADS
05432       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05433       return NULL;
05434     }
05435     catch (...) {
05436       Py_BLOCK_THREADS
05437       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05438       return NULL;
05439     }
05440     Py_END_ALLOW_THREADS
05441   }
05442   resultobj = SWIG_From_bool(static_cast< bool >(result));
05443   return resultobj;
05444 fail:
05445   return NULL;
05446 }
05447 
05448 
05449 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_NbProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05450   PyObject *resultobj = 0;
05451   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
05452   Engines::ContainerParameters *arg2 = 0 ;
05453   void *argp1 = 0 ;
05454   int res1 = 0 ;
05455   void *argp2 = 0 ;
05456   int res2 = 0 ;
05457   PyObject * obj0 = 0 ;
05458   PyObject * obj1 = 0 ;
05459   int result;
05460   
05461   if (!PyArg_ParseTuple(args,(char *)"OO:SALOME_LifeCycleCORBA_NbProc",&obj0,&obj1)) SWIG_fail;
05462   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
05463   if (!SWIG_IsOK(res1)) {
05464     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_NbProc" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
05465   }
05466   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
05467   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Engines__ContainerParameters,  0  | 0);
05468   if (!SWIG_IsOK(res2)) {
05469     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SALOME_LifeCycleCORBA_NbProc" "', argument " "2"" of type '" "Engines::ContainerParameters const &""'"); 
05470   }
05471   if (!argp2) {
05472     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SALOME_LifeCycleCORBA_NbProc" "', argument " "2"" of type '" "Engines::ContainerParameters const &""'"); 
05473   }
05474   arg2 = reinterpret_cast< Engines::ContainerParameters * >(argp2);
05475   {
05476     Py_BEGIN_ALLOW_THREADS
05477     try {
05478       result = (int)(arg1)->NbProc((Engines::ContainerParameters const &)*arg2);
05479     }
05480     catch (ServiceUnreachable) {
05481       Py_BLOCK_THREADS
05482       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05483       return NULL;
05484     }
05485     catch (SALOME_Exception &e) {
05486       Py_BLOCK_THREADS
05487       PyErr_SetString(PyExc_RuntimeError,e.what());
05488       return NULL;
05489     }
05490     catch (SALOME::SALOME_Exception &e) {
05491       Py_BLOCK_THREADS
05492       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05493       return NULL;
05494     }
05495     catch (...) {
05496       Py_BLOCK_THREADS
05497       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05498       return NULL;
05499     }
05500     Py_END_ALLOW_THREADS
05501   }
05502   resultobj = SWIG_From_int(static_cast< int >(result));
05503   return resultobj;
05504 fail:
05505   return NULL;
05506 }
05507 
05508 
05509 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_preSet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05510   PyObject *resultobj = 0;
05511   Engines::MachineParameters *arg1 = 0 ;
05512   void *argp1 = 0 ;
05513   int res1 = 0 ;
05514   PyObject * obj0 = 0 ;
05515   
05516   if (!PyArg_ParseTuple(args,(char *)"O:SALOME_LifeCycleCORBA_preSet",&obj0)) SWIG_fail;
05517   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Engines__MachineParameters,  0 );
05518   if (!SWIG_IsOK(res1)) {
05519     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_preSet" "', argument " "1"" of type '" "Engines::MachineParameters &""'"); 
05520   }
05521   if (!argp1) {
05522     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SALOME_LifeCycleCORBA_preSet" "', argument " "1"" of type '" "Engines::MachineParameters &""'"); 
05523   }
05524   arg1 = reinterpret_cast< Engines::MachineParameters * >(argp1);
05525   {
05526     Py_BEGIN_ALLOW_THREADS
05527     try {
05528       SALOME_LifeCycleCORBA::preSet(*arg1);
05529     }
05530     catch (ServiceUnreachable) {
05531       Py_BLOCK_THREADS
05532       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05533       return NULL;
05534     }
05535     catch (SALOME_Exception &e) {
05536       Py_BLOCK_THREADS
05537       PyErr_SetString(PyExc_RuntimeError,e.what());
05538       return NULL;
05539     }
05540     catch (SALOME::SALOME_Exception &e) {
05541       Py_BLOCK_THREADS
05542       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05543       return NULL;
05544     }
05545     catch (...) {
05546       Py_BLOCK_THREADS
05547       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05548       return NULL;
05549     }
05550     Py_END_ALLOW_THREADS
05551   }
05552   resultobj = SWIG_Py_Void();
05553   return resultobj;
05554 fail:
05555   return NULL;
05556 }
05557 
05558 
05559 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_preSet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05560   PyObject *resultobj = 0;
05561   Engines::ResourceParameters *arg1 = 0 ;
05562   void *argp1 = 0 ;
05563   int res1 = 0 ;
05564   PyObject * obj0 = 0 ;
05565   
05566   if (!PyArg_ParseTuple(args,(char *)"O:SALOME_LifeCycleCORBA_preSet",&obj0)) SWIG_fail;
05567   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Engines__ResourceParameters,  0 );
05568   if (!SWIG_IsOK(res1)) {
05569     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_preSet" "', argument " "1"" of type '" "Engines::ResourceParameters &""'"); 
05570   }
05571   if (!argp1) {
05572     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SALOME_LifeCycleCORBA_preSet" "', argument " "1"" of type '" "Engines::ResourceParameters &""'"); 
05573   }
05574   arg1 = reinterpret_cast< Engines::ResourceParameters * >(argp1);
05575   {
05576     Py_BEGIN_ALLOW_THREADS
05577     try {
05578       SALOME_LifeCycleCORBA::preSet(*arg1);
05579     }
05580     catch (ServiceUnreachable) {
05581       Py_BLOCK_THREADS
05582       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05583       return NULL;
05584     }
05585     catch (SALOME_Exception &e) {
05586       Py_BLOCK_THREADS
05587       PyErr_SetString(PyExc_RuntimeError,e.what());
05588       return NULL;
05589     }
05590     catch (SALOME::SALOME_Exception &e) {
05591       Py_BLOCK_THREADS
05592       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05593       return NULL;
05594     }
05595     catch (...) {
05596       Py_BLOCK_THREADS
05597       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05598       return NULL;
05599     }
05600     Py_END_ALLOW_THREADS
05601   }
05602   resultobj = SWIG_Py_Void();
05603   return resultobj;
05604 fail:
05605   return NULL;
05606 }
05607 
05608 
05609 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_preSet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05610   PyObject *resultobj = 0;
05611   Engines::ContainerParameters *arg1 = 0 ;
05612   void *argp1 = 0 ;
05613   int res1 = 0 ;
05614   PyObject * obj0 = 0 ;
05615   
05616   if (!PyArg_ParseTuple(args,(char *)"O:SALOME_LifeCycleCORBA_preSet",&obj0)) SWIG_fail;
05617   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Engines__ContainerParameters,  0 );
05618   if (!SWIG_IsOK(res1)) {
05619     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_preSet" "', argument " "1"" of type '" "Engines::ContainerParameters &""'"); 
05620   }
05621   if (!argp1) {
05622     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SALOME_LifeCycleCORBA_preSet" "', argument " "1"" of type '" "Engines::ContainerParameters &""'"); 
05623   }
05624   arg1 = reinterpret_cast< Engines::ContainerParameters * >(argp1);
05625   {
05626     Py_BEGIN_ALLOW_THREADS
05627     try {
05628       SALOME_LifeCycleCORBA::preSet(*arg1);
05629     }
05630     catch (ServiceUnreachable) {
05631       Py_BLOCK_THREADS
05632       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05633       return NULL;
05634     }
05635     catch (SALOME_Exception &e) {
05636       Py_BLOCK_THREADS
05637       PyErr_SetString(PyExc_RuntimeError,e.what());
05638       return NULL;
05639     }
05640     catch (SALOME::SALOME_Exception &e) {
05641       Py_BLOCK_THREADS
05642       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05643       return NULL;
05644     }
05645     catch (...) {
05646       Py_BLOCK_THREADS
05647       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05648       return NULL;
05649     }
05650     Py_END_ALLOW_THREADS
05651   }
05652   resultobj = SWIG_Py_Void();
05653   return resultobj;
05654 fail:
05655   return NULL;
05656 }
05657 
05658 
05659 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_preSet(PyObject *self, PyObject *args) {
05660   int argc;
05661   PyObject *argv[2];
05662   int ii;
05663   
05664   if (!PyTuple_Check(args)) SWIG_fail;
05665   argc = (int)PyObject_Length(args);
05666   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
05667     argv[ii] = PyTuple_GET_ITEM(args,ii);
05668   }
05669   if (argc == 1) {
05670     int _v;
05671     void *vptr = 0;
05672     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Engines__MachineParameters, 0);
05673     _v = SWIG_CheckState(res);
05674     if (_v) {
05675       return _wrap_SALOME_LifeCycleCORBA_preSet__SWIG_0(self, args);
05676     }
05677   }
05678   if (argc == 1) {
05679     int _v;
05680     void *vptr = 0;
05681     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Engines__ResourceParameters, 0);
05682     _v = SWIG_CheckState(res);
05683     if (_v) {
05684       return _wrap_SALOME_LifeCycleCORBA_preSet__SWIG_1(self, args);
05685     }
05686   }
05687   if (argc == 1) {
05688     int _v;
05689     void *vptr = 0;
05690     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Engines__ContainerParameters, 0);
05691     _v = SWIG_CheckState(res);
05692     if (_v) {
05693       return _wrap_SALOME_LifeCycleCORBA_preSet__SWIG_2(self, args);
05694     }
05695   }
05696   
05697 fail:
05698   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SALOME_LifeCycleCORBA_preSet'.\n"
05699     "  Possible C/C++ prototypes are:\n"
05700     "    preSet(Engines::MachineParameters &)\n"
05701     "    preSet(Engines::ResourceParameters &)\n"
05702     "    SALOME_LifeCycleCORBA::preSet(Engines::ContainerParameters &)\n");
05703   return NULL;
05704 }
05705 
05706 
05707 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_getContainerManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05708   PyObject *resultobj = 0;
05709   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
05710   void *argp1 = 0 ;
05711   int res1 = 0 ;
05712   PyObject * obj0 = 0 ;
05713   Engines::ContainerManager_ptr result;
05714   
05715   if (!PyArg_ParseTuple(args,(char *)"O:SALOME_LifeCycleCORBA_getContainerManager",&obj0)) SWIG_fail;
05716   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
05717   if (!SWIG_IsOK(res1)) {
05718     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_getContainerManager" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
05719   }
05720   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
05721   {
05722     Py_BEGIN_ALLOW_THREADS
05723     try {
05724       result = (arg1)->getContainerManager();
05725     }
05726     catch (ServiceUnreachable) {
05727       Py_BLOCK_THREADS
05728       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05729       return NULL;
05730     }
05731     catch (SALOME_Exception &e) {
05732       Py_BLOCK_THREADS
05733       PyErr_SetString(PyExc_RuntimeError,e.what());
05734       return NULL;
05735     }
05736     catch (SALOME::SALOME_Exception &e) {
05737       Py_BLOCK_THREADS
05738       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05739       return NULL;
05740     }
05741     catch (...) {
05742       Py_BLOCK_THREADS
05743       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05744       return NULL;
05745     }
05746     Py_END_ALLOW_THREADS
05747   }
05748   {
05749     MESSAGE("typemap out on CORBA object ptr");
05750     SCRUTE(result);
05751     resultobj = api->cxxObjRefToPyObjRef(result, 1);
05752     SCRUTE(resultobj);
05753   }
05754   return resultobj;
05755 fail:
05756   return NULL;
05757 }
05758 
05759 
05760 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_getResourcesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05761   PyObject *resultobj = 0;
05762   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
05763   void *argp1 = 0 ;
05764   int res1 = 0 ;
05765   PyObject * obj0 = 0 ;
05766   Engines::ResourcesManager_ptr result;
05767   
05768   if (!PyArg_ParseTuple(args,(char *)"O:SALOME_LifeCycleCORBA_getResourcesManager",&obj0)) SWIG_fail;
05769   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
05770   if (!SWIG_IsOK(res1)) {
05771     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_getResourcesManager" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
05772   }
05773   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
05774   {
05775     Py_BEGIN_ALLOW_THREADS
05776     try {
05777       result = (arg1)->getResourcesManager();
05778     }
05779     catch (ServiceUnreachable) {
05780       Py_BLOCK_THREADS
05781       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05782       return NULL;
05783     }
05784     catch (SALOME_Exception &e) {
05785       Py_BLOCK_THREADS
05786       PyErr_SetString(PyExc_RuntimeError,e.what());
05787       return NULL;
05788     }
05789     catch (SALOME::SALOME_Exception &e) {
05790       Py_BLOCK_THREADS
05791       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05792       return NULL;
05793     }
05794     catch (...) {
05795       Py_BLOCK_THREADS
05796       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05797       return NULL;
05798     }
05799     Py_END_ALLOW_THREADS
05800   }
05801   {
05802     MESSAGE("typemap out on CORBA object ptr");
05803     SCRUTE(result);
05804     resultobj = api->cxxObjRefToPyObjRef(result, 1);
05805     SCRUTE(resultobj);
05806   }
05807   return resultobj;
05808 fail:
05809   return NULL;
05810 }
05811 
05812 
05813 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_namingService(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05814   PyObject *resultobj = 0;
05815   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
05816   void *argp1 = 0 ;
05817   int res1 = 0 ;
05818   PyObject * obj0 = 0 ;
05819   SALOME_NamingService *result = 0 ;
05820   
05821   if (!PyArg_ParseTuple(args,(char *)"O:SALOME_LifeCycleCORBA_namingService",&obj0)) SWIG_fail;
05822   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
05823   if (!SWIG_IsOK(res1)) {
05824     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_namingService" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
05825   }
05826   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
05827   {
05828     Py_BEGIN_ALLOW_THREADS
05829     try {
05830       result = (SALOME_NamingService *)(arg1)->namingService();
05831     }
05832     catch (ServiceUnreachable) {
05833       Py_BLOCK_THREADS
05834       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05835       return NULL;
05836     }
05837     catch (SALOME_Exception &e) {
05838       Py_BLOCK_THREADS
05839       PyErr_SetString(PyExc_RuntimeError,e.what());
05840       return NULL;
05841     }
05842     catch (SALOME::SALOME_Exception &e) {
05843       Py_BLOCK_THREADS
05844       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05845       return NULL;
05846     }
05847     catch (...) {
05848       Py_BLOCK_THREADS
05849       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05850       return NULL;
05851     }
05852     Py_END_ALLOW_THREADS
05853   }
05854   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SALOME_NamingService, 0 |  0 );
05855   return resultobj;
05856 fail:
05857   return NULL;
05858 }
05859 
05860 
05861 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_orb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05862   PyObject *resultobj = 0;
05863   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
05864   void *argp1 = 0 ;
05865   int res1 = 0 ;
05866   PyObject * obj0 = 0 ;
05867   CORBA::ORB_ptr result;
05868   
05869   if (!PyArg_ParseTuple(args,(char *)"O:SALOME_LifeCycleCORBA_orb",&obj0)) SWIG_fail;
05870   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
05871   if (!SWIG_IsOK(res1)) {
05872     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_orb" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
05873   }
05874   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
05875   {
05876     Py_BEGIN_ALLOW_THREADS
05877     try {
05878       result = (arg1)->orb();
05879     }
05880     catch (ServiceUnreachable) {
05881       Py_BLOCK_THREADS
05882       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05883       return NULL;
05884     }
05885     catch (SALOME_Exception &e) {
05886       Py_BLOCK_THREADS
05887       PyErr_SetString(PyExc_RuntimeError,e.what());
05888       return NULL;
05889     }
05890     catch (SALOME::SALOME_Exception &e) {
05891       Py_BLOCK_THREADS
05892       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05893       return NULL;
05894     }
05895     catch (...) {
05896       Py_BLOCK_THREADS
05897       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05898       return NULL;
05899     }
05900     Py_END_ALLOW_THREADS
05901   }
05902   resultobj = SWIG_NewPointerObj((new CORBA::ORB_ptr(static_cast< const CORBA::ORB_ptr& >(result))), SWIGTYPE_p_CORBA__ORB_ptr, SWIG_POINTER_OWN |  0 );
05903   return resultobj;
05904 fail:
05905   return NULL;
05906 }
05907 
05908 
05909 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_copyFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05910   PyObject *resultobj = 0;
05911   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
05912   char *arg2 = (char *) 0 ;
05913   char *arg3 = (char *) 0 ;
05914   char *arg4 = (char *) 0 ;
05915   char *arg5 = (char *) 0 ;
05916   void *argp1 = 0 ;
05917   int res1 = 0 ;
05918   int res2 ;
05919   char *buf2 = 0 ;
05920   int alloc2 = 0 ;
05921   int res3 ;
05922   char *buf3 = 0 ;
05923   int alloc3 = 0 ;
05924   int res4 ;
05925   char *buf4 = 0 ;
05926   int alloc4 = 0 ;
05927   int res5 ;
05928   char *buf5 = 0 ;
05929   int alloc5 = 0 ;
05930   PyObject * obj0 = 0 ;
05931   PyObject * obj1 = 0 ;
05932   PyObject * obj2 = 0 ;
05933   PyObject * obj3 = 0 ;
05934   PyObject * obj4 = 0 ;
05935   
05936   if (!PyArg_ParseTuple(args,(char *)"OOOOO:SALOME_LifeCycleCORBA_copyFile",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
05937   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
05938   if (!SWIG_IsOK(res1)) {
05939     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_copyFile" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
05940   }
05941   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
05942   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05943   if (!SWIG_IsOK(res2)) {
05944     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SALOME_LifeCycleCORBA_copyFile" "', argument " "2"" of type '" "char const *""'");
05945   }
05946   arg2 = reinterpret_cast< char * >(buf2);
05947   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
05948   if (!SWIG_IsOK(res3)) {
05949     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_copyFile" "', argument " "3"" of type '" "char const *""'");
05950   }
05951   arg3 = reinterpret_cast< char * >(buf3);
05952   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
05953   if (!SWIG_IsOK(res4)) {
05954     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SALOME_LifeCycleCORBA_copyFile" "', argument " "4"" of type '" "char const *""'");
05955   }
05956   arg4 = reinterpret_cast< char * >(buf4);
05957   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
05958   if (!SWIG_IsOK(res5)) {
05959     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SALOME_LifeCycleCORBA_copyFile" "', argument " "5"" of type '" "char const *""'");
05960   }
05961   arg5 = reinterpret_cast< char * >(buf5);
05962   {
05963     Py_BEGIN_ALLOW_THREADS
05964     try {
05965       (arg1)->copyFile((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
05966     }
05967     catch (ServiceUnreachable) {
05968       Py_BLOCK_THREADS
05969       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
05970       return NULL;
05971     }
05972     catch (SALOME_Exception &e) {
05973       Py_BLOCK_THREADS
05974       PyErr_SetString(PyExc_RuntimeError,e.what());
05975       return NULL;
05976     }
05977     catch (SALOME::SALOME_Exception &e) {
05978       Py_BLOCK_THREADS
05979       PyErr_SetString(PyExc_RuntimeError,e.details.text);
05980       return NULL;
05981     }
05982     catch (...) {
05983       Py_BLOCK_THREADS
05984       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
05985       return NULL;
05986     }
05987     Py_END_ALLOW_THREADS
05988   }
05989   resultobj = SWIG_Py_Void();
05990   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05991   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05992   if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
05993   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
05994   return resultobj;
05995 fail:
05996   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05997   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
05998   if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
05999   if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
06000   return NULL;
06001 }
06002 
06003 
06004 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_shutdownServers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06005   PyObject *resultobj = 0;
06006   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
06007   void *argp1 = 0 ;
06008   int res1 = 0 ;
06009   PyObject * obj0 = 0 ;
06010   
06011   if (!PyArg_ParseTuple(args,(char *)"O:SALOME_LifeCycleCORBA_shutdownServers",&obj0)) SWIG_fail;
06012   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
06013   if (!SWIG_IsOK(res1)) {
06014     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_shutdownServers" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
06015   }
06016   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
06017   {
06018     Py_BEGIN_ALLOW_THREADS
06019     try {
06020       (arg1)->shutdownServers();
06021     }
06022     catch (ServiceUnreachable) {
06023       Py_BLOCK_THREADS
06024       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
06025       return NULL;
06026     }
06027     catch (SALOME_Exception &e) {
06028       Py_BLOCK_THREADS
06029       PyErr_SetString(PyExc_RuntimeError,e.what());
06030       return NULL;
06031     }
06032     catch (SALOME::SALOME_Exception &e) {
06033       Py_BLOCK_THREADS
06034       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06035       return NULL;
06036     }
06037     catch (...) {
06038       Py_BLOCK_THREADS
06039       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
06040       return NULL;
06041     }
06042     Py_END_ALLOW_THREADS
06043   }
06044   resultobj = SWIG_Py_Void();
06045   return resultobj;
06046 fail:
06047   return NULL;
06048 }
06049 
06050 
06051 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_killOmniNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06052   PyObject *resultobj = 0;
06053   
06054   if (!PyArg_ParseTuple(args,(char *)":SALOME_LifeCycleCORBA_killOmniNames")) SWIG_fail;
06055   {
06056     Py_BEGIN_ALLOW_THREADS
06057     try {
06058       SALOME_LifeCycleCORBA::killOmniNames();
06059     }
06060     catch (ServiceUnreachable) {
06061       Py_BLOCK_THREADS
06062       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
06063       return NULL;
06064     }
06065     catch (SALOME_Exception &e) {
06066       Py_BLOCK_THREADS
06067       PyErr_SetString(PyExc_RuntimeError,e.what());
06068       return NULL;
06069     }
06070     catch (SALOME::SALOME_Exception &e) {
06071       Py_BLOCK_THREADS
06072       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06073       return NULL;
06074     }
06075     catch (...) {
06076       Py_BLOCK_THREADS
06077       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
06078       return NULL;
06079     }
06080     Py_END_ALLOW_THREADS
06081   }
06082   resultobj = SWIG_Py_Void();
06083   return resultobj;
06084 fail:
06085   return NULL;
06086 }
06087 
06088 
06089 SWIGINTERN PyObject *_wrap_SALOME_LifeCycleCORBA_convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06090   PyObject *resultobj = 0;
06091   SALOME_LifeCycleCORBA *arg1 = (SALOME_LifeCycleCORBA *) 0 ;
06092   Engines::MachineParameters *arg2 = 0 ;
06093   Engines::ContainerParameters *arg3 = 0 ;
06094   void *argp1 = 0 ;
06095   int res1 = 0 ;
06096   void *argp3 = 0 ;
06097   int res3 = 0 ;
06098   PyObject * obj0 = 0 ;
06099   PyObject * obj1 = 0 ;
06100   PyObject * obj2 = 0 ;
06101   
06102   if (!PyArg_ParseTuple(args,(char *)"OOO:SALOME_LifeCycleCORBA_convert",&obj0,&obj1,&obj2)) SWIG_fail;
06103   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_LifeCycleCORBA, 0 |  0 );
06104   if (!SWIG_IsOK(res1)) {
06105     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_LifeCycleCORBA_convert" "', argument " "1"" of type '" "SALOME_LifeCycleCORBA *""'"); 
06106   }
06107   arg1 = reinterpret_cast< SALOME_LifeCycleCORBA * >(argp1);
06108   {
06109     //printf("typemap in on Engines::MachineParameters\n");
06110     MESSAGE("typemap in on Engines::MachineParameters");
06111     if (PyDict_Check(obj1) == 1)
06112     {
06113       Engines::MachineParameters *param = new Engines::MachineParameters ;
06114       SALOME_LifeCycleCORBA::preSet(*param);
06115       
06116       PyObject *key, *value;
06117       Py_ssize_t pos = 0;
06118       while (PyDict_Next(obj1, &pos, &key, &value))
06119       {
06120         char* keystr = PyString_AsString(key);
06121         if (strcmp(keystr,"container_name")==0)
06122         {
06123           param->container_name = CORBA::string_dup(PyString_AsString(value));
06124         }
06125         else if (strcmp(keystr,"hostname")==0)
06126         {
06127           param->hostname = CORBA::string_dup(PyString_AsString(value));
06128         }
06129         else if (strcmp(keystr,"OS")==0)
06130         {
06131           param->OS = CORBA::string_dup(PyString_AsString(value));
06132         }
06133         else if (strcmp(keystr,"mem_mb")==0)
06134         {
06135           param->mem_mb = PyLong_AsLong(value);
06136         }
06137         else if (strcmp(keystr,"cpu_clock")==0)
06138         {
06139           param->cpu_clock = PyLong_AsLong(value);
06140         }
06141         else if (strcmp(keystr,"nb_proc_per_node")==0)
06142         {
06143           param->nb_proc_per_node = PyLong_AsLong(value);
06144         }
06145         else if (strcmp(keystr,"nb_node")==0)
06146         {
06147           param->nb_node = PyLong_AsLong(value);
06148         }
06149         else if (strcmp(keystr,"isMPI")==0)
06150         {
06151           param->isMPI = PyLong_AsLong(value);
06152         }
06153         else if (strcmp(keystr,"workingdir")==0)
06154         param->workingdir = CORBA::string_dup(PyString_AsString(value));
06155         else if (strcmp(keystr,"mode")==0)
06156         param->mode = CORBA::string_dup(PyString_AsString(value));
06157         else if (strcmp(keystr,"policy")==0)
06158         param->policy = CORBA::string_dup(PyString_AsString(value));
06159         else if (strcmp(keystr,"parallelLib")==0)
06160         {
06161           param->parallelLib = CORBA::string_dup(PyString_AsString(value));
06162         }
06163         else if (strcmp(keystr,"nb_component_nodes")==0)
06164         {
06165           param->nb_component_nodes = PyLong_AsLong(value);
06166         }
06167       }
06168       arg2 = param;
06169     }
06170     else 
06171     {
06172       MESSAGE("Not a dictionnary");
06173       PyErr_SetString(PyExc_TypeError,"Must Be a Python Dictionnary");
06174       return NULL;
06175     }
06176   }
06177   res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Engines__ContainerParameters,  0 );
06178   if (!SWIG_IsOK(res3)) {
06179     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SALOME_LifeCycleCORBA_convert" "', argument " "3"" of type '" "Engines::ContainerParameters &""'"); 
06180   }
06181   if (!argp3) {
06182     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SALOME_LifeCycleCORBA_convert" "', argument " "3"" of type '" "Engines::ContainerParameters &""'"); 
06183   }
06184   arg3 = reinterpret_cast< Engines::ContainerParameters * >(argp3);
06185   {
06186     Py_BEGIN_ALLOW_THREADS
06187     try {
06188       (arg1)->convert((Engines::MachineParameters const &)*arg2,*arg3);
06189     }
06190     catch (ServiceUnreachable) {
06191       Py_BLOCK_THREADS
06192       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
06193       return NULL;
06194     }
06195     catch (SALOME_Exception &e) {
06196       Py_BLOCK_THREADS
06197       PyErr_SetString(PyExc_RuntimeError,e.what());
06198       return NULL;
06199     }
06200     catch (SALOME::SALOME_Exception &e) {
06201       Py_BLOCK_THREADS
06202       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06203       return NULL;
06204     }
06205     catch (...) {
06206       Py_BLOCK_THREADS
06207       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
06208       return NULL;
06209     }
06210     Py_END_ALLOW_THREADS
06211   }
06212   resultobj = SWIG_Py_Void();
06213   {
06214     MESSAGE("delete arg2");
06215     delete arg2;
06216   }
06217   return resultobj;
06218 fail:
06219   {
06220     MESSAGE("delete arg2");
06221     delete arg2;
06222   }
06223   return NULL;
06224 }
06225 
06226 
06227 SWIGINTERN PyObject *SALOME_LifeCycleCORBA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06228   PyObject *obj;
06229   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
06230   SWIG_TypeNewClientData(SWIGTYPE_p_SALOME_LifeCycleCORBA, SWIG_NewClientData(obj));
06231   return SWIG_Py_Void();
06232 }
06233 
06234 SWIGINTERN PyObject *_wrap_new_SALOME_FileTransferCORBA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06235   PyObject *resultobj = 0;
06236   SALOME_FileTransferCORBA *result = 0 ;
06237   
06238   if (!PyArg_ParseTuple(args,(char *)":new_SALOME_FileTransferCORBA")) SWIG_fail;
06239   {
06240     Py_BEGIN_ALLOW_THREADS
06241     try {
06242       result = (SALOME_FileTransferCORBA *)new SALOME_FileTransferCORBA();
06243     }
06244     catch (ServiceUnreachable) {
06245       Py_BLOCK_THREADS
06246       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
06247       return NULL;
06248     }
06249     catch (SALOME_Exception &e) {
06250       Py_BLOCK_THREADS
06251       PyErr_SetString(PyExc_RuntimeError,e.what());
06252       return NULL;
06253     }
06254     catch (SALOME::SALOME_Exception &e) {
06255       Py_BLOCK_THREADS
06256       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06257       return NULL;
06258     }
06259     catch (...) {
06260       Py_BLOCK_THREADS
06261       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
06262       return NULL;
06263     }
06264     Py_END_ALLOW_THREADS
06265   }
06266   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SALOME_FileTransferCORBA, SWIG_POINTER_NEW |  0 );
06267   return resultobj;
06268 fail:
06269   return NULL;
06270 }
06271 
06272 
06273 SWIGINTERN PyObject *_wrap_new_SALOME_FileTransferCORBA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06274   PyObject *resultobj = 0;
06275   Engines::fileRef_ptr arg1 ;
06276   PyObject * obj0 = 0 ;
06277   SALOME_FileTransferCORBA *result = 0 ;
06278   
06279   if (!PyArg_ParseTuple(args,(char *)"O:new_SALOME_FileTransferCORBA",&obj0)) SWIG_fail;
06280   {
06281     MESSAGE("typemap in on CORBA object ptr");
06282     try {
06283       CORBA::Object_ptr obj = api->pyObjRefToCxxObjRef(obj0,1);
06284       arg1 = Engines::fileRef::_narrow(obj);
06285       SCRUTE(arg1);
06286     }
06287     catch (...) {
06288       PyErr_SetString(PyExc_RuntimeError, "not a valid CORBA object ptr");
06289     }
06290   }
06291   {
06292     Py_BEGIN_ALLOW_THREADS
06293     try {
06294       result = (SALOME_FileTransferCORBA *)new SALOME_FileTransferCORBA(arg1);
06295     }
06296     catch (ServiceUnreachable) {
06297       Py_BLOCK_THREADS
06298       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
06299       return NULL;
06300     }
06301     catch (SALOME_Exception &e) {
06302       Py_BLOCK_THREADS
06303       PyErr_SetString(PyExc_RuntimeError,e.what());
06304       return NULL;
06305     }
06306     catch (SALOME::SALOME_Exception &e) {
06307       Py_BLOCK_THREADS
06308       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06309       return NULL;
06310     }
06311     catch (...) {
06312       Py_BLOCK_THREADS
06313       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
06314       return NULL;
06315     }
06316     Py_END_ALLOW_THREADS
06317   }
06318   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SALOME_FileTransferCORBA, SWIG_POINTER_NEW |  0 );
06319   return resultobj;
06320 fail:
06321   return NULL;
06322 }
06323 
06324 
06325 SWIGINTERN PyObject *_wrap_new_SALOME_FileTransferCORBA__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06326   PyObject *resultobj = 0;
06327   std::string arg1 ;
06328   std::string arg2 ;
06329   std::string arg3 ;
06330   PyObject * obj0 = 0 ;
06331   PyObject * obj1 = 0 ;
06332   PyObject * obj2 = 0 ;
06333   SALOME_FileTransferCORBA *result = 0 ;
06334   
06335   if (!PyArg_ParseTuple(args,(char *)"OOO:new_SALOME_FileTransferCORBA",&obj0,&obj1,&obj2)) SWIG_fail;
06336   {
06337     std::string *ptr = (std::string *)0;
06338     int res = SWIG_AsPtr_std_string(obj0, &ptr);
06339     if (!SWIG_IsOK(res) || !ptr) {
06340       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SALOME_FileTransferCORBA" "', argument " "1"" of type '" "std::string""'"); 
06341     }
06342     arg1 = *ptr;
06343     if (SWIG_IsNewObj(res)) delete ptr;
06344   }
06345   {
06346     std::string *ptr = (std::string *)0;
06347     int res = SWIG_AsPtr_std_string(obj1, &ptr);
06348     if (!SWIG_IsOK(res) || !ptr) {
06349       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SALOME_FileTransferCORBA" "', argument " "2"" of type '" "std::string""'"); 
06350     }
06351     arg2 = *ptr;
06352     if (SWIG_IsNewObj(res)) delete ptr;
06353   }
06354   {
06355     std::string *ptr = (std::string *)0;
06356     int res = SWIG_AsPtr_std_string(obj2, &ptr);
06357     if (!SWIG_IsOK(res) || !ptr) {
06358       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SALOME_FileTransferCORBA" "', argument " "3"" of type '" "std::string""'"); 
06359     }
06360     arg3 = *ptr;
06361     if (SWIG_IsNewObj(res)) delete ptr;
06362   }
06363   {
06364     Py_BEGIN_ALLOW_THREADS
06365     try {
06366       result = (SALOME_FileTransferCORBA *)new SALOME_FileTransferCORBA(arg1,arg2,arg3);
06367     }
06368     catch (ServiceUnreachable) {
06369       Py_BLOCK_THREADS
06370       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
06371       return NULL;
06372     }
06373     catch (SALOME_Exception &e) {
06374       Py_BLOCK_THREADS
06375       PyErr_SetString(PyExc_RuntimeError,e.what());
06376       return NULL;
06377     }
06378     catch (SALOME::SALOME_Exception &e) {
06379       Py_BLOCK_THREADS
06380       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06381       return NULL;
06382     }
06383     catch (...) {
06384       Py_BLOCK_THREADS
06385       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
06386       return NULL;
06387     }
06388     Py_END_ALLOW_THREADS
06389   }
06390   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SALOME_FileTransferCORBA, SWIG_POINTER_NEW |  0 );
06391   return resultobj;
06392 fail:
06393   return NULL;
06394 }
06395 
06396 
06397 SWIGINTERN PyObject *_wrap_new_SALOME_FileTransferCORBA__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06398   PyObject *resultobj = 0;
06399   std::string arg1 ;
06400   std::string arg2 ;
06401   PyObject * obj0 = 0 ;
06402   PyObject * obj1 = 0 ;
06403   SALOME_FileTransferCORBA *result = 0 ;
06404   
06405   if (!PyArg_ParseTuple(args,(char *)"OO:new_SALOME_FileTransferCORBA",&obj0,&obj1)) SWIG_fail;
06406   {
06407     std::string *ptr = (std::string *)0;
06408     int res = SWIG_AsPtr_std_string(obj0, &ptr);
06409     if (!SWIG_IsOK(res) || !ptr) {
06410       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SALOME_FileTransferCORBA" "', argument " "1"" of type '" "std::string""'"); 
06411     }
06412     arg1 = *ptr;
06413     if (SWIG_IsNewObj(res)) delete ptr;
06414   }
06415   {
06416     std::string *ptr = (std::string *)0;
06417     int res = SWIG_AsPtr_std_string(obj1, &ptr);
06418     if (!SWIG_IsOK(res) || !ptr) {
06419       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SALOME_FileTransferCORBA" "', argument " "2"" of type '" "std::string""'"); 
06420     }
06421     arg2 = *ptr;
06422     if (SWIG_IsNewObj(res)) delete ptr;
06423   }
06424   {
06425     Py_BEGIN_ALLOW_THREADS
06426     try {
06427       result = (SALOME_FileTransferCORBA *)new SALOME_FileTransferCORBA(arg1,arg2);
06428     }
06429     catch (ServiceUnreachable) {
06430       Py_BLOCK_THREADS
06431       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
06432       return NULL;
06433     }
06434     catch (SALOME_Exception &e) {
06435       Py_BLOCK_THREADS
06436       PyErr_SetString(PyExc_RuntimeError,e.what());
06437       return NULL;
06438     }
06439     catch (SALOME::SALOME_Exception &e) {
06440       Py_BLOCK_THREADS
06441       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06442       return NULL;
06443     }
06444     catch (...) {
06445       Py_BLOCK_THREADS
06446       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
06447       return NULL;
06448     }
06449     Py_END_ALLOW_THREADS
06450   }
06451   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SALOME_FileTransferCORBA, SWIG_POINTER_NEW |  0 );
06452   return resultobj;
06453 fail:
06454   return NULL;
06455 }
06456 
06457 
06458 SWIGINTERN PyObject *_wrap_new_SALOME_FileTransferCORBA(PyObject *self, PyObject *args) {
06459   int argc;
06460   PyObject *argv[4];
06461   int ii;
06462   
06463   if (!PyTuple_Check(args)) SWIG_fail;
06464   argc = (int)PyObject_Length(args);
06465   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
06466     argv[ii] = PyTuple_GET_ITEM(args,ii);
06467   }
06468   if (argc == 0) {
06469     return _wrap_new_SALOME_FileTransferCORBA__SWIG_0(self, args);
06470   }
06471   if (argc == 1) {
06472     int _v;
06473     {
06474       _v=PyObject_HasAttrString(argv[0], "__omni_obj");
06475     }
06476     if (_v) {
06477       return _wrap_new_SALOME_FileTransferCORBA__SWIG_1(self, args);
06478     }
06479   }
06480   if (argc == 2) {
06481     int _v;
06482     int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
06483     _v = SWIG_CheckState(res);
06484     if (_v) {
06485       int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
06486       _v = SWIG_CheckState(res);
06487       if (_v) {
06488         return _wrap_new_SALOME_FileTransferCORBA__SWIG_3(self, args);
06489       }
06490     }
06491   }
06492   if (argc == 3) {
06493     int _v;
06494     int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
06495     _v = SWIG_CheckState(res);
06496     if (_v) {
06497       int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
06498       _v = SWIG_CheckState(res);
06499       if (_v) {
06500         int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
06501         _v = SWIG_CheckState(res);
06502         if (_v) {
06503           return _wrap_new_SALOME_FileTransferCORBA__SWIG_2(self, args);
06504         }
06505       }
06506     }
06507   }
06508   
06509 fail:
06510   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SALOME_FileTransferCORBA'.\n"
06511     "  Possible C/C++ prototypes are:\n"
06512     "    SALOME_FileTransferCORBA()\n"
06513     "    SALOME_FileTransferCORBA(Engines::fileRef_ptr)\n"
06514     "    SALOME_FileTransferCORBA(std::string,std::string,std::string)\n"
06515     "    SALOME_FileTransferCORBA(std::string,std::string)\n");
06516   return NULL;
06517 }
06518 
06519 
06520 SWIGINTERN PyObject *_wrap_delete_SALOME_FileTransferCORBA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06521   PyObject *resultobj = 0;
06522   SALOME_FileTransferCORBA *arg1 = (SALOME_FileTransferCORBA *) 0 ;
06523   void *argp1 = 0 ;
06524   int res1 = 0 ;
06525   PyObject * obj0 = 0 ;
06526   
06527   if (!PyArg_ParseTuple(args,(char *)"O:delete_SALOME_FileTransferCORBA",&obj0)) SWIG_fail;
06528   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_FileTransferCORBA, SWIG_POINTER_DISOWN |  0 );
06529   if (!SWIG_IsOK(res1)) {
06530     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SALOME_FileTransferCORBA" "', argument " "1"" of type '" "SALOME_FileTransferCORBA *""'"); 
06531   }
06532   arg1 = reinterpret_cast< SALOME_FileTransferCORBA * >(argp1);
06533   {
06534     Py_BEGIN_ALLOW_THREADS
06535     try {
06536       delete arg1;
06537     }
06538     catch (ServiceUnreachable) {
06539       Py_BLOCK_THREADS
06540       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
06541       return NULL;
06542     }
06543     catch (SALOME_Exception &e) {
06544       Py_BLOCK_THREADS
06545       PyErr_SetString(PyExc_RuntimeError,e.what());
06546       return NULL;
06547     }
06548     catch (SALOME::SALOME_Exception &e) {
06549       Py_BLOCK_THREADS
06550       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06551       return NULL;
06552     }
06553     catch (...) {
06554       Py_BLOCK_THREADS
06555       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
06556       return NULL;
06557     }
06558     Py_END_ALLOW_THREADS
06559   }
06560   resultobj = SWIG_Py_Void();
06561   return resultobj;
06562 fail:
06563   return NULL;
06564 }
06565 
06566 
06567 SWIGINTERN PyObject *_wrap_SALOME_FileTransferCORBA_getLocalFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06568   PyObject *resultobj = 0;
06569   SALOME_FileTransferCORBA *arg1 = (SALOME_FileTransferCORBA *) 0 ;
06570   std::string arg2 ;
06571   void *argp1 = 0 ;
06572   int res1 = 0 ;
06573   PyObject * obj0 = 0 ;
06574   PyObject * obj1 = 0 ;
06575   std::string result;
06576   
06577   if (!PyArg_ParseTuple(args,(char *)"OO:SALOME_FileTransferCORBA_getLocalFile",&obj0,&obj1)) SWIG_fail;
06578   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_FileTransferCORBA, 0 |  0 );
06579   if (!SWIG_IsOK(res1)) {
06580     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_FileTransferCORBA_getLocalFile" "', argument " "1"" of type '" "SALOME_FileTransferCORBA *""'"); 
06581   }
06582   arg1 = reinterpret_cast< SALOME_FileTransferCORBA * >(argp1);
06583   {
06584     std::string *ptr = (std::string *)0;
06585     int res = SWIG_AsPtr_std_string(obj1, &ptr);
06586     if (!SWIG_IsOK(res) || !ptr) {
06587       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SALOME_FileTransferCORBA_getLocalFile" "', argument " "2"" of type '" "std::string""'"); 
06588     }
06589     arg2 = *ptr;
06590     if (SWIG_IsNewObj(res)) delete ptr;
06591   }
06592   {
06593     Py_BEGIN_ALLOW_THREADS
06594     try {
06595       result = (arg1)->getLocalFile(arg2);
06596     }
06597     catch (ServiceUnreachable) {
06598       Py_BLOCK_THREADS
06599       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
06600       return NULL;
06601     }
06602     catch (SALOME_Exception &e) {
06603       Py_BLOCK_THREADS
06604       PyErr_SetString(PyExc_RuntimeError,e.what());
06605       return NULL;
06606     }
06607     catch (SALOME::SALOME_Exception &e) {
06608       Py_BLOCK_THREADS
06609       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06610       return NULL;
06611     }
06612     catch (...) {
06613       Py_BLOCK_THREADS
06614       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
06615       return NULL;
06616     }
06617     Py_END_ALLOW_THREADS
06618   }
06619   resultobj = SWIG_From_std_string(static_cast< std::string >(result));
06620   return resultobj;
06621 fail:
06622   return NULL;
06623 }
06624 
06625 
06626 SWIGINTERN PyObject *_wrap_SALOME_FileTransferCORBA_getLocalFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06627   PyObject *resultobj = 0;
06628   SALOME_FileTransferCORBA *arg1 = (SALOME_FileTransferCORBA *) 0 ;
06629   void *argp1 = 0 ;
06630   int res1 = 0 ;
06631   PyObject * obj0 = 0 ;
06632   std::string result;
06633   
06634   if (!PyArg_ParseTuple(args,(char *)"O:SALOME_FileTransferCORBA_getLocalFile",&obj0)) SWIG_fail;
06635   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SALOME_FileTransferCORBA, 0 |  0 );
06636   if (!SWIG_IsOK(res1)) {
06637     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SALOME_FileTransferCORBA_getLocalFile" "', argument " "1"" of type '" "SALOME_FileTransferCORBA *""'"); 
06638   }
06639   arg1 = reinterpret_cast< SALOME_FileTransferCORBA * >(argp1);
06640   {
06641     Py_BEGIN_ALLOW_THREADS
06642     try {
06643       result = (arg1)->getLocalFile();
06644     }
06645     catch (ServiceUnreachable) {
06646       Py_BLOCK_THREADS
06647       PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable");
06648       return NULL;
06649     }
06650     catch (SALOME_Exception &e) {
06651       Py_BLOCK_THREADS
06652       PyErr_SetString(PyExc_RuntimeError,e.what());
06653       return NULL;
06654     }
06655     catch (SALOME::SALOME_Exception &e) {
06656       Py_BLOCK_THREADS
06657       PyErr_SetString(PyExc_RuntimeError,e.details.text);
06658       return NULL;
06659     }
06660     catch (...) {
06661       Py_BLOCK_THREADS
06662       PyErr_SetString(PyExc_RuntimeError, "unknown exception");
06663       return NULL;
06664     }
06665     Py_END_ALLOW_THREADS
06666   }
06667   resultobj = SWIG_From_std_string(static_cast< std::string >(result));
06668   return resultobj;
06669 fail:
06670   return NULL;
06671 }
06672 
06673 
06674 SWIGINTERN PyObject *_wrap_SALOME_FileTransferCORBA_getLocalFile(PyObject *self, PyObject *args) {
06675   int argc;
06676   PyObject *argv[3];
06677   int ii;
06678   
06679   if (!PyTuple_Check(args)) SWIG_fail;
06680   argc = (int)PyObject_Length(args);
06681   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
06682     argv[ii] = PyTuple_GET_ITEM(args,ii);
06683   }
06684   if (argc == 1) {
06685     int _v;
06686     void *vptr = 0;
06687     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_FileTransferCORBA, 0);
06688     _v = SWIG_CheckState(res);
06689     if (_v) {
06690       return _wrap_SALOME_FileTransferCORBA_getLocalFile__SWIG_1(self, args);
06691     }
06692   }
06693   if (argc == 2) {
06694     int _v;
06695     void *vptr = 0;
06696     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SALOME_FileTransferCORBA, 0);
06697     _v = SWIG_CheckState(res);
06698     if (_v) {
06699       int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
06700       _v = SWIG_CheckState(res);
06701       if (_v) {
06702         return _wrap_SALOME_FileTransferCORBA_getLocalFile__SWIG_0(self, args);
06703       }
06704     }
06705   }
06706   
06707 fail:
06708   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SALOME_FileTransferCORBA_getLocalFile'.\n"
06709     "  Possible C/C++ prototypes are:\n"
06710     "    getLocalFile(SALOME_FileTransferCORBA *,std::string)\n"
06711     "    getLocalFile(SALOME_FileTransferCORBA *)\n");
06712   return NULL;
06713 }
06714 
06715 
06716 SWIGINTERN PyObject *SALOME_FileTransferCORBA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06717   PyObject *obj;
06718   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
06719   SWIG_TypeNewClientData(SWIGTYPE_p_SALOME_FileTransferCORBA, SWIG_NewClientData(obj));
06720   return SWIG_Py_Void();
06721 }
06722 
06723 static PyMethodDef SwigMethods[] = {
06724         { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
06725         { (char *)"makeText", _wrap_makeText, METH_VARARGS, (char *)"makeText(char text, char fileName, unsigned int lineNumber) -> char"},
06726         { (char *)"new_SALOME_Exception", _wrap_new_SALOME_Exception, METH_VARARGS, (char *)"\n"
06727               "SALOME_Exception(char text, char fileName = None, unsigned int lineNumber = 0)\n"
06728               "SALOME_Exception(char text, char fileName = None)\n"
06729               "SALOME_Exception(char text)\n"
06730               "new_SALOME_Exception(SALOME_Exception ex) -> SALOME_Exception\n"
06731               ""},
06732         { (char *)"delete_SALOME_Exception", _wrap_delete_SALOME_Exception, METH_VARARGS, (char *)"delete_SALOME_Exception(SALOME_Exception self)"},
06733         { (char *)"SALOME_Exception_what", _wrap_SALOME_Exception_what, METH_VARARGS, (char *)"SALOME_Exception_what(SALOME_Exception self) -> char"},
06734         { (char *)"SALOME_Exception_swigregister", SALOME_Exception_swigregister, METH_VARARGS, NULL},
06735         { (char *)"new_IncompatibleComponent", _wrap_new_IncompatibleComponent, METH_VARARGS, (char *)"\n"
06736               "IncompatibleComponent()\n"
06737               "new_IncompatibleComponent(IncompatibleComponent ex) -> IncompatibleComponent\n"
06738               ""},
06739         { (char *)"delete_IncompatibleComponent", _wrap_delete_IncompatibleComponent, METH_VARARGS, (char *)"delete_IncompatibleComponent(IncompatibleComponent self)"},
06740         { (char *)"IncompatibleComponent_swigregister", IncompatibleComponent_swigregister, METH_VARARGS, NULL},
06741         { (char *)"new_SALOME_LifeCycleCORBA", _wrap_new_SALOME_LifeCycleCORBA, METH_VARARGS, (char *)"\n"
06742               "SALOME_LifeCycleCORBA(SALOME_NamingService ns = None)\n"
06743               "new_SALOME_LifeCycleCORBA() -> SALOME_LifeCycleCORBA\n"
06744               ""},
06745         { (char *)"delete_SALOME_LifeCycleCORBA", _wrap_delete_SALOME_LifeCycleCORBA, METH_VARARGS, (char *)"delete_SALOME_LifeCycleCORBA(SALOME_LifeCycleCORBA self)"},
06746         { (char *)"SALOME_LifeCycleCORBA_FindComponent", _wrap_SALOME_LifeCycleCORBA_FindComponent, METH_VARARGS, (char *)"\n"
06747               "FindComponent(Engines::MachineParameters params, char componentName, \n"
06748               "    int studyId = 0) -> Engines::EngineComponent_ptr\n"
06749               "SALOME_LifeCycleCORBA_FindComponent(SALOME_LifeCycleCORBA self, Engines::MachineParameters params, \n"
06750               "    char componentName) -> Engines::EngineComponent_ptr\n"
06751               ""},
06752         { (char *)"SALOME_LifeCycleCORBA_LoadComponent", _wrap_SALOME_LifeCycleCORBA_LoadComponent, METH_VARARGS, (char *)"\n"
06753               "LoadComponent(Engines::MachineParameters params, char componentName, \n"
06754               "    int studyId = 0) -> Engines::EngineComponent_ptr\n"
06755               "SALOME_LifeCycleCORBA_LoadComponent(SALOME_LifeCycleCORBA self, Engines::MachineParameters params, \n"
06756               "    char componentName) -> Engines::EngineComponent_ptr\n"
06757               ""},
06758         { (char *)"SALOME_LifeCycleCORBA_FindOrLoad_Component", _wrap_SALOME_LifeCycleCORBA_FindOrLoad_Component, METH_VARARGS, (char *)"\n"
06759               "FindOrLoad_Component(Engines::MachineParameters params, char componentName, \n"
06760               "    int studyId = 0) -> Engines::EngineComponent_ptr\n"
06761               "FindOrLoad_Component(Engines::MachineParameters params, char componentName) -> Engines::EngineComponent_ptr\n"
06762               "FindOrLoad_Component(Engines::ContainerParameters params, char componentName, \n"
06763               "    int studyId = 0) -> Engines::EngineComponent_ptr\n"
06764               "FindOrLoad_Component(Engines::ContainerParameters params, char componentName) -> Engines::EngineComponent_ptr\n"
06765               "SALOME_LifeCycleCORBA_FindOrLoad_Component(SALOME_LifeCycleCORBA self, char containerName, char componentName) -> Engines::EngineComponent_ptr\n"
06766               ""},
06767         { (char *)"SALOME_LifeCycleCORBA_Load_ParallelComponent", _wrap_SALOME_LifeCycleCORBA_Load_ParallelComponent, METH_VARARGS, (char *)"\n"
06768               "SALOME_LifeCycleCORBA_Load_ParallelComponent(SALOME_LifeCycleCORBA self, Engines::ContainerParameters params, \n"
06769               "    char componentName, int studyId) -> Engines::EngineComponent_ptr\n"
06770               ""},
06771         { (char *)"SALOME_LifeCycleCORBA_isKnownComponentClass", _wrap_SALOME_LifeCycleCORBA_isKnownComponentClass, METH_VARARGS, (char *)"SALOME_LifeCycleCORBA_isKnownComponentClass(SALOME_LifeCycleCORBA self, char componentName) -> bool"},
06772         { (char *)"SALOME_LifeCycleCORBA_isMpiContainer", _wrap_SALOME_LifeCycleCORBA_isMpiContainer, METH_VARARGS, (char *)"SALOME_LifeCycleCORBA_isMpiContainer(SALOME_LifeCycleCORBA self, Engines::ContainerParameters params) -> bool"},
06773         { (char *)"SALOME_LifeCycleCORBA_NbProc", _wrap_SALOME_LifeCycleCORBA_NbProc, METH_VARARGS, (char *)"SALOME_LifeCycleCORBA_NbProc(SALOME_LifeCycleCORBA self, Engines::ContainerParameters params) -> int"},
06774         { (char *)"SALOME_LifeCycleCORBA_preSet", _wrap_SALOME_LifeCycleCORBA_preSet, METH_VARARGS, (char *)"\n"
06775               "preSet(Engines::MachineParameters outparams)\n"
06776               "preSet(Engines::ResourceParameters outparams)\n"
06777               "SALOME_LifeCycleCORBA_preSet(Engines::ContainerParameters outparams)\n"
06778               ""},
06779         { (char *)"SALOME_LifeCycleCORBA_getContainerManager", _wrap_SALOME_LifeCycleCORBA_getContainerManager, METH_VARARGS, (char *)"SALOME_LifeCycleCORBA_getContainerManager(SALOME_LifeCycleCORBA self) -> Engines::ContainerManager_ptr"},
06780         { (char *)"SALOME_LifeCycleCORBA_getResourcesManager", _wrap_SALOME_LifeCycleCORBA_getResourcesManager, METH_VARARGS, (char *)"SALOME_LifeCycleCORBA_getResourcesManager(SALOME_LifeCycleCORBA self) -> Engines::ResourcesManager_ptr"},
06781         { (char *)"SALOME_LifeCycleCORBA_namingService", _wrap_SALOME_LifeCycleCORBA_namingService, METH_VARARGS, (char *)"SALOME_LifeCycleCORBA_namingService(SALOME_LifeCycleCORBA self) -> SALOME_NamingService"},
06782         { (char *)"SALOME_LifeCycleCORBA_orb", _wrap_SALOME_LifeCycleCORBA_orb, METH_VARARGS, (char *)"SALOME_LifeCycleCORBA_orb(SALOME_LifeCycleCORBA self) -> CORBA::ORB_ptr"},
06783         { (char *)"SALOME_LifeCycleCORBA_copyFile", _wrap_SALOME_LifeCycleCORBA_copyFile, METH_VARARGS, (char *)"\n"
06784               "SALOME_LifeCycleCORBA_copyFile(SALOME_LifeCycleCORBA self, char hostSrc, char fileSrc, \n"
06785               "    char hostDest, char fileDest)\n"
06786               ""},
06787         { (char *)"SALOME_LifeCycleCORBA_shutdownServers", _wrap_SALOME_LifeCycleCORBA_shutdownServers, METH_VARARGS, (char *)"SALOME_LifeCycleCORBA_shutdownServers(SALOME_LifeCycleCORBA self)"},
06788         { (char *)"SALOME_LifeCycleCORBA_killOmniNames", _wrap_SALOME_LifeCycleCORBA_killOmniNames, METH_VARARGS, (char *)"SALOME_LifeCycleCORBA_killOmniNames()"},
06789         { (char *)"SALOME_LifeCycleCORBA_convert", _wrap_SALOME_LifeCycleCORBA_convert, METH_VARARGS, (char *)"\n"
06790               "SALOME_LifeCycleCORBA_convert(SALOME_LifeCycleCORBA self, Engines::MachineParameters params_in, \n"
06791               "    Engines::ContainerParameters params_out)\n"
06792               ""},
06793         { (char *)"SALOME_LifeCycleCORBA_swigregister", SALOME_LifeCycleCORBA_swigregister, METH_VARARGS, NULL},
06794         { (char *)"new_SALOME_FileTransferCORBA", _wrap_new_SALOME_FileTransferCORBA, METH_VARARGS, (char *)"\n"
06795               "SALOME_FileTransferCORBA()\n"
06796               "SALOME_FileTransferCORBA(Engines::fileRef_ptr aFileRef)\n"
06797               "SALOME_FileTransferCORBA(string refMachine, string origFileName, string containerName = \"\")\n"
06798               "new_SALOME_FileTransferCORBA(string refMachine, string origFileName) -> SALOME_FileTransferCORBA\n"
06799               ""},
06800         { (char *)"delete_SALOME_FileTransferCORBA", _wrap_delete_SALOME_FileTransferCORBA, METH_VARARGS, (char *)"delete_SALOME_FileTransferCORBA(SALOME_FileTransferCORBA self)"},
06801         { (char *)"SALOME_FileTransferCORBA_getLocalFile", _wrap_SALOME_FileTransferCORBA_getLocalFile, METH_VARARGS, (char *)"\n"
06802               "getLocalFile(string localFile = \"\") -> string\n"
06803               "SALOME_FileTransferCORBA_getLocalFile(SALOME_FileTransferCORBA self) -> string\n"
06804               ""},
06805         { (char *)"SALOME_FileTransferCORBA_swigregister", SALOME_FileTransferCORBA_swigregister, METH_VARARGS, NULL},
06806         { NULL, NULL, 0, NULL }
06807 };
06808 
06809 
06810 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
06811 
06812 static void *_p_IncompatibleComponentTo_p_SALOME_Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
06813     return (void *)((SALOME_Exception *)  ((IncompatibleComponent *) x));
06814 }
06815 static void *_p_IncompatibleComponentTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
06816     return (void *)((std::exception *) (SALOME_Exception *) ((IncompatibleComponent *) x));
06817 }
06818 static void *_p_SALOME_ExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
06819     return (void *)((std::exception *)  ((SALOME_Exception *) x));
06820 }
06821 static swig_type_info _swigt__p_CORBA__ORB_ptr = {"_p_CORBA__ORB_ptr", "CORBA::ORB_ptr *", 0, 0, (void*)0, 0};
06822 static swig_type_info _swigt__p_Engines__ContainerParameters = {"_p_Engines__ContainerParameters", "Engines::ContainerParameters *", 0, 0, (void*)0, 0};
06823 static swig_type_info _swigt__p_Engines__MachineParameters = {"_p_Engines__MachineParameters", "Engines::MachineParameters *", 0, 0, (void*)0, 0};
06824 static swig_type_info _swigt__p_Engines__ResourceParameters = {"_p_Engines__ResourceParameters", "Engines::ResourceParameters *", 0, 0, (void*)0, 0};
06825 static swig_type_info _swigt__p_IncompatibleComponent = {"_p_IncompatibleComponent", "IncompatibleComponent *", 0, 0, (void*)0, 0};
06826 static swig_type_info _swigt__p_SALOME_Exception = {"_p_SALOME_Exception", "SALOME_Exception *", 0, 0, (void*)0, 0};
06827 static swig_type_info _swigt__p_SALOME_FileTransferCORBA = {"_p_SALOME_FileTransferCORBA", "SALOME_FileTransferCORBA *", 0, 0, (void*)0, 0};
06828 static swig_type_info _swigt__p_SALOME_LifeCycleCORBA = {"_p_SALOME_LifeCycleCORBA", "SALOME_LifeCycleCORBA *", 0, 0, (void*)0, 0};
06829 static swig_type_info _swigt__p_SALOME_NamingService = {"_p_SALOME_NamingService", "SALOME_NamingService *", 0, 0, (void*)0, 0};
06830 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
06831 static swig_type_info _swigt__p_std__exception = {"_p_std__exception", "std::exception *", 0, 0, (void*)0, 0};
06832 
06833 static swig_type_info *swig_type_initial[] = {
06834   &_swigt__p_CORBA__ORB_ptr,
06835   &_swigt__p_Engines__ContainerParameters,
06836   &_swigt__p_Engines__MachineParameters,
06837   &_swigt__p_Engines__ResourceParameters,
06838   &_swigt__p_IncompatibleComponent,
06839   &_swigt__p_SALOME_Exception,
06840   &_swigt__p_SALOME_FileTransferCORBA,
06841   &_swigt__p_SALOME_LifeCycleCORBA,
06842   &_swigt__p_SALOME_NamingService,
06843   &_swigt__p_char,
06844   &_swigt__p_std__exception,
06845 };
06846 
06847 static swig_cast_info _swigc__p_CORBA__ORB_ptr[] = {  {&_swigt__p_CORBA__ORB_ptr, 0, 0, 0},{0, 0, 0, 0}};
06848 static swig_cast_info _swigc__p_Engines__ContainerParameters[] = {  {&_swigt__p_Engines__ContainerParameters, 0, 0, 0},{0, 0, 0, 0}};
06849 static swig_cast_info _swigc__p_Engines__MachineParameters[] = {  {&_swigt__p_Engines__MachineParameters, 0, 0, 0},{0, 0, 0, 0}};
06850 static swig_cast_info _swigc__p_Engines__ResourceParameters[] = {  {&_swigt__p_Engines__ResourceParameters, 0, 0, 0},{0, 0, 0, 0}};
06851 static swig_cast_info _swigc__p_IncompatibleComponent[] = {  {&_swigt__p_IncompatibleComponent, 0, 0, 0},{0, 0, 0, 0}};
06852 static swig_cast_info _swigc__p_SALOME_Exception[] = {  {&_swigt__p_IncompatibleComponent, _p_IncompatibleComponentTo_p_SALOME_Exception, 0, 0},  {&_swigt__p_SALOME_Exception, 0, 0, 0},{0, 0, 0, 0}};
06853 static swig_cast_info _swigc__p_SALOME_FileTransferCORBA[] = {  {&_swigt__p_SALOME_FileTransferCORBA, 0, 0, 0},{0, 0, 0, 0}};
06854 static swig_cast_info _swigc__p_SALOME_LifeCycleCORBA[] = {  {&_swigt__p_SALOME_LifeCycleCORBA, 0, 0, 0},{0, 0, 0, 0}};
06855 static swig_cast_info _swigc__p_SALOME_NamingService[] = {  {&_swigt__p_SALOME_NamingService, 0, 0, 0},{0, 0, 0, 0}};
06856 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
06857 static swig_cast_info _swigc__p_std__exception[] = {  {&_swigt__p_IncompatibleComponent, _p_IncompatibleComponentTo_p_std__exception, 0, 0},  {&_swigt__p_std__exception, 0, 0, 0},  {&_swigt__p_SALOME_Exception, _p_SALOME_ExceptionTo_p_std__exception, 0, 0},{0, 0, 0, 0}};
06858 
06859 static swig_cast_info *swig_cast_initial[] = {
06860   _swigc__p_CORBA__ORB_ptr,
06861   _swigc__p_Engines__ContainerParameters,
06862   _swigc__p_Engines__MachineParameters,
06863   _swigc__p_Engines__ResourceParameters,
06864   _swigc__p_IncompatibleComponent,
06865   _swigc__p_SALOME_Exception,
06866   _swigc__p_SALOME_FileTransferCORBA,
06867   _swigc__p_SALOME_LifeCycleCORBA,
06868   _swigc__p_SALOME_NamingService,
06869   _swigc__p_char,
06870   _swigc__p_std__exception,
06871 };
06872 
06873 
06874 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
06875 
06876 static swig_const_info swig_const_table[] = {
06877 {0, 0, 0, 0.0, 0, 0}};
06878 
06879 #ifdef __cplusplus
06880 }
06881 #endif
06882 /* -----------------------------------------------------------------------------
06883  * Type initialization:
06884  * This problem is tough by the requirement that no dynamic 
06885  * memory is used. Also, since swig_type_info structures store pointers to 
06886  * swig_cast_info structures and swig_cast_info structures store pointers back
06887  * to swig_type_info structures, we need some lookup code at initialization. 
06888  * The idea is that swig generates all the structures that are needed. 
06889  * The runtime then collects these partially filled structures. 
06890  * The SWIG_InitializeModule function takes these initial arrays out of 
06891  * swig_module, and does all the lookup, filling in the swig_module.types
06892  * array with the correct data and linking the correct swig_cast_info
06893  * structures together.
06894  *
06895  * The generated swig_type_info structures are assigned staticly to an initial 
06896  * array. We just loop through that array, and handle each type individually.
06897  * First we lookup if this type has been already loaded, and if so, use the
06898  * loaded structure instead of the generated one. Then we have to fill in the
06899  * cast linked list. The cast data is initially stored in something like a
06900  * two-dimensional array. Each row corresponds to a type (there are the same
06901  * number of rows as there are in the swig_type_initial array). Each entry in
06902  * a column is one of the swig_cast_info structures for that type.
06903  * The cast_initial array is actually an array of arrays, because each row has
06904  * a variable number of columns. So to actually build the cast linked list,
06905  * we find the array of casts associated with the type, and loop through it 
06906  * adding the casts to the list. The one last trick we need to do is making
06907  * sure the type pointer in the swig_cast_info struct is correct.
06908  *
06909  * First off, we lookup the cast->type name to see if it is already loaded. 
06910  * There are three cases to handle:
06911  *  1) If the cast->type has already been loaded AND the type we are adding
06912  *     casting info to has not been loaded (it is in this module), THEN we
06913  *     replace the cast->type pointer with the type pointer that has already
06914  *     been loaded.
06915  *  2) If BOTH types (the one we are adding casting info to, and the 
06916  *     cast->type) are loaded, THEN the cast info has already been loaded by
06917  *     the previous module so we just ignore it.
06918  *  3) Finally, if cast->type has not already been loaded, then we add that
06919  *     swig_cast_info to the linked list (because the cast->type) pointer will
06920  *     be correct.
06921  * ----------------------------------------------------------------------------- */
06922 
06923 #ifdef __cplusplus
06924 extern "C" {
06925 #if 0
06926 } /* c-mode */
06927 #endif
06928 #endif
06929 
06930 #if 0
06931 #define SWIGRUNTIME_DEBUG
06932 #endif
06933 
06934 
06935 SWIGRUNTIME void
06936 SWIG_InitializeModule(void *clientdata) {
06937   size_t i;
06938   swig_module_info *module_head, *iter;
06939   int found, init;
06940   
06941   clientdata = clientdata;
06942   
06943   /* check to see if the circular list has been setup, if not, set it up */
06944   if (swig_module.next==0) {
06945     /* Initialize the swig_module */
06946     swig_module.type_initial = swig_type_initial;
06947     swig_module.cast_initial = swig_cast_initial;
06948     swig_module.next = &swig_module;
06949     init = 1;
06950   } else {
06951     init = 0;
06952   }
06953   
06954   /* Try and load any already created modules */
06955   module_head = SWIG_GetModule(clientdata);
06956   if (!module_head) {
06957     /* This is the first module loaded for this interpreter */
06958     /* so set the swig module into the interpreter */
06959     SWIG_SetModule(clientdata, &swig_module);
06960     module_head = &swig_module;
06961   } else {
06962     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
06963     found=0;
06964     iter=module_head;
06965     do {
06966       if (iter==&swig_module) {
06967         found=1;
06968         break;
06969       }
06970       iter=iter->next;
06971     } while (iter!= module_head);
06972     
06973     /* if the is found in the list, then all is done and we may leave */
06974     if (found) return;
06975     /* otherwise we must add out module into the list */
06976     swig_module.next = module_head->next;
06977     module_head->next = &swig_module;
06978   }
06979   
06980   /* When multiple interpeters are used, a module could have already been initialized in
06981        a different interpreter, but not yet have a pointer in this interpreter.
06982        In this case, we do not want to continue adding types... everything should be
06983        set up already */
06984   if (init == 0) return;
06985   
06986   /* Now work on filling in swig_module.types */
06987 #ifdef SWIGRUNTIME_DEBUG
06988   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
06989 #endif
06990   for (i = 0; i < swig_module.size; ++i) {
06991     swig_type_info *type = 0;
06992     swig_type_info *ret;
06993     swig_cast_info *cast;
06994     
06995 #ifdef SWIGRUNTIME_DEBUG
06996     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
06997 #endif
06998     
06999     /* if there is another module already loaded */
07000     if (swig_module.next != &swig_module) {
07001       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
07002     }
07003     if (type) {
07004       /* Overwrite clientdata field */
07005 #ifdef SWIGRUNTIME_DEBUG
07006       printf("SWIG_InitializeModule: found type %s\n", type->name);
07007 #endif
07008       if (swig_module.type_initial[i]->clientdata) {
07009         type->clientdata = swig_module.type_initial[i]->clientdata;
07010 #ifdef SWIGRUNTIME_DEBUG
07011         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
07012 #endif
07013       }
07014     } else {
07015       type = swig_module.type_initial[i];
07016     }
07017     
07018     /* Insert casting types */
07019     cast = swig_module.cast_initial[i];
07020     while (cast->type) {
07021       /* Don't need to add information already in the list */
07022       ret = 0;
07023 #ifdef SWIGRUNTIME_DEBUG
07024       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
07025 #endif
07026       if (swig_module.next != &swig_module) {
07027         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
07028 #ifdef SWIGRUNTIME_DEBUG
07029         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
07030 #endif
07031       }
07032       if (ret) {
07033         if (type == swig_module.type_initial[i]) {
07034 #ifdef SWIGRUNTIME_DEBUG
07035           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
07036 #endif
07037           cast->type = ret;
07038           ret = 0;
07039         } else {
07040           /* Check for casting already in the list */
07041           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
07042 #ifdef SWIGRUNTIME_DEBUG
07043           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
07044 #endif
07045           if (!ocast) ret = 0;
07046         }
07047       }
07048       
07049       if (!ret) {
07050 #ifdef SWIGRUNTIME_DEBUG
07051         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
07052 #endif
07053         if (type->cast) {
07054           type->cast->prev = cast;
07055           cast->next = type->cast;
07056         }
07057         type->cast = cast;
07058       }
07059       cast++;
07060     }
07061     /* Set entry in modules->types array equal to the type */
07062     swig_module.types[i] = type;
07063   }
07064   swig_module.types[i] = 0;
07065   
07066 #ifdef SWIGRUNTIME_DEBUG
07067   printf("**** SWIG_InitializeModule: Cast List ******\n");
07068   for (i = 0; i < swig_module.size; ++i) {
07069     int j = 0;
07070     swig_cast_info *cast = swig_module.cast_initial[i];
07071     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
07072     while (cast->type) {
07073       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
07074       cast++;
07075       ++j;
07076     }
07077     printf("---- Total casts: %d\n",j);
07078   }
07079   printf("**** SWIG_InitializeModule: Cast List ******\n");
07080 #endif
07081 }
07082 
07083 /* This function will propagate the clientdata field of type to
07084 * any new swig_type_info structures that have been added into the list
07085 * of equivalent types.  It is like calling
07086 * SWIG_TypeClientData(type, clientdata) a second time.
07087 */
07088 SWIGRUNTIME void
07089 SWIG_PropagateClientData(void) {
07090   size_t i;
07091   swig_cast_info *equiv;
07092   static int init_run = 0;
07093   
07094   if (init_run) return;
07095   init_run = 1;
07096   
07097   for (i = 0; i < swig_module.size; i++) {
07098     if (swig_module.types[i]->clientdata) {
07099       equiv = swig_module.types[i]->cast;
07100       while (equiv) {
07101         if (!equiv->converter) {
07102           if (equiv->type && !equiv->type->clientdata)
07103           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
07104         }
07105         equiv = equiv->next;
07106       }
07107     }
07108   }
07109 }
07110 
07111 #ifdef __cplusplus
07112 #if 0
07113 {
07114   /* c-mode */
07115 #endif
07116 }
07117 #endif
07118 
07119 
07120 
07121 #ifdef __cplusplus
07122 extern "C" {
07123 #endif
07124   
07125   /* Python-specific SWIG API */
07126 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
07127 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
07128 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
07129   
07130   /* -----------------------------------------------------------------------------
07131    * global variable support code.
07132    * ----------------------------------------------------------------------------- */
07133   
07134   typedef struct swig_globalvar {
07135     char       *name;                  /* Name of global variable */
07136     PyObject *(*get_attr)(void);       /* Return the current value */
07137     int       (*set_attr)(PyObject *); /* Set the value */
07138     struct swig_globalvar *next;
07139   } swig_globalvar;
07140   
07141   typedef struct swig_varlinkobject {
07142     PyObject_HEAD
07143     swig_globalvar *vars;
07144   } swig_varlinkobject;
07145   
07146   SWIGINTERN PyObject *
07147   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
07148 #if PY_VERSION_HEX >= 0x03000000
07149     return PyUnicode_InternFromString("<Swig global variables>");
07150 #else
07151     return PyString_FromString("<Swig global variables>");
07152 #endif
07153   }
07154   
07155   SWIGINTERN PyObject *
07156   swig_varlink_str(swig_varlinkobject *v) {
07157 #if PY_VERSION_HEX >= 0x03000000
07158     PyObject *str = PyUnicode_InternFromString("(");
07159     PyObject *tail;
07160     PyObject *joined;
07161     swig_globalvar *var;
07162     for (var = v->vars; var; var=var->next) {
07163       tail = PyUnicode_FromString(var->name);
07164       joined = PyUnicode_Concat(str, tail);
07165       Py_DecRef(str);
07166       Py_DecRef(tail);
07167       str = joined;
07168       if (var->next) {
07169         tail = PyUnicode_InternFromString(", ");
07170         joined = PyUnicode_Concat(str, tail);
07171         Py_DecRef(str);
07172         Py_DecRef(tail);
07173         str = joined;
07174       }
07175     }
07176     tail = PyUnicode_InternFromString(")");
07177     joined = PyUnicode_Concat(str, tail);
07178     Py_DecRef(str);
07179     Py_DecRef(tail);
07180     str = joined;
07181 #else
07182     PyObject *str = PyString_FromString("(");
07183     swig_globalvar *var;
07184     for (var = v->vars; var; var=var->next) {
07185       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
07186       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
07187     }
07188     PyString_ConcatAndDel(&str,PyString_FromString(")"));
07189 #endif
07190     return str;
07191   }
07192   
07193   SWIGINTERN int
07194   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
07195     char *tmp;
07196     PyObject *str = swig_varlink_str(v);
07197     fprintf(fp,"Swig global variables ");
07198     fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
07199     SWIG_Python_str_DelForPy3(tmp);
07200     Py_DECREF(str);
07201     return 0;
07202   }
07203   
07204   SWIGINTERN void
07205   swig_varlink_dealloc(swig_varlinkobject *v) {
07206     swig_globalvar *var = v->vars;
07207     while (var) {
07208       swig_globalvar *n = var->next;
07209       free(var->name);
07210       free(var);
07211       var = n;
07212     }
07213   }
07214   
07215   SWIGINTERN PyObject *
07216   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
07217     PyObject *res = NULL;
07218     swig_globalvar *var = v->vars;
07219     while (var) {
07220       if (strcmp(var->name,n) == 0) {
07221         res = (*var->get_attr)();
07222         break;
07223       }
07224       var = var->next;
07225     }
07226     if (res == NULL && !PyErr_Occurred()) {
07227       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
07228     }
07229     return res;
07230   }
07231   
07232   SWIGINTERN int
07233   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
07234     int res = 1;
07235     swig_globalvar *var = v->vars;
07236     while (var) {
07237       if (strcmp(var->name,n) == 0) {
07238         res = (*var->set_attr)(p);
07239         break;
07240       }
07241       var = var->next;
07242     }
07243     if (res == 1 && !PyErr_Occurred()) {
07244       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
07245     }
07246     return res;
07247   }
07248   
07249   SWIGINTERN PyTypeObject*
07250   swig_varlink_type(void) {
07251     static char varlink__doc__[] = "Swig var link object";
07252     static PyTypeObject varlink_type;
07253     static int type_init = 0;  
07254     if (!type_init) {
07255       const PyTypeObject tmp
07256       = {
07257         /* PyObject header changed in Python 3 */
07258 #if PY_VERSION_HEX >= 0x03000000
07259         PyVarObject_HEAD_INIT(&PyType_Type, 0)
07260 #else
07261         PyObject_HEAD_INIT(NULL)
07262         0,                                  /* Number of items in variable part (ob_size) */
07263 #endif
07264         (char *)"swigvarlink",              /* Type name (tp_name) */
07265         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
07266         0,                                  /* Itemsize (tp_itemsize) */
07267         (destructor) swig_varlink_dealloc,  /* Deallocator (tp_dealloc) */ 
07268         (printfunc) swig_varlink_print,     /* Print (tp_print) */
07269         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
07270         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
07271         0,                                  /* tp_compare */
07272         (reprfunc) swig_varlink_repr,       /* tp_repr */
07273         0,                                  /* tp_as_number */
07274         0,                                  /* tp_as_sequence */
07275         0,                                  /* tp_as_mapping */
07276         0,                                  /* tp_hash */
07277         0,                                  /* tp_call */
07278         (reprfunc) swig_varlink_str,        /* tp_str */
07279         0,                                  /* tp_getattro */
07280         0,                                  /* tp_setattro */
07281         0,                                  /* tp_as_buffer */
07282         0,                                  /* tp_flags */
07283         varlink__doc__,                     /* tp_doc */
07284         0,                                  /* tp_traverse */
07285         0,                                  /* tp_clear */
07286         0,                                  /* tp_richcompare */
07287         0,                                  /* tp_weaklistoffset */
07288 #if PY_VERSION_HEX >= 0x02020000
07289         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
07290 #endif
07291 #if PY_VERSION_HEX >= 0x02030000
07292         0,                                  /* tp_del */
07293 #endif
07294 #ifdef COUNT_ALLOCS
07295         0,0,0,0                             /* tp_alloc -> tp_next */
07296 #endif
07297       };
07298       varlink_type = tmp;
07299       /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
07300 #if PY_VERSION_HEX < 0x03000000
07301       varlink_type.ob_type = &PyType_Type;
07302 #endif
07303       type_init = 1;
07304     }
07305     return &varlink_type;
07306   }
07307   
07308   /* Create a variable linking object for use later */
07309   SWIGINTERN PyObject *
07310   SWIG_Python_newvarlink(void) {
07311     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
07312     if (result) {
07313       result->vars = 0;
07314     }
07315     return ((PyObject*) result);
07316   }
07317   
07318   SWIGINTERN void 
07319   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
07320     swig_varlinkobject *v = (swig_varlinkobject *) p;
07321     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
07322     if (gv) {
07323       size_t size = strlen(name)+1;
07324       gv->name = (char *)malloc(size);
07325       if (gv->name) {
07326         strncpy(gv->name,name,size);
07327         gv->get_attr = get_attr;
07328         gv->set_attr = set_attr;
07329         gv->next = v->vars;
07330       }
07331     }
07332     v->vars = gv;
07333   }
07334   
07335   SWIGINTERN PyObject *
07336   SWIG_globals(void) {
07337     static PyObject *_SWIG_globals = 0; 
07338     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
07339     return _SWIG_globals;
07340   }
07341   
07342   /* -----------------------------------------------------------------------------
07343    * constants/methods manipulation
07344    * ----------------------------------------------------------------------------- */
07345   
07346   /* Install Constants */
07347   SWIGINTERN void
07348   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
07349     PyObject *obj = 0;
07350     size_t i;
07351     for (i = 0; constants[i].type; ++i) {
07352       switch(constants[i].type) {
07353       case SWIG_PY_POINTER:
07354         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
07355         break;
07356       case SWIG_PY_BINARY:
07357         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
07358         break;
07359       default:
07360         obj = 0;
07361         break;
07362       }
07363       if (obj) {
07364         PyDict_SetItemString(d, constants[i].name, obj);
07365         Py_DECREF(obj);
07366       }
07367     }
07368   }
07369   
07370   /* -----------------------------------------------------------------------------*/
07371   /* Fix SwigMethods to carry the callback ptrs when needed */
07372   /* -----------------------------------------------------------------------------*/
07373   
07374   SWIGINTERN void
07375   SWIG_Python_FixMethods(PyMethodDef *methods,
07376     swig_const_info *const_table,
07377     swig_type_info **types,
07378     swig_type_info **types_initial) {
07379     size_t i;
07380     for (i = 0; methods[i].ml_name; ++i) {
07381       const char *c = methods[i].ml_doc;
07382       if (c && (c = strstr(c, "swig_ptr: "))) {
07383         int j;
07384         swig_const_info *ci = 0;
07385         const char *name = c + 10;
07386         for (j = 0; const_table[j].type; ++j) {
07387           if (strncmp(const_table[j].name, name, 
07388               strlen(const_table[j].name)) == 0) {
07389             ci = &(const_table[j]);
07390             break;
07391           }
07392         }
07393         if (ci) {
07394           size_t shift = (ci->ptype) - types;
07395           swig_type_info *ty = types_initial[shift];
07396           size_t ldoc = (c - methods[i].ml_doc);
07397           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
07398           char *ndoc = (char*)malloc(ldoc + lptr + 10);
07399           if (ndoc) {
07400             char *buff = ndoc;
07401             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
07402             if (ptr) {
07403               strncpy(buff, methods[i].ml_doc, ldoc);
07404               buff += ldoc;
07405               strncpy(buff, "swig_ptr: ", 10);
07406               buff += 10;
07407               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
07408               methods[i].ml_doc = ndoc;
07409             }
07410           }
07411         }
07412       }
07413     }
07414   } 
07415   
07416 #ifdef __cplusplus
07417 }
07418 #endif
07419 
07420 /* -----------------------------------------------------------------------------*
07421  *  Partial Init method
07422  * -----------------------------------------------------------------------------*/
07423 
07424 #ifdef __cplusplus
07425 extern "C"
07426 #endif
07427 
07428 SWIGEXPORT 
07429 #if PY_VERSION_HEX >= 0x03000000
07430 PyObject*
07431 #else
07432 void
07433 #endif
07434 SWIG_init(void) {
07435   PyObject *m, *d;  
07436 #if PY_VERSION_HEX >= 0x03000000
07437   static struct PyModuleDef SWIG_module = {
07438     PyModuleDef_HEAD_INIT,
07439     (char *) SWIG_name,
07440     NULL,
07441     -1,
07442     SwigMethods,
07443     NULL,
07444     NULL,
07445     NULL,
07446     NULL
07447   };
07448 #endif
07449   
07450   /* Fix SwigMethods to carry the callback ptrs when needed */
07451   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
07452   
07453 #if PY_VERSION_HEX >= 0x03000000
07454   m = PyModule_Create(&SWIG_module);
07455 #else
07456   m = Py_InitModule((char *) SWIG_name, SwigMethods);
07457 #endif
07458   d = PyModule_GetDict(m);
07459   
07460   SWIG_InitializeModule(0);
07461   SWIG_InstallConstants(d,swig_const_table);
07462   
07463   
07464   
07465   // init section
07466   
07467   PyObject* omnipy = PyImport_ImportModule((char*)"_omnipy");
07468   if (!omnipy)
07469   {
07470     PyErr_SetString(PyExc_ImportError, (char*)"Cannot import _omnipy");
07471     return;
07472   }
07473   PyObject* pyapi = PyObject_GetAttrString(omnipy, (char*)"API");
07474   api = (omniORBpyAPI*)PyCObject_AsVoidPtr(pyapi);
07475   Py_DECREF(pyapi);
07476   
07477 #if PY_VERSION_HEX >= 0x03000000
07478   return m;
07479 #else
07480   return;
07481 #endif
07482 }
07483