src/HEXABLOCK_SWIG/hexablock_swig_wrap.cc

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.40
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #define SWIGPYTHON
  12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
  13
  14
  15 #ifdef __cplusplus
  16 /* SwigValueWrapper is described in swig.swg */
  17 template<typename T> class SwigValueWrapper {
  18   struct SwigMovePointer {
  19     T *ptr;
  20     SwigMovePointer(T *p) : ptr(p) { }
  21     ~SwigMovePointer() { delete ptr; }
  22     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  23   } pointer;
  24   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  25   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  26 public:
  27   SwigValueWrapper() : pointer(0) { }
  28   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  29   operator T&() const { return *pointer.ptr; }
  30   T *operator&() { return pointer.ptr; }
  31 };
  32
  33 template <typename T> T SwigValueInit() {
  34   return T();
  35 }
  36 #endif
  37
  38 /* -----------------------------------------------------------------------------
  39  *  This section contains generic SWIG labels for method/variable
  40  *  declarations/attributes, and other compiler dependent labels.
  41  * ----------------------------------------------------------------------------- */
  42
  43 /* template workaround for compilers that cannot correctly implement the C++ standard */
  44 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  45 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  46 #  define SWIGTEMPLATEDISAMBIGUATOR template
  47 # elif defined(__HP_aCC)
  48 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  49 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # else
  52 #  define SWIGTEMPLATEDISAMBIGUATOR
  53 # endif
  54 #endif
  55
  56 /* inline attribute */
  57 #ifndef SWIGINLINE
  58 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  59 #   define SWIGINLINE inline
  60 # else
  61 #   define SWIGINLINE
  62 # endif
  63 #endif
  64
  65 /* attribute recognised by some compilers to avoid 'unused' warnings */
  66 #ifndef SWIGUNUSED
  67 # if defined(__GNUC__)
  68 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  69 #     define SWIGUNUSED __attribute__ ((__unused__))
  70 #   else
  71 #     define SWIGUNUSED
  72 #   endif
  73 # elif defined(__ICC)
  74 #   define SWIGUNUSED __attribute__ ((__unused__))
  75 # else
  76 #   define SWIGUNUSED
  77 # endif
  78 #endif
  79
  80 #ifndef SWIG_MSC_UNSUPPRESS_4505
  81 # if defined(_MSC_VER)
  82 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  83 # endif
  84 #endif
  85
  86 #ifndef SWIGUNUSEDPARM
  87 # ifdef __cplusplus
  88 #   define SWIGUNUSEDPARM(p)
  89 # else
  90 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  91 # endif
  92 #endif
  93
  94 /* internal SWIG method */
  95 #ifndef SWIGINTERN
  96 # define SWIGINTERN static SWIGUNUSED
  97 #endif
  98
  99 /* internal inline SWIG method */
 100 #ifndef SWIGINTERNINLINE
 101 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 102 #endif
 103
 104 /* exporting methods */
 105 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 106 #  ifndef GCC_HASCLASSVISIBILITY
 107 #    define GCC_HASCLASSVISIBILITY
 108 #  endif
 109 #endif
 110
 111 #ifndef SWIGEXPORT
 112 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 113 #   if defined(STATIC_LINKED)
 114 #     define SWIGEXPORT
 115 #   else
 116 #     define SWIGEXPORT __declspec(dllexport)
 117 #   endif
 118 # else
 119 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 120 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 121 #   else
 122 #     define SWIGEXPORT
 123 #   endif
 124 # endif
 125 #endif
 126
 127 /* calling conventions for Windows */
 128 #ifndef SWIGSTDCALL
 129 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 130 #   define SWIGSTDCALL __stdcall
 131 # else
 132 #   define SWIGSTDCALL
 133 # endif
 134 #endif
 135
 136 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 137 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 138 # define _CRT_SECURE_NO_DEPRECATE
 139 #endif
 140
 141 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 142 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 143 # define _SCL_SECURE_NO_DEPRECATE
 144 #endif
 145
 146
 147
 148 /* Python.h has to appear first */
 149 #include <Python.h>
 150
 151 /* -----------------------------------------------------------------------------
 152  * swigrun.swg
 153  *
 154  * This file contains generic C API SWIG runtime support for pointer
 155  * type checking.
 156  * ----------------------------------------------------------------------------- */
 157
 158 /* This should only be incremented when either the layout of swig_type_info changes,
 159    or for whatever reason, the runtime changes incompatibly */
 160 #define SWIG_RUNTIME_VERSION "4"
 161
 162 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 163 #ifdef SWIG_TYPE_TABLE
 164 # define SWIG_QUOTE_STRING(x) #x
 165 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 166 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 167 #else
 168 # define SWIG_TYPE_TABLE_NAME
 169 #endif
 170
 171 /*
 172   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 173   creating a static or dynamic library from the SWIG runtime code.
 174   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
 175
 176   But only do this if strictly necessary, ie, if you have problems
 177   with your compiler or suchlike.
 178 */
 179
 180 #ifndef SWIGRUNTIME
 181 # define SWIGRUNTIME SWIGINTERN
 182 #endif
 183
 184 #ifndef SWIGRUNTIMEINLINE
 185 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 186 #endif
 187
 188 /*  Generic buffer size */
 189 #ifndef SWIG_BUFFER_SIZE
 190 # define SWIG_BUFFER_SIZE 1024
 191 #endif
 192
 193 /* Flags for pointer conversions */
 194 #define SWIG_POINTER_DISOWN        0x1
 195 #define SWIG_CAST_NEW_MEMORY       0x2
 196
 197 /* Flags for new pointer objects */
 198 #define SWIG_POINTER_OWN           0x1
 199
 200
 201 /*
 202    Flags/methods for returning states.
 203
 204    The SWIG conversion methods, as ConvertPtr, return and integer
 205    that tells if the conversion was successful or not. And if not,
 206    an error code can be returned (see swigerrors.swg for the codes).
 207
 208    Use the following macros/flags to set or process the returning
 209    states.
 210
 211    In old versions of SWIG, code such as the following was usually written:
 212
 213      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 214        // success code
 215      } else {
 216        //fail code
 217      }
 218
 219    Now you can be more explicit:
 220
 221     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 222     if (SWIG_IsOK(res)) {
 223       // success code
 224     } else {
 225       // fail code
 226     }
 227
 228    which is the same really, but now you can also do
 229
 230     Type *ptr;
 231     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 232     if (SWIG_IsOK(res)) {
 233       // success code
 234       if (SWIG_IsNewObj(res) {
 235         ...
 236         delete *ptr;
 237       } else {
 238         ...
 239       }
 240     } else {
 241       // fail code
 242     }
 243
 244    I.e., now SWIG_ConvertPtr can return new objects and you can
 245    identify the case and take care of the deallocation. Of course that
 246    also requires SWIG_ConvertPtr to return new result values, such as
 247
 248       int SWIG_ConvertPtr(obj, ptr,...) {
 249         if (<obj is ok>) {
 250           if (<need new object>) {
 251             *ptr = <ptr to new allocated object>;
 252             return SWIG_NEWOBJ;
 253           } else {
 254             *ptr = <ptr to old object>;
 255             return SWIG_OLDOBJ;
 256           }
 257         } else {
 258           return SWIG_BADOBJ;
 259         }
 260       }
 261
 262    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 263    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 264    SWIG errors code.
 265
 266    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 267    allows to return the 'cast rank', for example, if you have this
 268
 269        int food(double)
 270        int fooi(int);
 271
 272    and you call
 273
 274       food(1)   // cast rank '1'  (1 -> 1.0)
 275       fooi(1)   // cast rank '0'
 276
 277    just use the SWIG_AddCast()/SWIG_CheckState()
 278 */
 279
 280 #define SWIG_OK                    (0)
 281 #define SWIG_ERROR                 (-1)
 282 #define SWIG_IsOK(r)               (r >= 0)
 283 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 284
 285 /* The CastRankLimit says how many bits are used for the cast rank */
 286 #define SWIG_CASTRANKLIMIT         (1 << 8)
 287 /* The NewMask denotes the object was created (using new/malloc) */
 288 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 289 /* The TmpMask is for in/out typemaps that use temporal objects */
 290 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 291 /* Simple returning values */
 292 #define SWIG_BADOBJ                (SWIG_ERROR)
 293 #define SWIG_OLDOBJ                (SWIG_OK)
 294 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 295 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 296 /* Check, add and del mask methods */
 297 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 298 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 299 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 300 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 301 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 302 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 303
 304 /* Cast-Rank Mode */
 305 #if defined(SWIG_CASTRANK_MODE)
 306 #  ifndef SWIG_TypeRank
 307 #    define SWIG_TypeRank             unsigned long
 308 #  endif
 309 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 310 #    define SWIG_MAXCASTRANK          (2)
 311 #  endif
 312 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 313 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 314 SWIGINTERNINLINE int SWIG_AddCast(int r) {
 315   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 316 }
 317 SWIGINTERNINLINE int SWIG_CheckState(int r) {
 318   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
 319 }
 320 #else /* no cast-rank mode */
 321 #  define SWIG_AddCast
 322 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 323 #endif
 324
 325
 326 #include <string.h>
 327
 328 #ifdef __cplusplus
 329 extern "C" {
 330 #endif
 331
 332 typedef void *(*swig_converter_func)(void *, int *);
 333 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 334
 335 /* Structure to store information on one type */
 336 typedef struct swig_type_info {
 337   const char             *name;                 /* mangled name of this type */
 338   const char             *str;                  /* human readable name of this type */
 339   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 340   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 341   void                   *clientdata;           /* language specific type data */
 342   int                    owndata;               /* flag if the structure owns the clientdata */
 343 } swig_type_info;
 344
 345 /* Structure to store a type and conversion function used for casting */
 346 typedef struct swig_cast_info {
 347   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 348   swig_converter_func     converter;            /* function to cast the void pointers */
 349   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 350   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 351 } swig_cast_info;
 352
 353 /* Structure used to store module information
 354  * Each module generates one structure like this, and the runtime collects
 355  * all of these structures and stores them in a circularly linked list.*/
 356 typedef struct swig_module_info {
 357   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 358   size_t                 size;                  /* Number of types in this module */
 359   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 360   swig_type_info         **type_initial;        /* Array of initially generated type structures */
 361   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 362   void                    *clientdata;          /* Language specific module data */
 363 } swig_module_info;
 364
 365 /*
 366   Compare two type names skipping the space characters, therefore
 367   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 368
 369   Return 0 when the two name types are equivalent, as in
 370   strncmp, but skipping ' '.
 371 */
 372 SWIGRUNTIME int
 373 SWIG_TypeNameComp(const char *f1, const char *l1,
 374                   const char *f2, const char *l2) {
 375   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 376     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 377     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 378     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 379   }
 380   return (int)((l1 - f1) - (l2 - f2));
 381 }
 382
 383 /*
 384   Check type equivalence in a name list like <name1>|<name2>|...
 385   Return 0 if not equal, 1 if equal
 386 */
 387 SWIGRUNTIME int
 388 SWIG_TypeEquiv(const char *nb, const char *tb) {
 389   int equiv = 0;
 390   const char* te = tb + strlen(tb);
 391   const char* ne = nb;
 392   while (!equiv && *ne) {
 393     for (nb = ne; *ne; ++ne) {
 394       if (*ne == '|') break;
 395     }
 396     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 397     if (*ne) ++ne;
 398   }
 399   return equiv;
 400 }
 401
 402 /*
 403   Check type equivalence in a name list like <name1>|<name2>|...
 404   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 405 */
 406 SWIGRUNTIME int
 407 SWIG_TypeCompare(const char *nb, const char *tb) {
 408   int equiv = 0;
 409   const char* te = tb + strlen(tb);
 410   const char* ne = nb;
 411   while (!equiv && *ne) {
 412     for (nb = ne; *ne; ++ne) {
 413       if (*ne == '|') break;
 414     }
 415     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 416     if (*ne) ++ne;
 417   }
 418   return equiv;
 419 }
 420
 421
 422 /*
 423   Check the typename
 424 */
 425 SWIGRUNTIME swig_cast_info *
 426 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 427   if (ty) {
 428     swig_cast_info *iter = ty->cast;
 429     while (iter) {
 430       if (strcmp(iter->type->name, c) == 0) {
 431         if (iter == ty->cast)
 432           return iter;
 433         /* Move iter to the top of the linked list */
 434         iter->prev->next = iter->next;
 435         if (iter->next)
 436           iter->next->prev = iter->prev;
 437         iter->next = ty->cast;
 438         iter->prev = 0;
 439         if (ty->cast) ty->cast->prev = iter;
 440         ty->cast = iter;
 441         return iter;
 442       }
 443       iter = iter->next;
 444     }
 445   }
 446   return 0;
 447 }
 448
 449 /*
 450   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
 451 */
 452 SWIGRUNTIME swig_cast_info *
 453 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
 454   if (ty) {
 455     swig_cast_info *iter = ty->cast;
 456     while (iter) {
 457       if (iter->type == from) {
 458         if (iter == ty->cast)
 459           return iter;
 460         /* Move iter to the top of the linked list */
 461         iter->prev->next = iter->next;
 462         if (iter->next)
 463           iter->next->prev = iter->prev;
 464         iter->next = ty->cast;
 465         iter->prev = 0;
 466         if (ty->cast) ty->cast->prev = iter;
 467         ty->cast = iter;
 468         return iter;
 469       }
 470       iter = iter->next;
 471     }
 472   }
 473   return 0;
 474 }
 475
 476 /*
 477   Cast a pointer up an inheritance hierarchy
 478 */
 479 SWIGRUNTIMEINLINE void *
 480 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
 481   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 482 }
 483
 484 /*
 485    Dynamic pointer casting. Down an inheritance hierarchy
 486 */
 487 SWIGRUNTIME swig_type_info *
 488 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 489   swig_type_info *lastty = ty;
 490   if (!ty || !ty->dcast) return ty;
 491   while (ty && (ty->dcast)) {
 492     ty = (*ty->dcast)(ptr);
 493     if (ty) lastty = ty;
 494   }
 495   return lastty;
 496 }
 497
 498 /*
 499   Return the name associated with this type
 500 */
 501 SWIGRUNTIMEINLINE const char *
 502 SWIG_TypeName(const swig_type_info *ty) {
 503   return ty->name;
 504 }
 505
 506 /*
 507   Return the pretty name associated with this type,
 508   that is an unmangled type name in a form presentable to the user.
 509 */
 510 SWIGRUNTIME const char *
 511 SWIG_TypePrettyName(const swig_type_info *type) {
 512   /* The "str" field contains the equivalent pretty names of the
 513      type, separated by vertical-bar characters.  We choose
 514      to print the last name, as it is often (?) the most
 515      specific. */
 516   if (!type) return NULL;
 517   if (type->str != NULL) {
 518     const char *last_name = type->str;
 519     const char *s;
 520     for (s = type->str; *s; s++)
 521       if (*s == '|') last_name = s+1;
 522     return last_name;
 523   }
 524   else
 525     return type->name;
 526 }
 527
 528 /*
 529    Set the clientdata field for a type
 530 */
 531 SWIGRUNTIME void
 532 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 533   swig_cast_info *cast = ti->cast;
 534   /* if (ti->clientdata == clientdata) return; */
 535   ti->clientdata = clientdata;
 536
 537   while (cast) {
 538     if (!cast->converter) {
 539       swig_type_info *tc = cast->type;
 540       if (!tc->clientdata) {
 541         SWIG_TypeClientData(tc, clientdata);
 542       }
 543     }
 544     cast = cast->next;
 545   }
 546 }
 547 SWIGRUNTIME void
 548 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 549   SWIG_TypeClientData(ti, clientdata);
 550   ti->owndata = 1;
 551 }
 552
 553 /*
 554   Search for a swig_type_info structure only by mangled name
 555   Search is a O(log #types)
 556
 557   We start searching at module start, and finish searching when start == end.
 558   Note: if start == end at the beginning of the function, we go all the way around
 559   the circular list.
 560 */
 561 SWIGRUNTIME swig_type_info *
 562 SWIG_MangledTypeQueryModule(swig_module_info *start,
 563                             swig_module_info *end,
 564                             const char *name) {
 565   swig_module_info *iter = start;
 566   do {
 567     if (iter->size) {
 568       register size_t l = 0;
 569       register size_t r = iter->size - 1;
 570       do {
 571         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 572         register size_t i = (l + r) >> 1;
 573         const char *iname = iter->types[i]->name;
 574         if (iname) {
 575           register int compare = strcmp(name, iname);
 576           if (compare == 0) {
 577             return iter->types[i];
 578           } else if (compare < 0) {
 579             if (i) {
 580               r = i - 1;
 581             } else {
 582               break;
 583             }
 584           } else if (compare > 0) {
 585             l = i + 1;
 586           }
 587         } else {
 588           break; /* should never happen */
 589         }
 590       } while (l <= r);
 591     }
 592     iter = iter->next;
 593   } while (iter != end);
 594   return 0;
 595 }
 596
 597 /*
 598   Search for a swig_type_info structure for either a mangled name or a human readable name.
 599   It first searches the mangled names of the types, which is a O(log #types)
 600   If a type is not found it then searches the human readable names, which is O(#types).
 601
 602   We start searching at module start, and finish searching when start == end.
 603   Note: if start == end at the beginning of the function, we go all the way around
 604   the circular list.
 605 */
 606 SWIGRUNTIME swig_type_info *
 607 SWIG_TypeQueryModule(swig_module_info *start,
 608                      swig_module_info *end,
 609                      const char *name) {
 610   /* STEP 1: Search the name field using binary search */
 611   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 612   if (ret) {
 613     return ret;
 614   } else {
 615     /* STEP 2: If the type hasn't been found, do a complete search
 616        of the str field (the human readable name) */
 617     swig_module_info *iter = start;
 618     do {
 619       register size_t i = 0;
 620       for (; i < iter->size; ++i) {
 621         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 622           return iter->types[i];
 623       }
 624       iter = iter->next;
 625     } while (iter != end);
 626   }
 627
 628   /* neither found a match */
 629   return 0;
 630 }
 631
 632 /*
 633    Pack binary data into a string
 634 */
 635 SWIGRUNTIME char *
 636 SWIG_PackData(char *c, void *ptr, size_t sz) {
 637   static const char hex[17] = "0123456789abcdef";
 638   register const unsigned char *u = (unsigned char *) ptr;
 639   register const unsigned char *eu =  u + sz;
 640   for (; u != eu; ++u) {
 641     register unsigned char uu = *u;
 642     *(c++) = hex[(uu & 0xf0) >> 4];
 643     *(c++) = hex[uu & 0xf];
 644   }
 645   return c;
 646 }
 647
 648 /*
 649    Unpack binary data from a string
 650 */
 651 SWIGRUNTIME const char *
 652 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 653   register unsigned char *u = (unsigned char *) ptr;
 654   register const unsigned char *eu = u + sz;
 655   for (; u != eu; ++u) {
 656     register char d = *(c++);
 657     register unsigned char uu;
 658     if ((d >= '0') && (d <= '9'))
 659       uu = ((d - '0') << 4);
 660     else if ((d >= 'a') && (d <= 'f'))
 661       uu = ((d - ('a'-10)) << 4);
 662     else
 663       return (char *) 0;
 664     d = *(c++);
 665     if ((d >= '0') && (d <= '9'))
 666       uu |= (d - '0');
 667     else if ((d >= 'a') && (d <= 'f'))
 668       uu |= (d - ('a'-10));
 669     else
 670       return (char *) 0;
 671     *u = uu;
 672   }
 673   return c;
 674 }
 675
 676 /*
 677    Pack 'void *' into a string buffer.
 678 */
 679 SWIGRUNTIME char *
 680 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 681   char *r = buff;
 682   if ((2*sizeof(void *) + 2) > bsz) return 0;
 683   *(r++) = '_';
 684   r = SWIG_PackData(r,&ptr,sizeof(void *));
 685   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 686   strcpy(r,name);
 687   return buff;
 688 }
 689
 690 SWIGRUNTIME const char *
 691 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 692   if (*c != '_') {
 693     if (strcmp(c,"NULL") == 0) {
 694       *ptr = (void *) 0;
 695       return name;
 696     } else {
 697       return 0;
 698     }
 699   }
 700   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 701 }
 702
 703 SWIGRUNTIME char *
 704 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 705   char *r = buff;
 706   size_t lname = (name ? strlen(name) : 0);
 707   if ((2*sz + 2 + lname) > bsz) return 0;
 708   *(r++) = '_';
 709   r = SWIG_PackData(r,ptr,sz);
 710   if (lname) {
 711     strncpy(r,name,lname+1);
 712   } else {
 713     *r = 0;
 714   }
 715   return buff;
 716 }
 717
 718 SWIGRUNTIME const char *
 719 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 720   if (*c != '_') {
 721     if (strcmp(c,"NULL") == 0) {
 722       memset(ptr,0,sz);
 723       return name;
 724     } else {
 725       return 0;
 726     }
 727   }
 728   return SWIG_UnpackData(++c,ptr,sz);
 729 }
 730
 731 #ifdef __cplusplus
 732 }
 733 #endif
 734
 735 /*  Errors in SWIG */
 736 #define  SWIG_UnknownError         -1
 737 #define  SWIG_IOError              -2
 738 #define  SWIG_RuntimeError         -3
 739 #define  SWIG_IndexError           -4
 740 #define  SWIG_TypeError            -5
 741 #define  SWIG_DivisionByZero       -6
 742 #define  SWIG_OverflowError        -7
 743 #define  SWIG_SyntaxError          -8
 744 #define  SWIG_ValueError           -9
 745 #define  SWIG_SystemError          -10
 746 #define  SWIG_AttributeError       -11
 747 #define  SWIG_MemoryError          -12
 748 #define  SWIG_NullReferenceError   -13
 749
 750
 751
 752 /* Compatibility macros for Python 3 */
 753 #if PY_VERSION_HEX >= 0x03000000
 754
 755 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
 756 #define PyInt_Check(x) PyLong_Check(x)
 757 #define PyInt_AsLong(x) PyLong_AsLong(x)
 758 #define PyInt_FromLong(x) PyLong_FromLong(x)
 759 #define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
 760
 761 #endif
 762
 763 #ifndef Py_TYPE
 764 #  define Py_TYPE(op) ((op)->ob_type)
 765 #endif
 766
 767 /* SWIG APIs for compatibility of both Python 2 & 3 */
 768
 769 #if PY_VERSION_HEX >= 0x03000000
 770 #  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
 771 #else
 772 #  define SWIG_Python_str_FromFormat PyString_FromFormat
 773 #endif
 774
 775
 776 /* Warning: This function will allocate a new string in Python 3,
 777  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
 778  */
 779 SWIGINTERN char*
 780 SWIG_Python_str_AsChar(PyObject *str)
 781 {
 782 #if PY_VERSION_HEX >= 0x03000000
 783   char *cstr;
 784   char *newstr;
 785   Py_ssize_t len;
 786   str = PyUnicode_AsUTF8String(str);
 787   PyBytes_AsStringAndSize(str, &cstr, &len);
 788   newstr = (char *) malloc(len+1);
 789   memcpy(newstr, cstr, len+1);
 790   Py_XDECREF(str);
 791   return newstr;
 792 #else
 793   return PyString_AsString(str);
 794 #endif
 795 }
 796
 797 #if PY_VERSION_HEX >= 0x03000000
 798 #  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
 799 #else
 800 #  define SWIG_Python_str_DelForPy3(x)
 801 #endif
 802
 803
 804 SWIGINTERN PyObject*
 805 SWIG_Python_str_FromChar(const char *c)
 806 {
 807 #if PY_VERSION_HEX >= 0x03000000
 808   return PyUnicode_FromString(c);
 809 #else
 810   return PyString_FromString(c);
 811 #endif
 812 }
 813
 814 /* Add PyOS_snprintf for old Pythons */
 815 #if PY_VERSION_HEX < 0x02020000
 816 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
 817 #  define PyOS_snprintf _snprintf
 818 # else
 819 #  define PyOS_snprintf snprintf
 820 # endif
 821 #endif
 822
 823 /* A crude PyString_FromFormat implementation for old Pythons */
 824 #if PY_VERSION_HEX < 0x02020000
 825
 826 #ifndef SWIG_PYBUFFER_SIZE
 827 # define SWIG_PYBUFFER_SIZE 1024
 828 #endif
 829
 830 static PyObject *
 831 PyString_FromFormat(const char *fmt, ...) {
 832   va_list ap;
 833   char buf[SWIG_PYBUFFER_SIZE * 2];
 834   int res;
 835   va_start(ap, fmt);
 836   res = vsnprintf(buf, sizeof(buf), fmt, ap);
 837   va_end(ap);
 838   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
 839 }
 840 #endif
 841
 842 /* Add PyObject_Del for old Pythons */
 843 #if PY_VERSION_HEX < 0x01060000
 844 # define PyObject_Del(op) PyMem_DEL((op))
 845 #endif
 846 #ifndef PyObject_DEL
 847 # define PyObject_DEL PyObject_Del
 848 #endif
 849
 850 /* A crude PyExc_StopIteration exception for old Pythons */
 851 #if PY_VERSION_HEX < 0x02020000
 852 # ifndef PyExc_StopIteration
 853 #  define PyExc_StopIteration PyExc_RuntimeError
 854 # endif
 855 # ifndef PyObject_GenericGetAttr
 856 #  define PyObject_GenericGetAttr 0
 857 # endif
 858 #endif
 859
 860 /* Py_NotImplemented is defined in 2.1 and up. */
 861 #if PY_VERSION_HEX < 0x02010000
 862 # ifndef Py_NotImplemented
 863 #  define Py_NotImplemented PyExc_RuntimeError
 864 # endif
 865 #endif
 866
 867 /* A crude PyString_AsStringAndSize implementation for old Pythons */
 868 #if PY_VERSION_HEX < 0x02010000
 869 # ifndef PyString_AsStringAndSize
 870 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
 871 # endif
 872 #endif
 873
 874 /* PySequence_Size for old Pythons */
 875 #if PY_VERSION_HEX < 0x02000000
 876 # ifndef PySequence_Size
 877 #  define PySequence_Size PySequence_Length
 878 # endif
 879 #endif
 880
 881 /* PyBool_FromLong for old Pythons */
 882 #if PY_VERSION_HEX < 0x02030000
 883 static
 884 PyObject *PyBool_FromLong(long ok)
 885 {
 886   PyObject *result = ok ? Py_True : Py_False;
 887   Py_INCREF(result);
 888   return result;
 889 }
 890 #endif
 891
 892 /* Py_ssize_t for old Pythons */
 893 /* This code is as recommended by: */
 894 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
 895 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
 896 typedef int Py_ssize_t;
 897 # define PY_SSIZE_T_MAX INT_MAX
 898 # define PY_SSIZE_T_MIN INT_MIN
 899 #endif
 900
 901 /* -----------------------------------------------------------------------------
 902  * error manipulation
 903  * ----------------------------------------------------------------------------- */
 904
 905 SWIGRUNTIME PyObject*
 906 SWIG_Python_ErrorType(int code) {
 907   PyObject* type = 0;
 908   switch(code) {
 909   case SWIG_MemoryError:
 910     type = PyExc_MemoryError;
 911     break;
 912   case SWIG_IOError:
 913     type = PyExc_IOError;
 914     break;
 915   case SWIG_RuntimeError:
 916     type = PyExc_RuntimeError;
 917     break;
 918   case SWIG_IndexError:
 919     type = PyExc_IndexError;
 920     break;
 921   case SWIG_TypeError:
 922     type = PyExc_TypeError;
 923     break;
 924   case SWIG_DivisionByZero:
 925     type = PyExc_ZeroDivisionError;
 926     break;
 927   case SWIG_OverflowError:
 928     type = PyExc_OverflowError;
 929     break;
 930   case SWIG_SyntaxError:
 931     type = PyExc_SyntaxError;
 932     break;
 933   case SWIG_ValueError:
 934     type = PyExc_ValueError;
 935     break;
 936   case SWIG_SystemError:
 937     type = PyExc_SystemError;
 938     break;
 939   case SWIG_AttributeError:
 940     type = PyExc_AttributeError;
 941     break;
 942   default:
 943     type = PyExc_RuntimeError;
 944   }
 945   return type;
 946 }
 947
 948
 949 SWIGRUNTIME void
 950 SWIG_Python_AddErrorMsg(const char* mesg)
 951 {
 952   PyObject *type = 0;
 953   PyObject *value = 0;
 954   PyObject *traceback = 0;
 955
 956   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
 957   if (value) {
 958     char *tmp;
 959     PyObject *old_str = PyObject_Str(value);
 960     PyErr_Clear();
 961     Py_XINCREF(type);
 962
 963     PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
 964     SWIG_Python_str_DelForPy3(tmp);
 965     Py_DECREF(old_str);
 966     Py_DECREF(value);
 967   } else {
 968     PyErr_SetString(PyExc_RuntimeError, mesg);
 969   }
 970 }
 971
 972 #if defined(SWIG_PYTHON_NO_THREADS)
 973 #  if defined(SWIG_PYTHON_THREADS)
 974 #    undef SWIG_PYTHON_THREADS
 975 #  endif
 976 #endif
 977 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
 978 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
 979 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
 980 #      define SWIG_PYTHON_USE_GIL
 981 #    endif
 982 #  endif
 983 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
 984 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
 985 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads()
 986 #    endif
 987 #    ifdef __cplusplus /* C++ code */
 988        class SWIG_Python_Thread_Block {
 989          bool status;
 990          PyGILState_STATE state;
 991        public:
 992          void end() { if (status) { PyGILState_Release(state); status = false;} }
 993          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
 994          ~SWIG_Python_Thread_Block() { end(); }
 995        };
 996        class SWIG_Python_Thread_Allow {
 997          bool status;
 998          PyThreadState *save;
 999        public:
1000          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1001          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1002          ~SWIG_Python_Thread_Allow() { end(); }
1003        };
1004 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
1005 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
1006 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
1007 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
1008 #    else /* C code */
1009 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1010 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
1011 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1012 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
1013 #    endif
1014 #  else /* Old thread way, not implemented, user must provide it */
1015 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1016 #      define SWIG_PYTHON_INITIALIZE_THREADS
1017 #    endif
1018 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1019 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1020 #    endif
1021 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1022 #      define SWIG_PYTHON_THREAD_END_BLOCK
1023 #    endif
1024 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1025 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1026 #    endif
1027 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1028 #      define SWIG_PYTHON_THREAD_END_ALLOW
1029 #    endif
1030 #  endif
1031 #else /* No thread support */
1032 #  define SWIG_PYTHON_INITIALIZE_THREADS
1033 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1034 #  define SWIG_PYTHON_THREAD_END_BLOCK
1035 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1036 #  define SWIG_PYTHON_THREAD_END_ALLOW
1037 #endif
1038
1039 /* -----------------------------------------------------------------------------
1040  * Python API portion that goes into the runtime
1041  * ----------------------------------------------------------------------------- */
1042
1043 #ifdef __cplusplus
1044 extern "C" {
1045 #if 0
1046 } /* cc-mode */
1047 #endif
1048 #endif
1049
1050 /* -----------------------------------------------------------------------------
1051  * Constant declarations
1052  * ----------------------------------------------------------------------------- */
1053
1054 /* Constant Types */
1055 #define SWIG_PY_POINTER 4
1056 #define SWIG_PY_BINARY  5
1057
1058 /* Constant information structure */
1059 typedef struct swig_const_info {
1060   int type;
1061   char *name;
1062   long lvalue;
1063   double dvalue;
1064   void   *pvalue;
1065   swig_type_info **ptype;
1066 } swig_const_info;
1067
1068
1069 /* -----------------------------------------------------------------------------
1070  * Wrapper of PyInstanceMethod_New() used in Python 3
1071  * It is exported to the generated module, used for -fastproxy
1072  * ----------------------------------------------------------------------------- */
1073 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
1074 {
1075 #if PY_VERSION_HEX >= 0x03000000
1076   return PyInstanceMethod_New(func);
1077 #else
1078   return NULL;
1079 #endif
1080 }
1081
1082 #ifdef __cplusplus
1083 #if 0
1084 { /* cc-mode */
1085 #endif
1086 }
1087 #endif
1088
1089
1090 /* -----------------------------------------------------------------------------
1091  * See the LICENSE file for information on copyright, usage and redistribution
1092  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1093  *
1094  * pyrun.swg
1095  *
1096  * This file contains the runtime support for Python modules
1097  * and includes code for managing global variables and pointer
1098  * type checking.
1099  *
1100  * ----------------------------------------------------------------------------- */
1101
1102 /* Common SWIG API */
1103
1104 /* for raw pointers */
1105 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1106 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1107 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1108 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
1109 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty)
1110 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
1111 #define swig_owntype                                    int
1112
1113 /* for raw packed data */
1114 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1115 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1116
1117 /* for class or struct pointers */
1118 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
1119 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
1120
1121 /* for C or C++ function pointers */
1122 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1123 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
1124
1125 /* for C++ member pointers, ie, member methods */
1126 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1127 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1128
1129
1130 /* Runtime API */
1131
1132 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1133 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1134 #define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
1135
1136 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
1137 #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg
1138 #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)
1139 #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1140 #define SWIG_fail                                       goto fail
1141
1142
1143 /* Runtime API implementation */
1144
1145 /* Error manipulation */
1146
1147 SWIGINTERN void
1148 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1149   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1150   PyErr_SetObject(errtype, obj);
1151   Py_DECREF(obj);
1152   SWIG_PYTHON_THREAD_END_BLOCK;
1153 }
1154
1155 SWIGINTERN void
1156 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1157   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1158   PyErr_SetString(errtype, (char *) msg);
1159   SWIG_PYTHON_THREAD_END_BLOCK;
1160 }
1161
1162 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1163
1164 /* Set a constant value */
1165
1166 SWIGINTERN void
1167 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1168   PyDict_SetItemString(d, (char*) name, obj);
1169   Py_DECREF(obj);
1170 }
1171
1172 /* Append a value to the result obj */
1173
1174 SWIGINTERN PyObject*
1175 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1176 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1177   if (!result) {
1178     result = obj;
1179   } else if (result == Py_None) {
1180     Py_DECREF(result);
1181     result = obj;
1182   } else {
1183     if (!PyList_Check(result)) {
1184       PyObject *o2 = result;
1185       result = PyList_New(1);
1186       PyList_SetItem(result, 0, o2);
1187     }
1188     PyList_Append(result,obj);
1189     Py_DECREF(obj);
1190   }
1191   return result;
1192 #else
1193   PyObject*   o2;
1194   PyObject*   o3;
1195   if (!result) {
1196     result = obj;
1197   } else if (result == Py_None) {
1198     Py_DECREF(result);
1199     result = obj;
1200   } else {
1201     if (!PyTuple_Check(result)) {
1202       o2 = result;
1203       result = PyTuple_New(1);
1204       PyTuple_SET_ITEM(result, 0, o2);
1205     }
1206     o3 = PyTuple_New(1);
1207     PyTuple_SET_ITEM(o3, 0, obj);
1208     o2 = result;
1209     result = PySequence_Concat(o2, o3);
1210     Py_DECREF(o2);
1211     Py_DECREF(o3);
1212   }
1213   return result;
1214 #endif
1215 }
1216
1217 /* Unpack the argument tuple */
1218
1219 SWIGINTERN int
1220 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1221 {
1222   if (!args) {
1223     if (!min && !max) {
1224       return 1;
1225     } else {
1226       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1227                    name, (min == max ? "" : "at least "), (int)min);
1228       return 0;
1229     }
1230   }
1231   if (!PyTuple_Check(args)) {
1232     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1233     return 0;
1234   } else {
1235     register Py_ssize_t l = PyTuple_GET_SIZE(args);
1236     if (l < min) {
1237       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1238                    name, (min == max ? "" : "at least "), (int)min, (int)l);
1239       return 0;
1240     } else if (l > max) {
1241       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1242                    name, (min == max ? "" : "at most "), (int)max, (int)l);
1243       return 0;
1244     } else {
1245       register int i;
1246       for (i = 0; i < l; ++i) {
1247         objs[i] = PyTuple_GET_ITEM(args, i);
1248       }
1249       for (; l < max; ++l) {
1250         objs[l] = 0;
1251       }
1252       return i + 1;
1253     }
1254   }
1255 }
1256
1257 /* A functor is a function object with one single object argument */
1258 #if PY_VERSION_HEX >= 0x02020000
1259 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
1260 #else
1261 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
1262 #endif
1263
1264 /*
1265   Helper for static pointer initialization for both C and C++ code, for example
1266   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1267 */
1268 #ifdef __cplusplus
1269 #define SWIG_STATIC_POINTER(var)  var
1270 #else
1271 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1272 #endif
1273
1274 /* -----------------------------------------------------------------------------
1275  * Pointer declarations
1276  * ----------------------------------------------------------------------------- */
1277
1278 /* Flags for new pointer objects */
1279 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
1280 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1281
1282 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1283
1284 #ifdef __cplusplus
1285 extern "C" {
1286 #if 0
1287 } /* cc-mode */
1288 #endif
1289 #endif
1290
1291 /*  How to access Py_None */
1292 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1293 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
1294 #    ifndef SWIG_PYTHON_BUILD_NONE
1295 #      define SWIG_PYTHON_BUILD_NONE
1296 #    endif
1297 #  endif
1298 #endif
1299
1300 #ifdef SWIG_PYTHON_BUILD_NONE
1301 #  ifdef Py_None
1302 #   undef Py_None
1303 #   define Py_None SWIG_Py_None()
1304 #  endif
1305 SWIGRUNTIMEINLINE PyObject *
1306 _SWIG_Py_None(void)
1307 {
1308   PyObject *none = Py_BuildValue((char*)"");
1309   Py_DECREF(none);
1310   return none;
1311 }
1312 SWIGRUNTIME PyObject *
1313 SWIG_Py_None(void)
1314 {
1315   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1316   return none;
1317 }
1318 #endif
1319
1320 /* The python void return value */
1321
1322 SWIGRUNTIMEINLINE PyObject *
1323 SWIG_Py_Void(void)
1324 {
1325   PyObject *none = Py_None;
1326   Py_INCREF(none);
1327   return none;
1328 }
1329
1330 /* SwigPyClientData */
1331
1332 typedef struct {
1333   PyObject *klass;
1334   PyObject *newraw;
1335   PyObject *newargs;
1336   PyObject *destroy;
1337   int delargs;
1338   int implicitconv;
1339 } SwigPyClientData;
1340
1341 SWIGRUNTIMEINLINE int
1342 SWIG_Python_CheckImplicit(swig_type_info *ty)
1343 {
1344   SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1345   return data ? data->implicitconv : 0;
1346 }
1347
1348 SWIGRUNTIMEINLINE PyObject *
1349 SWIG_Python_ExceptionType(swig_type_info *desc) {
1350   SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1351   PyObject *klass = data ? data->klass : 0;
1352   return (klass ? klass : PyExc_RuntimeError);
1353 }
1354
1355
1356 SWIGRUNTIME SwigPyClientData *
1357 SwigPyClientData_New(PyObject* obj)
1358 {
1359   if (!obj) {
1360     return 0;
1361   } else {
1362     SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1363     /* the klass element */
1364     data->klass = obj;
1365     Py_INCREF(data->klass);
1366     /* the newraw method and newargs arguments used to create a new raw instance */
1367     if (PyClass_Check(obj)) {
1368       data->newraw = 0;
1369       data->newargs = obj;
1370       Py_INCREF(obj);
1371     } else {
1372 #if (PY_VERSION_HEX < 0x02020000)
1373       data->newraw = 0;
1374 #else
1375       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1376 #endif
1377       if (data->newraw) {
1378         Py_INCREF(data->newraw);
1379         data->newargs = PyTuple_New(1);
1380         PyTuple_SetItem(data->newargs, 0, obj);
1381       } else {
1382         data->newargs = obj;
1383       }
1384       Py_INCREF(data->newargs);
1385     }
1386     /* the destroy method, aka as the C++ delete method */
1387     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1388     if (PyErr_Occurred()) {
1389       PyErr_Clear();
1390       data->destroy = 0;
1391     }
1392     if (data->destroy) {
1393       int flags;
1394       Py_INCREF(data->destroy);
1395       flags = PyCFunction_GET_FLAGS(data->destroy);
1396 #ifdef METH_O
1397       data->delargs = !(flags & (METH_O));
1398 #else
1399       data->delargs = 0;
1400 #endif
1401     } else {
1402       data->delargs = 0;
1403     }
1404     data->implicitconv = 0;
1405     return data;
1406   }
1407 }
1408
1409 SWIGRUNTIME void
1410 SwigPyClientData_Del(SwigPyClientData* data)
1411 {
1412   Py_XDECREF(data->newraw);
1413   Py_XDECREF(data->newargs);
1414   Py_XDECREF(data->destroy);
1415 }
1416
1417 /* =============== SwigPyObject =====================*/
1418
1419 typedef struct {
1420   PyObject_HEAD
1421   void *ptr;
1422   swig_type_info *ty;
1423   int own;
1424   PyObject *next;
1425 } SwigPyObject;
1426
1427 SWIGRUNTIME PyObject *
1428 SwigPyObject_long(SwigPyObject *v)
1429 {
1430   return PyLong_FromVoidPtr(v->ptr);
1431 }
1432
1433 SWIGRUNTIME PyObject *
1434 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1435 {
1436   PyObject *res = NULL;
1437   PyObject *args = PyTuple_New(1);
1438   if (args) {
1439     if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1440       PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1441       if (ofmt) {
1442 #if PY_VERSION_HEX >= 0x03000000
1443         res = PyUnicode_Format(ofmt,args);
1444 #else
1445         res = PyString_Format(ofmt,args);
1446 #endif
1447         Py_DECREF(ofmt);
1448       }
1449       Py_DECREF(args);
1450     }
1451   }
1452   return res;
1453 }
1454
1455 SWIGRUNTIME PyObject *
1456 SwigPyObject_oct(SwigPyObject *v)
1457 {
1458   return SwigPyObject_format("%o",v);
1459 }
1460
1461 SWIGRUNTIME PyObject *
1462 SwigPyObject_hex(SwigPyObject *v)
1463 {
1464   return SwigPyObject_format("%x",v);
1465 }
1466
1467 SWIGRUNTIME PyObject *
1468 #ifdef METH_NOARGS
1469 SwigPyObject_repr(SwigPyObject *v)
1470 #else
1471 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1472 #endif
1473 {
1474   const char *name = SWIG_TypePrettyName(v->ty);
1475   PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, v);
1476   if (v->next) {
1477 #ifdef METH_NOARGS
1478     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1479 #else
1480     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1481 #endif
1482 #if PY_VERSION_HEX >= 0x03000000
1483     PyObject *joined = PyUnicode_Concat(repr, nrep);
1484     Py_DecRef(repr);
1485     Py_DecRef(nrep);
1486     repr = joined;
1487 #else
1488     PyString_ConcatAndDel(&repr,nrep);
1489 #endif
1490   }
1491   return repr;
1492 }
1493
1494 SWIGRUNTIME int
1495 SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1496 {
1497   char *str;
1498 #ifdef METH_NOARGS
1499   PyObject *repr = SwigPyObject_repr(v);
1500 #else
1501   PyObject *repr = SwigPyObject_repr(v, NULL);
1502 #endif
1503   if (repr) {
1504     str = SWIG_Python_str_AsChar(repr);
1505     fputs(str, fp);
1506     SWIG_Python_str_DelForPy3(str);
1507     Py_DECREF(repr);
1508     return 0;
1509   } else {
1510     return 1;
1511   }
1512 }
1513
1514 SWIGRUNTIME PyObject *
1515 SwigPyObject_str(SwigPyObject *v)
1516 {
1517   char result[SWIG_BUFFER_SIZE];
1518   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1519     SWIG_Python_str_FromChar(result) : 0;
1520 }
1521
1522 SWIGRUNTIME int
1523 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1524 {
1525   void *i = v->ptr;
1526   void *j = w->ptr;
1527   return (i < j) ? -1 : ((i > j) ? 1 : 0);
1528 }
1529
1530 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1531 SWIGRUNTIME PyObject*
1532 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1533 {
1534   PyObject* res;
1535   if( op != Py_EQ && op != Py_NE ) {
1536     Py_INCREF(Py_NotImplemented);
1537     return Py_NotImplemented;
1538   }
1539   if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
1540     res = Py_True;
1541   else
1542     res = Py_False;
1543   Py_INCREF(res);
1544   return res;
1545 }
1546
1547
1548 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1549
1550 SWIGRUNTIME PyTypeObject*
1551 SwigPyObject_type(void) {
1552   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1553   return type;
1554 }
1555
1556 SWIGRUNTIMEINLINE int
1557 SwigPyObject_Check(PyObject *op) {
1558   return (Py_TYPE(op) == SwigPyObject_type())
1559     || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1560 }
1561
1562 SWIGRUNTIME PyObject *
1563 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1564
1565 SWIGRUNTIME void
1566 SwigPyObject_dealloc(PyObject *v)
1567 {
1568   SwigPyObject *sobj = (SwigPyObject *) v;
1569   PyObject *next = sobj->next;
1570   if (sobj->own == SWIG_POINTER_OWN) {
1571     swig_type_info *ty = sobj->ty;
1572     SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1573     PyObject *destroy = data ? data->destroy : 0;
1574     if (destroy) {
1575       /* destroy is always a VARARGS method */
1576       PyObject *res;
1577       if (data->delargs) {
1578         /* we need to create a temporary object to carry the destroy operation */
1579         PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1580         res = SWIG_Python_CallFunctor(destroy, tmp);
1581         Py_DECREF(tmp);
1582       } else {
1583         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1584         PyObject *mself = PyCFunction_GET_SELF(destroy);
1585         res = ((*meth)(mself, v));
1586       }
1587       Py_XDECREF(res);
1588     }
1589 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1590     else {
1591       const char *name = SWIG_TypePrettyName(ty);
1592       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1593     }
1594 #endif
1595   }
1596   Py_XDECREF(next);
1597   PyObject_DEL(v);
1598 }
1599
1600 SWIGRUNTIME PyObject*
1601 SwigPyObject_append(PyObject* v, PyObject* next)
1602 {
1603   SwigPyObject *sobj = (SwigPyObject *) v;
1604 #ifndef METH_O
1605   PyObject *tmp = 0;
1606   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1607   next = tmp;
1608 #endif
1609   if (!SwigPyObject_Check(next)) {
1610     return NULL;
1611   }
1612   sobj->next = next;
1613   Py_INCREF(next);
1614   return SWIG_Py_Void();
1615 }
1616
1617 SWIGRUNTIME PyObject*
1618 #ifdef METH_NOARGS
1619 SwigPyObject_next(PyObject* v)
1620 #else
1621 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1622 #endif
1623 {
1624   SwigPyObject *sobj = (SwigPyObject *) v;
1625   if (sobj->next) {
1626     Py_INCREF(sobj->next);
1627     return sobj->next;
1628   } else {
1629     return SWIG_Py_Void();
1630   }
1631 }
1632
1633 SWIGINTERN PyObject*
1634 #ifdef METH_NOARGS
1635 SwigPyObject_disown(PyObject *v)
1636 #else
1637 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1638 #endif
1639 {
1640   SwigPyObject *sobj = (SwigPyObject *)v;
1641   sobj->own = 0;
1642   return SWIG_Py_Void();
1643 }
1644
1645 SWIGINTERN PyObject*
1646 #ifdef METH_NOARGS
1647 SwigPyObject_acquire(PyObject *v)
1648 #else
1649 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1650 #endif
1651 {
1652   SwigPyObject *sobj = (SwigPyObject *)v;
1653   sobj->own = SWIG_POINTER_OWN;
1654   return SWIG_Py_Void();
1655 }
1656
1657 SWIGINTERN PyObject*
1658 SwigPyObject_own(PyObject *v, PyObject *args)
1659 {
1660   PyObject *val = 0;
1661 #if (PY_VERSION_HEX < 0x02020000)
1662   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1663 #else
1664   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1665 #endif
1666     {
1667       return NULL;
1668     }
1669   else
1670     {
1671       SwigPyObject *sobj = (SwigPyObject *)v;
1672       PyObject *obj = PyBool_FromLong(sobj->own);
1673       if (val) {
1674 #ifdef METH_NOARGS
1675         if (PyObject_IsTrue(val)) {
1676           SwigPyObject_acquire(v);
1677         } else {
1678           SwigPyObject_disown(v);
1679         }
1680 #else
1681         if (PyObject_IsTrue(val)) {
1682           SwigPyObject_acquire(v,args);
1683         } else {
1684           SwigPyObject_disown(v,args);
1685         }
1686 #endif
1687       }
1688       return obj;
1689     }
1690 }
1691
1692 #ifdef METH_O
1693 static PyMethodDef
1694 swigobject_methods[] = {
1695   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1696   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
1697   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1698   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
1699   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1700   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1701   {0, 0, 0, 0}
1702 };
1703 #else
1704 static PyMethodDef
1705 swigobject_methods[] = {
1706   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1707   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1708   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1709   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1710   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1711   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1712   {0, 0, 0, 0}
1713 };
1714 #endif
1715
1716 #if PY_VERSION_HEX < 0x02020000
1717 SWIGINTERN PyObject *
1718 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1719 {
1720   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1721 }
1722 #endif
1723
1724 SWIGRUNTIME PyTypeObject*
1725 _PySwigObject_type(void) {
1726   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1727
1728   static PyNumberMethods SwigPyObject_as_number = {
1729     (binaryfunc)0, /*nb_add*/
1730     (binaryfunc)0, /*nb_subtract*/
1731     (binaryfunc)0, /*nb_multiply*/
1732     /* nb_divide removed in Python 3 */
1733 #if PY_VERSION_HEX < 0x03000000
1734     (binaryfunc)0, /*nb_divide*/
1735 #endif
1736     (binaryfunc)0, /*nb_remainder*/
1737     (binaryfunc)0, /*nb_divmod*/
1738     (ternaryfunc)0,/*nb_power*/
1739     (unaryfunc)0,  /*nb_negative*/
1740     (unaryfunc)0,  /*nb_positive*/
1741     (unaryfunc)0,  /*nb_absolute*/
1742     (inquiry)0,    /*nb_nonzero*/
1743     0,             /*nb_invert*/
1744     0,             /*nb_lshift*/
1745     0,             /*nb_rshift*/
1746     0,             /*nb_and*/
1747     0,             /*nb_xor*/
1748     0,             /*nb_or*/
1749 #if PY_VERSION_HEX < 0x03000000
1750     0,   /*nb_coerce*/
1751 #endif
1752     (unaryfunc)SwigPyObject_long, /*nb_int*/
1753 #if PY_VERSION_HEX < 0x03000000
1754     (unaryfunc)SwigPyObject_long, /*nb_long*/
1755 #else
1756     0, /*nb_reserved*/
1757 #endif
1758     (unaryfunc)0,                 /*nb_float*/
1759 #if PY_VERSION_HEX < 0x03000000
1760     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
1761     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
1762 #endif
1763 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1764     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1765 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1766     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1767 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1768     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1769 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1770     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1771 #endif
1772   };
1773
1774   static PyTypeObject swigpyobject_type;
1775   static int type_init = 0;
1776   if (!type_init) {
1777     const PyTypeObject tmp
1778       = {
1779         /* PyObject header changed in Python 3 */
1780 #if PY_VERSION_HEX >= 0x03000000
1781         PyVarObject_HEAD_INIT(&PyType_Type, 0)
1782 #else
1783         PyObject_HEAD_INIT(NULL)
1784         0,                                  /* ob_size */
1785 #endif
1786         (char *)"SwigPyObject",             /* tp_name */
1787         sizeof(SwigPyObject),               /* tp_basicsize */
1788         0,                                  /* tp_itemsize */
1789         (destructor)SwigPyObject_dealloc,   /* tp_dealloc */
1790         (printfunc)SwigPyObject_print,      /* tp_print */
1791 #if PY_VERSION_HEX < 0x02020000
1792         (getattrfunc)SwigPyObject_getattr,  /* tp_getattr */
1793 #else
1794         (getattrfunc)0,                     /* tp_getattr */
1795 #endif
1796         (setattrfunc)0,                     /* tp_setattr */
1797 #if PY_VERSION_HEX >= 0x03000000
1798     0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1799 #else
1800         (cmpfunc)SwigPyObject_compare,      /* tp_compare */
1801 #endif
1802         (reprfunc)SwigPyObject_repr,        /* tp_repr */
1803         &SwigPyObject_as_number,            /* tp_as_number */
1804         0,                                  /* tp_as_sequence */
1805         0,                                  /* tp_as_mapping */
1806         (hashfunc)0,                        /* tp_hash */
1807         (ternaryfunc)0,                     /* tp_call */
1808         (reprfunc)SwigPyObject_str,         /* tp_str */
1809         PyObject_GenericGetAttr,            /* tp_getattro */
1810         0,                                  /* tp_setattro */
1811         0,                                  /* tp_as_buffer */
1812         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1813         swigobject_doc,                     /* tp_doc */
1814         0,                                  /* tp_traverse */
1815         0,                                  /* tp_clear */
1816         (richcmpfunc)SwigPyObject_richcompare,           /* tp_richcompare */
1817         0,                                  /* tp_weaklistoffset */
1818 #if PY_VERSION_HEX >= 0x02020000
1819         0,                                  /* tp_iter */
1820         0,                                  /* tp_iternext */
1821         swigobject_methods,                 /* tp_methods */
1822         0,                                  /* tp_members */
1823         0,                                  /* tp_getset */
1824         0,                                  /* tp_base */
1825         0,                                  /* tp_dict */
1826         0,                                  /* tp_descr_get */
1827         0,                                  /* tp_descr_set */
1828         0,                                  /* tp_dictoffset */
1829         0,                                  /* tp_init */
1830         0,                                  /* tp_alloc */
1831         0,                                  /* tp_new */
1832         0,                                  /* tp_free */
1833         0,                                  /* tp_is_gc */
1834         0,                                  /* tp_bases */
1835         0,                                  /* tp_mro */
1836         0,                                  /* tp_cache */
1837         0,                                  /* tp_subclasses */
1838         0,                                  /* tp_weaklist */
1839 #endif
1840 #if PY_VERSION_HEX >= 0x02030000
1841         0,                                  /* tp_del */
1842 #endif
1843 #ifdef COUNT_ALLOCS
1844         0,0,0,0                             /* tp_alloc -> tp_next */
1845 #endif
1846       };
1847     swigpyobject_type = tmp;
1848     /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
1849 #if PY_VERSION_HEX < 0x03000000
1850     swigpyobject_type.ob_type = &PyType_Type;
1851 #endif
1852     type_init = 1;
1853   }
1854   return &swigpyobject_type;
1855 }
1856
1857 SWIGRUNTIME PyObject *
1858 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1859 {
1860   SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1861   if (sobj) {
1862     sobj->ptr  = ptr;
1863     sobj->ty   = ty;
1864     sobj->own  = own;
1865     sobj->next = 0;
1866   }
1867   return (PyObject *)sobj;
1868 }
1869
1870 /* -----------------------------------------------------------------------------
1871  * Implements a simple Swig Packed type, and use it instead of string
1872  * ----------------------------------------------------------------------------- */
1873
1874 typedef struct {
1875   PyObject_HEAD
1876   void *pack;
1877   swig_type_info *ty;
1878   size_t size;
1879 } SwigPyPacked;
1880
1881 SWIGRUNTIME int
1882 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1883 {
1884   char result[SWIG_BUFFER_SIZE];
1885   fputs("<Swig Packed ", fp);
1886   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1887     fputs("at ", fp);
1888     fputs(result, fp);
1889   }
1890   fputs(v->ty->name,fp);
1891   fputs(">", fp);
1892   return 0;
1893 }
1894
1895 SWIGRUNTIME PyObject *
1896 SwigPyPacked_repr(SwigPyPacked *v)
1897 {
1898   char result[SWIG_BUFFER_SIZE];
1899   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1900     return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1901   } else {
1902     return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1903   }
1904 }
1905
1906 SWIGRUNTIME PyObject *
1907 SwigPyPacked_str(SwigPyPacked *v)
1908 {
1909   char result[SWIG_BUFFER_SIZE];
1910   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1911     return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1912   } else {
1913     return SWIG_Python_str_FromChar(v->ty->name);
1914   }
1915 }
1916
1917 SWIGRUNTIME int
1918 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
1919 {
1920   size_t i = v->size;
1921   size_t j = w->size;
1922   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1923   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1924 }
1925
1926 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1927
1928 SWIGRUNTIME PyTypeObject*
1929 SwigPyPacked_type(void) {
1930   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1931   return type;
1932 }
1933
1934 SWIGRUNTIMEINLINE int
1935 SwigPyPacked_Check(PyObject *op) {
1936   return ((op)->ob_type == _PySwigPacked_type())
1937     || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1938 }
1939
1940 SWIGRUNTIME void
1941 SwigPyPacked_dealloc(PyObject *v)
1942 {
1943   if (SwigPyPacked_Check(v)) {
1944     SwigPyPacked *sobj = (SwigPyPacked *) v;
1945     free(sobj->pack);
1946   }
1947   PyObject_DEL(v);
1948 }
1949
1950 SWIGRUNTIME PyTypeObject*
1951 _PySwigPacked_type(void) {
1952   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1953   static PyTypeObject swigpypacked_type;
1954   static int type_init = 0;
1955   if (!type_init) {
1956     const PyTypeObject tmp
1957       = {
1958     /* PyObject header changed in Python 3 */
1959 #if PY_VERSION_HEX>=0x03000000
1960     PyVarObject_HEAD_INIT(&PyType_Type, 0)
1961 #else
1962         PyObject_HEAD_INIT(NULL)
1963     0,                              /* ob_size */
1964 #endif
1965         (char *)"SwigPyPacked",             /* tp_name */
1966         sizeof(SwigPyPacked),               /* tp_basicsize */
1967         0,                                  /* tp_itemsize */
1968         (destructor)SwigPyPacked_dealloc,   /* tp_dealloc */
1969         (printfunc)SwigPyPacked_print,      /* tp_print */
1970         (getattrfunc)0,                     /* tp_getattr */
1971         (setattrfunc)0,                     /* tp_setattr */
1972 #if PY_VERSION_HEX>=0x03000000
1973     0, /* tp_reserved in 3.0.1 */
1974 #else
1975     (cmpfunc)SwigPyPacked_compare,          /* tp_compare */
1976 #endif
1977         (reprfunc)SwigPyPacked_repr,        /* tp_repr */
1978         0,                                  /* tp_as_number */
1979         0,                                  /* tp_as_sequence */
1980         0,                                  /* tp_as_mapping */
1981         (hashfunc)0,                        /* tp_hash */
1982         (ternaryfunc)0,                     /* tp_call */
1983         (reprfunc)SwigPyPacked_str,         /* tp_str */
1984         PyObject_GenericGetAttr,            /* tp_getattro */
1985         0,                                  /* tp_setattro */
1986         0,                                  /* tp_as_buffer */
1987         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1988         swigpacked_doc,                     /* tp_doc */
1989         0,                                  /* tp_traverse */
1990         0,                                  /* tp_clear */
1991         0,                                  /* tp_richcompare */
1992         0,                                  /* tp_weaklistoffset */
1993 #if PY_VERSION_HEX >= 0x02020000
1994         0,                                  /* tp_iter */
1995         0,                                  /* tp_iternext */
1996         0,                                  /* tp_methods */
1997         0,                                  /* tp_members */
1998         0,                                  /* tp_getset */
1999         0,                                  /* tp_base */
2000         0,                                  /* tp_dict */
2001         0,                                  /* tp_descr_get */
2002         0,                                  /* tp_descr_set */
2003         0,                                  /* tp_dictoffset */
2004         0,                                  /* tp_init */
2005         0,                                  /* tp_alloc */
2006         0,                                  /* tp_new */
2007         0,                                  /* tp_free */
2008         0,                                  /* tp_is_gc */
2009         0,                                  /* tp_bases */
2010         0,                                  /* tp_mro */
2011         0,                                  /* tp_cache */
2012         0,                                  /* tp_subclasses */
2013         0,                                  /* tp_weaklist */
2014 #endif
2015 #if PY_VERSION_HEX >= 0x02030000
2016         0,                                  /* tp_del */
2017 #endif
2018 #ifdef COUNT_ALLOCS
2019         0,0,0,0                             /* tp_alloc -> tp_next */
2020 #endif
2021       };
2022     swigpypacked_type = tmp;
2023     /* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
2024 #if PY_VERSION_HEX < 0x03000000
2025     swigpypacked_type.ob_type = &PyType_Type;
2026 #endif
2027     type_init = 1;
2028   }
2029   return &swigpypacked_type;
2030 }
2031
2032 SWIGRUNTIME PyObject *
2033 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2034 {
2035   SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2036   if (sobj) {
2037     void *pack = malloc(size);
2038     if (pack) {
2039       memcpy(pack, ptr, size);
2040       sobj->pack = pack;
2041       sobj->ty   = ty;
2042       sobj->size = size;
2043     } else {
2044       PyObject_DEL((PyObject *) sobj);
2045       sobj = 0;
2046     }
2047   }
2048   return (PyObject *) sobj;
2049 }
2050
2051 SWIGRUNTIME swig_type_info *
2052 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2053 {
2054   if (SwigPyPacked_Check(obj)) {
2055     SwigPyPacked *sobj = (SwigPyPacked *)obj;
2056     if (sobj->size != size) return 0;
2057     memcpy(ptr, sobj->pack, size);
2058     return sobj->ty;
2059   } else {
2060     return 0;
2061   }
2062 }
2063
2064 /* -----------------------------------------------------------------------------
2065  * pointers/data manipulation
2066  * ----------------------------------------------------------------------------- */
2067
2068 SWIGRUNTIMEINLINE PyObject *
2069 _SWIG_This(void)
2070 {
2071     return SWIG_Python_str_FromChar("this");
2072 }
2073
2074 SWIGRUNTIME PyObject *
2075 SWIG_This(void)
2076 {
2077   static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
2078   return swig_this;
2079 }
2080
2081 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2082
2083 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2084 #if PY_VERSION_HEX>=0x03000000
2085 #define SWIG_PYTHON_SLOW_GETSET_THIS
2086 #endif
2087
2088 SWIGRUNTIME SwigPyObject *
2089 SWIG_Python_GetSwigThis(PyObject *pyobj)
2090 {
2091   if (SwigPyObject_Check(pyobj)) {
2092     return (SwigPyObject *) pyobj;
2093   } else {
2094     PyObject *obj = 0;
2095 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2096     if (PyInstance_Check(pyobj)) {
2097       obj = _PyInstance_Lookup(pyobj, SWIG_This());
2098     } else {
2099       PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2100       if (dictptr != NULL) {
2101         PyObject *dict = *dictptr;
2102         obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2103       } else {
2104 #ifdef PyWeakref_CheckProxy
2105         if (PyWeakref_CheckProxy(pyobj)) {
2106           PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2107           return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2108         }
2109 #endif
2110         obj = PyObject_GetAttr(pyobj,SWIG_This());
2111         if (obj) {
2112           Py_DECREF(obj);
2113         } else {
2114           if (PyErr_Occurred()) PyErr_Clear();
2115           return 0;
2116         }
2117       }
2118     }
2119 #else
2120     obj = PyObject_GetAttr(pyobj,SWIG_This());
2121     if (obj) {
2122       Py_DECREF(obj);
2123     } else {
2124       if (PyErr_Occurred()) PyErr_Clear();
2125       return 0;
2126     }
2127 #endif
2128     if (obj && !SwigPyObject_Check(obj)) {
2129       /* a PyObject is called 'this', try to get the 'real this'
2130          SwigPyObject from it */
2131       return SWIG_Python_GetSwigThis(obj);
2132     }
2133     return (SwigPyObject *)obj;
2134   }
2135 }
2136
2137 /* Acquire a pointer value */
2138
2139 SWIGRUNTIME int
2140 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2141   if (own == SWIG_POINTER_OWN) {
2142     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2143     if (sobj) {
2144       int oldown = sobj->own;
2145       sobj->own = own;
2146       return oldown;
2147     }
2148   }
2149   return 0;
2150 }
2151
2152 /* Convert a pointer value */
2153
2154 SWIGRUNTIME int
2155 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2156   if (!obj) return SWIG_ERROR;
2157   if (obj == Py_None) {
2158     if (ptr) *ptr = 0;
2159     return SWIG_OK;
2160   } else {
2161     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2162     if (own)
2163       *own = 0;
2164     while (sobj) {
2165       void *vptr = sobj->ptr;
2166       if (ty) {
2167         swig_type_info *to = sobj->ty;
2168         if (to == ty) {
2169           /* no type cast needed */
2170           if (ptr) *ptr = vptr;
2171           break;
2172         } else {
2173           swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2174           if (!tc) {
2175             sobj = (SwigPyObject *)sobj->next;
2176           } else {
2177             if (ptr) {
2178               int newmemory = 0;
2179               *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2180               if (newmemory == SWIG_CAST_NEW_MEMORY) {
2181                 assert(own);
2182                 if (own)
2183                   *own = *own | SWIG_CAST_NEW_MEMORY;
2184               }
2185             }
2186             break;
2187           }
2188         }
2189       } else {
2190         if (ptr) *ptr = vptr;
2191         break;
2192       }
2193     }
2194     if (sobj) {
2195       if (own)
2196         *own = *own | sobj->own;
2197       if (flags & SWIG_POINTER_DISOWN) {
2198         sobj->own = 0;
2199       }
2200       return SWIG_OK;
2201     } else {
2202       int res = SWIG_ERROR;
2203       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2204         SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2205         if (data && !data->implicitconv) {
2206           PyObject *klass = data->klass;
2207           if (klass) {
2208             PyObject *impconv;
2209             data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2210             impconv = SWIG_Python_CallFunctor(klass, obj);
2211             data->implicitconv = 0;
2212             if (PyErr_Occurred()) {
2213               PyErr_Clear();
2214               impconv = 0;
2215             }
2216             if (impconv) {
2217               SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2218               if (iobj) {
2219                 void *vptr;
2220                 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2221                 if (SWIG_IsOK(res)) {
2222                   if (ptr) {
2223                     *ptr = vptr;
2224                     /* transfer the ownership to 'ptr' */
2225                     iobj->own = 0;
2226                     res = SWIG_AddCast(res);
2227                     res = SWIG_AddNewMask(res);
2228                   } else {
2229                     res = SWIG_AddCast(res);
2230                   }
2231                 }
2232               }
2233               Py_DECREF(impconv);
2234             }
2235           }
2236         }
2237       }
2238       return res;
2239     }
2240   }
2241 }
2242
2243 /* Convert a function ptr value */
2244
2245 SWIGRUNTIME int
2246 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2247   if (!PyCFunction_Check(obj)) {
2248     return SWIG_ConvertPtr(obj, ptr, ty, 0);
2249   } else {
2250     void *vptr = 0;
2251
2252     /* here we get the method pointer for callbacks */
2253     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2254     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2255     if (desc)
2256       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2257     if (!desc)
2258       return SWIG_ERROR;
2259     if (ty) {
2260       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2261       if (tc) {
2262         int newmemory = 0;
2263         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2264         assert(!newmemory); /* newmemory handling not yet implemented */
2265       } else {
2266         return SWIG_ERROR;
2267       }
2268     } else {
2269       *ptr = vptr;
2270     }
2271     return SWIG_OK;
2272   }
2273 }
2274
2275 /* Convert a packed value value */
2276
2277 SWIGRUNTIME int
2278 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2279   swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2280   if (!to) return SWIG_ERROR;
2281   if (ty) {
2282     if (to != ty) {
2283       /* check type cast? */
2284       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2285       if (!tc) return SWIG_ERROR;
2286     }
2287   }
2288   return SWIG_OK;
2289 }
2290
2291 /* -----------------------------------------------------------------------------
2292  * Create a new pointer object
2293  * ----------------------------------------------------------------------------- */
2294
2295 /*
2296   Create a new instance object, without calling __init__, and set the
2297   'this' attribute.
2298 */
2299
2300 SWIGRUNTIME PyObject*
2301 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2302 {
2303 #if (PY_VERSION_HEX >= 0x02020000)
2304   PyObject *inst = 0;
2305   PyObject *newraw = data->newraw;
2306   if (newraw) {
2307     inst = PyObject_Call(newraw, data->newargs, NULL);
2308     if (inst) {
2309 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2310       PyObject **dictptr = _PyObject_GetDictPtr(inst);
2311       if (dictptr != NULL) {
2312         PyObject *dict = *dictptr;
2313         if (dict == NULL) {
2314           dict = PyDict_New();
2315           *dictptr = dict;
2316           PyDict_SetItem(dict, SWIG_This(), swig_this);
2317         }
2318       }
2319 #else
2320       PyObject *key = SWIG_This();
2321       PyObject_SetAttr(inst, key, swig_this);
2322 #endif
2323     }
2324   } else {
2325 #if PY_VERSION_HEX >= 0x03000000
2326     inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2327     PyObject_SetAttr(inst, SWIG_This(), swig_this);
2328     Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2329 #else
2330     PyObject *dict = PyDict_New();
2331     PyDict_SetItem(dict, SWIG_This(), swig_this);
2332     inst = PyInstance_NewRaw(data->newargs, dict);
2333     Py_DECREF(dict);
2334 #endif
2335   }
2336   return inst;
2337 #else
2338 #if (PY_VERSION_HEX >= 0x02010000)
2339   PyObject *inst;
2340   PyObject *dict = PyDict_New();
2341   PyDict_SetItem(dict, SWIG_This(), swig_this);
2342   inst = PyInstance_NewRaw(data->newargs, dict);
2343   Py_DECREF(dict);
2344   return (PyObject *) inst;
2345 #else
2346   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2347   if (inst == NULL) {
2348     return NULL;
2349   }
2350   inst->in_class = (PyClassObject *)data->newargs;
2351   Py_INCREF(inst->in_class);
2352   inst->in_dict = PyDict_New();
2353   if (inst->in_dict == NULL) {
2354     Py_DECREF(inst);
2355     return NULL;
2356   }
2357 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2358   inst->in_weakreflist = NULL;
2359 #endif
2360 #ifdef Py_TPFLAGS_GC
2361   PyObject_GC_Init(inst);
2362 #endif
2363   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2364   return (PyObject *) inst;
2365 #endif
2366 #endif
2367 }
2368
2369 SWIGRUNTIME void
2370 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2371 {
2372  PyObject *dict;
2373 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2374  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2375  if (dictptr != NULL) {
2376    dict = *dictptr;
2377    if (dict == NULL) {
2378      dict = PyDict_New();
2379      *dictptr = dict;
2380    }
2381    PyDict_SetItem(dict, SWIG_This(), swig_this);
2382    return;
2383  }
2384 #endif
2385  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2386  PyDict_SetItem(dict, SWIG_This(), swig_this);
2387  Py_DECREF(dict);
2388 }
2389
2390
2391 SWIGINTERN PyObject *
2392 SWIG_Python_InitShadowInstance(PyObject *args) {
2393   PyObject *obj[2];
2394   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2395     return NULL;
2396   } else {
2397     SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2398     if (sthis) {
2399       SwigPyObject_append((PyObject*) sthis, obj[1]);
2400     } else {
2401       SWIG_Python_SetSwigThis(obj[0], obj[1]);
2402     }
2403     return SWIG_Py_Void();
2404   }
2405 }
2406
2407 /* Create a new pointer object */
2408
2409 SWIGRUNTIME PyObject *
2410 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2411   if (!ptr) {
2412     return SWIG_Py_Void();
2413   } else {
2414     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2415     PyObject *robj = SwigPyObject_New(ptr, type, own);
2416     SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2417     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2418       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2419       if (inst) {
2420         Py_DECREF(robj);
2421         robj = inst;
2422       }
2423     }
2424     return robj;
2425   }
2426 }
2427
2428 /* Create a new packed object */
2429
2430 SWIGRUNTIMEINLINE PyObject *
2431 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2432   return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2433 }
2434
2435 /* -----------------------------------------------------------------------------*
2436  *  Get type list
2437  * -----------------------------------------------------------------------------*/
2438
2439 #ifdef SWIG_LINK_RUNTIME
2440 void *SWIG_ReturnGlobalTypeList(void *);
2441 #endif
2442
2443 SWIGRUNTIME swig_module_info *
2444 SWIG_Python_GetModule(void) {
2445   static void *type_pointer = (void *)0;
2446   /* first check if module already created */
2447   if (!type_pointer) {
2448 #ifdef SWIG_LINK_RUNTIME
2449     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2450 #else
2451     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2452                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2453     if (PyErr_Occurred()) {
2454       PyErr_Clear();
2455       type_pointer = (void *)0;
2456     }
2457 #endif
2458   }
2459   return (swig_module_info *) type_pointer;
2460 }
2461
2462 #if PY_MAJOR_VERSION < 2
2463 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
2464    is copied out of Python/modsupport.c in python version 2.3.4 */
2465 SWIGINTERN int
2466 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2467 {
2468   PyObject *dict;
2469   if (!PyModule_Check(m)) {
2470     PyErr_SetString(PyExc_TypeError,
2471                     "PyModule_AddObject() needs module as first arg");
2472     return SWIG_ERROR;
2473   }
2474   if (!o) {
2475     PyErr_SetString(PyExc_TypeError,
2476                     "PyModule_AddObject() needs non-NULL value");
2477     return SWIG_ERROR;
2478   }
2479
2480   dict = PyModule_GetDict(m);
2481   if (dict == NULL) {
2482     /* Internal error -- modules must have a dict! */
2483     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2484                  PyModule_GetName(m));
2485     return SWIG_ERROR;
2486   }
2487   if (PyDict_SetItemString(dict, name, o))
2488     return SWIG_ERROR;
2489   Py_DECREF(o);
2490   return SWIG_OK;
2491 }
2492 #endif
2493
2494 SWIGRUNTIME void
2495 SWIG_Python_DestroyModule(void *vptr)
2496 {
2497   swig_module_info *swig_module = (swig_module_info *) vptr;
2498   swig_type_info **types = swig_module->types;
2499   size_t i;
2500   for (i =0; i < swig_module->size; ++i) {
2501     swig_type_info *ty = types[i];
2502     if (ty->owndata) {
2503       SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2504       if (data) SwigPyClientData_Del(data);
2505     }
2506   }
2507   Py_DECREF(SWIG_This());
2508 }
2509
2510 SWIGRUNTIME void
2511 SWIG_Python_SetModule(swig_module_info *swig_module) {
2512   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2513
2514 #if PY_VERSION_HEX >= 0x03000000
2515  /* Add a dummy module object into sys.modules */
2516   PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2517 #else
2518   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2519                                    swig_empty_runtime_method_table);
2520 #endif
2521   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2522   if (pointer && module) {
2523     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2524   } else {
2525     Py_XDECREF(pointer);
2526   }
2527 }
2528
2529 /* The python cached type query */
2530 SWIGRUNTIME PyObject *
2531 SWIG_Python_TypeCache(void) {
2532   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2533   return cache;
2534 }
2535
2536 SWIGRUNTIME swig_type_info *
2537 SWIG_Python_TypeQuery(const char *type)
2538 {
2539   PyObject *cache = SWIG_Python_TypeCache();
2540   PyObject *key = SWIG_Python_str_FromChar(type);
2541   PyObject *obj = PyDict_GetItem(cache, key);
2542   swig_type_info *descriptor;
2543   if (obj) {
2544     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2545   } else {
2546     swig_module_info *swig_module = SWIG_Python_GetModule();
2547     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2548     if (descriptor) {
2549       obj = PyCObject_FromVoidPtr(descriptor, NULL);
2550       PyDict_SetItem(cache, key, obj);
2551       Py_DECREF(obj);
2552     }
2553   }
2554   Py_DECREF(key);
2555   return descriptor;
2556 }
2557
2558 /*
2559    For backward compatibility only
2560 */
2561 #define SWIG_POINTER_EXCEPTION  0
2562 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2563 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2564
2565 SWIGRUNTIME int
2566 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2567 {
2568   if (PyErr_Occurred()) {
2569     PyObject *type = 0;
2570     PyObject *value = 0;
2571     PyObject *traceback = 0;
2572     PyErr_Fetch(&type, &value, &traceback);
2573     if (value) {
2574       char *tmp;
2575       PyObject *old_str = PyObject_Str(value);
2576       Py_XINCREF(type);
2577       PyErr_Clear();
2578       if (infront) {
2579         PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2580       } else {
2581         PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2582       }
2583       SWIG_Python_str_DelForPy3(tmp);
2584       Py_DECREF(old_str);
2585     }
2586     return 1;
2587   } else {
2588     return 0;
2589   }
2590 }
2591
2592 SWIGRUNTIME int
2593 SWIG_Python_ArgFail(int argnum)
2594 {
2595   if (PyErr_Occurred()) {
2596     /* add information about failing argument */
2597     char mesg[256];
2598     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2599     return SWIG_Python_AddErrMesg(mesg, 1);
2600   } else {
2601     return 0;
2602   }
2603 }
2604
2605 SWIGRUNTIMEINLINE const char *
2606 SwigPyObject_GetDesc(PyObject *self)
2607 {
2608   SwigPyObject *v = (SwigPyObject *)self;
2609   swig_type_info *ty = v ? v->ty : 0;
2610   return ty ? ty->str : (char*)"";
2611 }
2612
2613 SWIGRUNTIME void
2614 SWIG_Python_TypeError(const char *type, PyObject *obj)
2615 {
2616   if (type) {
2617 #if defined(SWIG_COBJECT_TYPES)
2618     if (obj && SwigPyObject_Check(obj)) {
2619       const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2620       if (otype) {
2621         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2622                      type, otype);
2623         return;
2624       }
2625     } else
2626 #endif
2627     {
2628       const char *otype = (obj ? obj->ob_type->tp_name : 0);
2629       if (otype) {
2630         PyObject *str = PyObject_Str(obj);
2631         const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2632         if (cstr) {
2633           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2634                        type, otype, cstr);
2635           SWIG_Python_str_DelForPy3(cstr);
2636         } else {
2637           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2638                        type, otype);
2639         }
2640         Py_XDECREF(str);
2641         return;
2642       }
2643     }
2644     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2645   } else {
2646     PyErr_Format(PyExc_TypeError, "unexpected type is received");
2647   }
2648 }
2649
2650
2651 /* Convert a pointer value, signal an exception on a type mismatch */
2652 SWIGRUNTIME void *
2653 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2654   void *result;
2655   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2656     PyErr_Clear();
2657 #if SWIG_POINTER_EXCEPTION
2658     if (flags) {
2659       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2660       SWIG_Python_ArgFail(argnum);
2661     }
2662 #endif
2663   }
2664   return result;
2665 }
2666
2667
2668 #ifdef __cplusplus
2669 #if 0
2670 { /* cc-mode */
2671 #endif
2672 }
2673 #endif
2674
2675
2676
2677 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2678
2679 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2680
2681
2682
2683   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2684
2685
2686 /* -------- TYPES TABLE (BEGIN) -------- */
2687
2688 #define SWIGTYPE_p_FILE swig_types[0]
2689 #define SWIGTYPE_p_Hex__BiCylinder swig_types[1]
2690 #define SWIGTYPE_p_Hex__Document swig_types[2]
2691 #define SWIGTYPE_p_Hex__Edge swig_types[3]
2692 #define SWIGTYPE_p_Hex__Elements swig_types[4]
2693 #define SWIGTYPE_p_Hex__EltBase swig_types[5]
2694 #define SWIGTYPE_p_Hex__Group swig_types[6]
2695 #define SWIGTYPE_p_Hex__Hex swig_types[7]
2696 #define SWIGTYPE_p_Hex__Hex__EltBase swig_types[8]
2697 #define SWIGTYPE_p_Hex__Hexa swig_types[9]
2698 #define SWIGTYPE_p_Hex__Law swig_types[10]
2699 #define SWIGTYPE_p_Hex__NewShape swig_types[11]
2700 #define SWIGTYPE_p_Hex__Propagation swig_types[12]
2701 #define SWIGTYPE_p_Hex__Quad swig_types[13]
2702 #define SWIGTYPE_p_Hex__Shape swig_types[14]
2703 #define SWIGTYPE_p_Hex__Vector swig_types[15]
2704 #define SWIGTYPE_p_Hex__Vertex swig_types[16]
2705 #define SWIGTYPE_p_Hex__XmlWriter swig_types[17]
2706 #define SWIGTYPE_p_a_Hex__DIM3__double swig_types[18]
2707 #define SWIGTYPE_p_allocator_type swig_types[19]
2708 #define SWIGTYPE_p_char swig_types[20]
2709 #define SWIGTYPE_p_const_reference swig_types[21]
2710 #define SWIGTYPE_p_difference_type swig_types[22]
2711 #define SWIGTYPE_p_double swig_types[23]
2712 #define SWIGTYPE_p_int swig_types[24]
2713 #define SWIGTYPE_p_p_PyObject swig_types[25]
2714 #define SWIGTYPE_p_reference swig_types[26]
2715 #define SWIGTYPE_p_size_type swig_types[27]
2716 #define SWIGTYPE_p_std__invalid_argument swig_types[28]
2717 #define SWIGTYPE_p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t swig_types[29]
2718 #define SWIGTYPE_p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t swig_types[30]
2719 #define SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t swig_types[31]
2720 #define SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type swig_types[32]
2721 #define SWIGTYPE_p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t swig_types[33]
2722 #define SWIGTYPE_p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t swig_types[34]
2723 #define SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t swig_types[35]
2724 #define SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type swig_types[36]
2725 #define SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t swig_types[37]
2726 #define SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type swig_types[38]
2727 #define SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t swig_types[39]
2728 #define SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type swig_types[40]
2729 #define SWIGTYPE_p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t swig_types[41]
2730 #define SWIGTYPE_p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t swig_types[42]
2731 #define SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t swig_types[43]
2732 #define SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type swig_types[44]
2733 #define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[45]
2734 #define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type swig_types[46]
2735 #define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[47]
2736 #define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type swig_types[48]
2737 #define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[49]
2738 #define SWIGTYPE_p_string swig_types[50]
2739 #define SWIGTYPE_p_swig__SwigPyIterator swig_types[51]
2740 #define SWIGTYPE_p_value_type swig_types[52]
2741 #define SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type swig_types[53]
2742 #define SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type swig_types[54]
2743 #define SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type swig_types[55]
2744 #define SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type swig_types[56]
2745 #define SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type swig_types[57]
2746 static swig_type_info *swig_types[59];
2747 static swig_module_info swig_module = {swig_types, 58, 0, 0, 0, 0};
2748 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2749 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2750
2751 /* -------- TYPES TABLE (END) -------- */
2752
2753 #if (PY_VERSION_HEX <= 0x02000000)
2754 # if !defined(SWIG_PYTHON_CLASSIC)
2755 #  error "This python version requires swig to be run with the '-classic' option"
2756 # endif
2757 #endif
2758
2759 /*-----------------------------------------------
2760               @(target):= _hexablock_swig.so
2761   ------------------------------------------------*/
2762 #if PY_VERSION_HEX >= 0x03000000
2763 #  define SWIG_init    PyInit__hexablock_swig
2764
2765 #else
2766 #  define SWIG_init    init_hexablock_swig
2767
2768 #endif
2769 #define SWIG_name    "_hexablock_swig"
2770
2771 #define SWIGVERSION 0x010340
2772 #define SWIG_VERSION SWIGVERSION
2773
2774
2775 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2776 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2777
2778
2779 #include <stdexcept>
2780
2781
2782 namespace swig {
2783   class SwigPtr_PyObject {
2784   protected:
2785     PyObject *_obj;
2786
2787   public:
2788     SwigPtr_PyObject() :_obj(0)
2789     {
2790     }
2791
2792     SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
2793     {
2794       Py_XINCREF(_obj);
2795     }
2796
2797     SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
2798     {
2799       if (initial_ref) {
2800         Py_XINCREF(_obj);
2801       }
2802     }
2803
2804     SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
2805     {
2806       Py_XINCREF(item._obj);
2807       Py_XDECREF(_obj);
2808       _obj = item._obj;
2809       return *this;
2810     }
2811
2812     ~SwigPtr_PyObject()
2813     {
2814       Py_XDECREF(_obj);
2815     }
2816
2817     operator PyObject *() const
2818     {
2819       return _obj;
2820     }
2821
2822     PyObject *operator->() const
2823     {
2824       return _obj;
2825     }
2826   };
2827 }
2828
2829
2830 namespace swig {
2831   struct SwigVar_PyObject : SwigPtr_PyObject {
2832     SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
2833
2834     SwigVar_PyObject & operator = (PyObject* obj)
2835     {
2836       Py_XDECREF(_obj);
2837       _obj = obj;
2838       return *this;
2839     }
2840   };
2841 }
2842
2843
2844 #include "Hex.hxx"
2845 #include "HexDocument.hxx"
2846 #include "HexPropagation.hxx"
2847 #include "HexElements.hxx"
2848 #include "HexQuad.hxx"
2849 #include "HexVertex.hxx"
2850 #include "HexHexa.hxx"
2851 #include "HexEdge.hxx"
2852 #include "HexVector.hxx"
2853 #include "HexBiCylinder.hxx"
2854 #include "HexNewShape.hxx"
2855 #include "HexGroup.hxx"
2856
2857
2858 #include <iostream>
2859
2860
2861 #include <stdexcept>
2862
2863
2864 #if defined(__GNUC__)
2865 #  if __GNUC__ == 2 && __GNUC_MINOR <= 96
2866 #     define SWIG_STD_NOMODERN_STL
2867 #  endif
2868 #endif
2869
2870
2871 #include <string>
2872 #include <stdexcept>
2873
2874
2875 namespace swig {
2876   struct stop_iteration {
2877   };
2878
2879   struct SwigPyIterator {
2880   private:
2881     SwigPtr_PyObject _seq;
2882
2883   protected:
2884     SwigPyIterator(PyObject *seq) : _seq(seq)
2885     {
2886     }
2887
2888   public:
2889     virtual ~SwigPyIterator() {}
2890
2891     // Access iterator method, required by Python
2892     virtual PyObject *value() const = 0;
2893
2894     // Forward iterator method, required by Python
2895     virtual SwigPyIterator *incr(size_t n = 1) = 0;
2896
2897     // Backward iterator method, very common in C++, but not required in Python
2898     virtual SwigPyIterator *decr(size_t /*n*/ = 1)
2899     {
2900       throw stop_iteration();
2901     }
2902
2903     // Random access iterator methods, but not required in Python
2904     virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
2905     {
2906       throw std::invalid_argument("operation not supported");
2907     }
2908
2909     virtual bool equal (const SwigPyIterator &/*x*/) const
2910     {
2911       throw std::invalid_argument("operation not supported");
2912     }
2913
2914     // C++ common/needed methods
2915     virtual SwigPyIterator *copy() const = 0;
2916
2917     PyObject *next()
2918     {
2919       SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
2920       PyObject *obj = value();
2921       incr();
2922       SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
2923       return obj;
2924     }
2925
2926     /* Make an alias for Python 3.x */
2927     PyObject *__next__()
2928     {
2929       return next();
2930     }
2931
2932     PyObject *previous()
2933     {
2934       SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
2935       decr();
2936       PyObject *obj = value();
2937       SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
2938       return obj;
2939     }
2940
2941     SwigPyIterator *advance(ptrdiff_t n)
2942     {
2943       return  (n > 0) ?  incr(n) : decr(-n);
2944     }
2945
2946     bool operator == (const SwigPyIterator& x)  const
2947     {
2948       return equal(x);
2949     }
2950
2951     bool operator != (const SwigPyIterator& x) const
2952     {
2953       return ! operator==(x);
2954     }
2955
2956     SwigPyIterator& operator += (ptrdiff_t n)
2957     {
2958       return *advance(n);
2959     }
2960
2961     SwigPyIterator& operator -= (ptrdiff_t n)
2962     {
2963       return *advance(-n);
2964     }
2965
2966     SwigPyIterator* operator + (ptrdiff_t n) const
2967     {
2968       return copy()->advance(n);
2969     }
2970
2971     SwigPyIterator* operator - (ptrdiff_t n) const
2972     {
2973       return copy()->advance(-n);
2974     }
2975
2976     ptrdiff_t operator - (const SwigPyIterator& x) const
2977     {
2978       return x.distance(*this);
2979     }
2980
2981     static swig_type_info* descriptor() {
2982       static int init = 0;
2983       static swig_type_info* desc = 0;
2984       if (!init) {
2985         desc = SWIG_TypeQuery("swig::SwigPyIterator *");
2986         init = 1;
2987       }
2988       return desc;
2989     }
2990   };
2991 }
2992
2993
2994 SWIGINTERN int
2995 SWIG_AsVal_double (PyObject *obj, double *val)
2996 {
2997   int res = SWIG_TypeError;
2998   if (PyFloat_Check(obj)) {
2999     if (val) *val = PyFloat_AsDouble(obj);
3000     return SWIG_OK;
3001   } else if (PyInt_Check(obj)) {
3002     if (val) *val = PyInt_AsLong(obj);
3003     return SWIG_OK;
3004   } else if (PyLong_Check(obj)) {
3005     double v = PyLong_AsDouble(obj);
3006     if (!PyErr_Occurred()) {
3007       if (val) *val = v;
3008       return SWIG_OK;
3009     } else {
3010       PyErr_Clear();
3011     }
3012   }
3013 #ifdef SWIG_PYTHON_CAST_MODE
3014   {
3015     int dispatch = 0;
3016     double d = PyFloat_AsDouble(obj);
3017     if (!PyErr_Occurred()) {
3018       if (val) *val = d;
3019       return SWIG_AddCast(SWIG_OK);
3020     } else {
3021       PyErr_Clear();
3022     }
3023     if (!dispatch) {
3024       long v = PyLong_AsLong(obj);
3025       if (!PyErr_Occurred()) {
3026         if (val) *val = v;
3027         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3028       } else {
3029         PyErr_Clear();
3030       }
3031     }
3032   }
3033 #endif
3034   return res;
3035 }
3036
3037
3038 #include <float.h>
3039
3040
3041 #include <math.h>
3042
3043
3044 SWIGINTERNINLINE int
3045 SWIG_CanCastAsInteger(double *d, double min, double max) {
3046   double x = *d;
3047   if ((min <= x && x <= max)) {
3048    double fx = floor(x);
3049    double cx = ceil(x);
3050    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3051    if ((errno == EDOM) || (errno == ERANGE)) {
3052      errno = 0;
3053    } else {
3054      double summ, reps, diff;
3055      if (rd < x) {
3056        diff = x - rd;
3057      } else if (rd > x) {
3058        diff = rd - x;
3059      } else {
3060        return 1;
3061      }
3062      summ = rd + x;
3063      reps = diff/summ;
3064      if (reps < 8*DBL_EPSILON) {
3065        *d = rd;
3066        return 1;
3067      }
3068    }
3069   }
3070   return 0;
3071 }
3072
3073
3074 SWIGINTERN int
3075 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3076 {
3077   if (PyInt_Check(obj)) {
3078     long v = PyInt_AsLong(obj);
3079     if (v >= 0) {
3080       if (val) *val = v;
3081       return SWIG_OK;
3082     } else {
3083       return SWIG_OverflowError;
3084     }
3085   } else if (PyLong_Check(obj)) {
3086     unsigned long v = PyLong_AsUnsignedLong(obj);
3087     if (!PyErr_Occurred()) {
3088       if (val) *val = v;
3089       return SWIG_OK;
3090     } else {
3091       PyErr_Clear();
3092     }
3093   }
3094 #ifdef SWIG_PYTHON_CAST_MODE
3095   {
3096     int dispatch = 0;
3097     unsigned long v = PyLong_AsUnsignedLong(obj);
3098     if (!PyErr_Occurred()) {
3099       if (val) *val = v;
3100       return SWIG_AddCast(SWIG_OK);
3101     } else {
3102       PyErr_Clear();
3103     }
3104     if (!dispatch) {
3105       double d;
3106       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3107       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3108         if (val) *val = (unsigned long)(d);
3109         return res;
3110       }
3111     }
3112   }
3113 #endif
3114   return SWIG_TypeError;
3115 }
3116
3117
3118 SWIGINTERNINLINE int
3119 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3120 {
3121   unsigned long v;
3122   int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3123   if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3124   return res;
3125 }
3126
3127
3128   #define SWIG_From_long   PyInt_FromLong
3129
3130
3131 SWIGINTERNINLINE PyObject *
3132 SWIG_From_ptrdiff_t  (ptrdiff_t value)
3133 {
3134   return SWIG_From_long  (static_cast< long >(value));
3135 }
3136
3137
3138 SWIGINTERNINLINE PyObject*
3139   SWIG_From_bool  (bool value)
3140 {
3141   return PyBool_FromLong(value ? 1 : 0);
3142 }
3143
3144
3145 SWIGINTERN int
3146 SWIG_AsVal_long (PyObject *obj, long* val)
3147 {
3148   if (PyInt_Check(obj)) {
3149     if (val) *val = PyInt_AsLong(obj);
3150     return SWIG_OK;
3151   } else if (PyLong_Check(obj)) {
3152     long v = PyLong_AsLong(obj);
3153     if (!PyErr_Occurred()) {
3154       if (val) *val = v;
3155       return SWIG_OK;
3156     } else {
3157       PyErr_Clear();
3158     }
3159   }
3160 #ifdef SWIG_PYTHON_CAST_MODE
3161   {
3162     int dispatch = 0;
3163     long v = PyInt_AsLong(obj);
3164     if (!PyErr_Occurred()) {
3165       if (val) *val = v;
3166       return SWIG_AddCast(SWIG_OK);
3167     } else {
3168       PyErr_Clear();
3169     }
3170     if (!dispatch) {
3171       double d;
3172       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3173       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3174         if (val) *val = (long)(d);
3175         return res;
3176       }
3177     }
3178   }
3179 #endif
3180   return SWIG_TypeError;
3181 }
3182
3183
3184 SWIGINTERNINLINE int
3185 SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
3186 {
3187   long v;
3188   int res = SWIG_AsVal_long (obj, val ? &v : 0);
3189   if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
3190   return res;
3191 }
3192
3193
3194 #include <stdexcept>
3195
3196
3197 #include <algorithm>
3198
3199
3200 #include <vector>
3201
3202
3203 namespace swig {
3204   template <class Type>
3205   struct noconst_traits {
3206     typedef Type noconst_type;
3207   };
3208
3209   template <class Type>
3210   struct noconst_traits<const Type> {
3211     typedef Type noconst_type;
3212   };
3213
3214   /*
3215     type categories
3216   */
3217   struct pointer_category { };
3218   struct value_category { };
3219
3220   /*
3221     General traits that provides type_name and type_info
3222   */
3223   template <class Type> struct traits { };
3224
3225   template <class Type>
3226   inline const char* type_name() {
3227     return traits<typename noconst_traits<Type >::noconst_type >::type_name();
3228   }
3229
3230   template <class Type>
3231   struct traits_info {
3232     static swig_type_info *type_query(std::string name) {
3233       name += " *";
3234       return SWIG_TypeQuery(name.c_str());
3235     }
3236     static swig_type_info *type_info() {
3237       static swig_type_info *info = type_query(type_name<Type>());
3238       return info;
3239     }
3240   };
3241
3242   template <class Type>
3243   inline swig_type_info *type_info() {
3244     return traits_info<Type>::type_info();
3245   }
3246
3247   /*
3248     Partial specialization for pointers
3249   */
3250   template <class Type> struct traits <Type *> {
3251     typedef pointer_category category;
3252     static std::string make_ptr_name(const char* name) {
3253       std::string ptrname = name;
3254       ptrname += " *";
3255       return ptrname;
3256     }
3257     static const char* type_name() {
3258       static std::string name = make_ptr_name(swig::type_name<Type>());
3259       return name.c_str();
3260     }
3261   };
3262
3263   template <class Type, class Category>
3264   struct traits_as { };
3265
3266   template <class Type, class Category>
3267   struct traits_check { };
3268
3269 }
3270
3271
3272 namespace swig {
3273   /*
3274     Traits that provides the from method
3275   */
3276   template <class Type> struct traits_from_ptr {
3277     static PyObject *from(Type *val, int owner = 0) {
3278       return SWIG_NewPointerObj(val, type_info<Type>(), owner);
3279     }
3280   };
3281
3282   template <class Type> struct traits_from {
3283     static PyObject *from(const Type& val) {
3284       return traits_from_ptr<Type>::from(new Type(val), 1);
3285     }
3286   };
3287
3288   template <class Type> struct traits_from<Type *> {
3289     static PyObject *from(Type* val) {
3290       return traits_from_ptr<Type>::from(val, 0);
3291     }
3292   };
3293
3294   template <class Type> struct traits_from<const Type *> {
3295     static PyObject *from(const Type* val) {
3296       return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
3297     }
3298   };
3299
3300
3301   template <class Type>
3302   inline PyObject *from(const Type& val) {
3303     return traits_from<Type>::from(val);
3304   }
3305
3306   template <class Type>
3307   inline PyObject *from_ptr(Type* val, int owner) {
3308     return traits_from_ptr<Type>::from(val, owner);
3309   }
3310
3311   /*
3312     Traits that provides the asval/as/check method
3313   */
3314   template <class Type>
3315   struct traits_asptr {
3316     static int asptr(PyObject *obj, Type **val) {
3317       Type *p;
3318       int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
3319       if (SWIG_IsOK(res)) {
3320         if (val) *val = p;
3321       }
3322       return res;
3323     }
3324   };
3325
3326   template <class Type>
3327   inline int asptr(PyObject *obj, Type **vptr) {
3328     return traits_asptr<Type>::asptr(obj, vptr);
3329   }
3330
3331   template <class Type>
3332   struct traits_asval {
3333     static int asval(PyObject *obj, Type *val) {
3334       if (val) {
3335         Type *p = 0;
3336         int res = traits_asptr<Type>::asptr(obj, &p);
3337         if (!SWIG_IsOK(res)) return res;
3338         if (p) {
3339           typedef typename noconst_traits<Type>::noconst_type noconst_type;
3340           *(const_cast<noconst_type*>(val)) = *p;
3341           if (SWIG_IsNewObj(res)){
3342             delete p;
3343             res = SWIG_DelNewMask(res);
3344           }
3345           return res;
3346         } else {
3347           return SWIG_ERROR;
3348         }
3349       } else {
3350         return traits_asptr<Type>::asptr(obj, (Type **)(0));
3351       }
3352     }
3353   };
3354
3355   template <class Type> struct traits_asval<Type*> {
3356     static int asval(PyObject *obj, Type **val) {
3357       if (val) {
3358         typedef typename noconst_traits<Type>::noconst_type noconst_type;
3359         noconst_type *p = 0;
3360         int res = traits_asptr<noconst_type>::asptr(obj,  &p);
3361         if (SWIG_IsOK(res)) {
3362           *(const_cast<noconst_type**>(val)) = p;
3363         }
3364         return res;
3365       } else {
3366         return traits_asptr<Type>::asptr(obj, (Type **)(0));
3367       }
3368     }
3369   };
3370
3371   template <class Type>
3372   inline int asval(PyObject *obj, Type *val) {
3373     return traits_asval<Type>::asval(obj, val);
3374   }
3375
3376   template <class Type>
3377   struct traits_as<Type, value_category> {
3378     static Type as(PyObject *obj, bool throw_error) {
3379       Type v;
3380       int res = asval(obj, &v);
3381       if (!obj || !SWIG_IsOK(res)) {
3382         if (!PyErr_Occurred()) {
3383           ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3384         }
3385         if (throw_error) throw std::invalid_argument("bad type");
3386       }
3387       return v;
3388     }
3389   };
3390
3391   template <class Type>
3392   struct traits_as<Type, pointer_category> {
3393     static Type as(PyObject *obj, bool throw_error) {
3394       Type *v = 0;
3395       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3396       if (SWIG_IsOK(res) && v) {
3397         if (SWIG_IsNewObj(res)) {
3398           Type r(*v);
3399           delete v;
3400           return r;
3401         } else {
3402           return *v;
3403         }
3404       } else {
3405         // Uninitialized return value, no Type() constructor required.
3406         static Type *v_def = (Type*) malloc(sizeof(Type));
3407         if (!PyErr_Occurred()) {
3408           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3409         }
3410         if (throw_error) throw std::invalid_argument("bad type");
3411         memset(v_def,0,sizeof(Type));
3412         return *v_def;
3413       }
3414     }
3415   };
3416
3417   template <class Type>
3418   struct traits_as<Type*, pointer_category> {
3419     static Type* as(PyObject *obj, bool throw_error) {
3420       Type *v = 0;
3421       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3422       if (SWIG_IsOK(res)) {
3423         return v;
3424       } else {
3425         if (!PyErr_Occurred()) {
3426           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3427         }
3428         if (throw_error) throw std::invalid_argument("bad type");
3429         return 0;
3430       }
3431     }
3432   };
3433
3434   template <class Type>
3435   inline Type as(PyObject *obj, bool te = false) {
3436     return traits_as<Type, typename traits<Type>::category>::as(obj, te);
3437   }
3438
3439   template <class Type>
3440   struct traits_check<Type, value_category> {
3441     static bool check(PyObject *obj) {
3442       int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
3443       return SWIG_IsOK(res) ? true : false;
3444     }
3445   };
3446
3447   template <class Type>
3448   struct traits_check<Type, pointer_category> {
3449     static bool check(PyObject *obj) {
3450       int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
3451       return SWIG_IsOK(res) ? true : false;
3452     }
3453   };
3454
3455   template <class Type>
3456   inline bool check(PyObject *obj) {
3457     return traits_check<Type, typename traits<Type>::category>::check(obj);
3458   }
3459 }
3460
3461
3462 #include <functional>
3463
3464 namespace std {
3465   template <>
3466   struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
3467   {
3468     bool
3469     operator()(PyObject * v, PyObject *w) const
3470     {
3471       bool res;
3472       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3473       res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
3474       /* This may fall into a case of inconsistent
3475                eg. ObjA > ObjX > ObjB
3476                but ObjA < ObjB
3477       */
3478       if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
3479       {
3480         /* Objects can't be compared, this mostly occurred in Python 3.0 */
3481         /* Compare their ptr directly for a workaround */
3482         res = (v < w);
3483         PyErr_Clear();
3484       }
3485       SWIG_PYTHON_THREAD_END_BLOCK;
3486       return res;
3487     }
3488   };
3489
3490   template <>
3491   struct less <swig::SwigPtr_PyObject>: public binary_function<swig::SwigPtr_PyObject, swig::SwigPtr_PyObject, bool>
3492   {
3493     bool
3494     operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
3495     {
3496       return std::less<PyObject *>()(v, w);
3497     }
3498   };
3499
3500   template <>
3501   struct less <swig::SwigVar_PyObject>: public binary_function<swig::SwigVar_PyObject, swig::SwigVar_PyObject, bool>
3502   {
3503     bool
3504     operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
3505     {
3506       return std::less<PyObject *>()(v, w);
3507     }
3508   };
3509
3510 }
3511
3512 namespace swig {
3513   template <> struct traits<PyObject *> {
3514     typedef value_category category;
3515     static const char* type_name() { return "PyObject *"; }
3516   };
3517
3518   template <>  struct traits_asval<PyObject * > {
3519     typedef PyObject * value_type;
3520     static int asval(PyObject *obj, value_type *val) {
3521       if (val) *val = obj;
3522       return SWIG_OK;
3523     }
3524   };
3525
3526   template <>
3527   struct traits_check<PyObject *, value_category> {
3528     static bool check(PyObject *) {
3529       return true;
3530     }
3531   };
3532
3533   template <>  struct traits_from<PyObject *> {
3534     typedef PyObject * value_type;
3535     static PyObject *from(const value_type& val) {
3536       Py_XINCREF(val);
3537       return val;
3538     }
3539   };
3540
3541 }
3542
3543 namespace swig {
3544   inline size_t
3545   check_index(ptrdiff_t i, size_t size, bool insert = false) {
3546     if ( i < 0 ) {
3547       if ((size_t) (-i) <= size)
3548         return (size_t) (i + size);
3549     } else if ( (size_t) i < size ) {
3550       return (size_t) i;
3551     } else if (insert && ((size_t) i == size)) {
3552       return size;
3553     }
3554
3555     throw std::out_of_range("index out of range");
3556   }
3557
3558   inline size_t
3559   slice_index(ptrdiff_t i, size_t size) {
3560     if ( i < 0 ) {
3561       if ((size_t) (-i) <= size) {
3562         return (size_t) (i + size);
3563       } else {
3564         throw std::out_of_range("index out of range");
3565       }
3566     } else {
3567       return ( (size_t) i < size ) ? ((size_t) i) : size;
3568     }
3569   }
3570
3571   template <class Sequence, class Difference>
3572   inline typename Sequence::iterator
3573   getpos(Sequence* self, Difference i)  {
3574     typename Sequence::iterator pos = self->begin();
3575     std::advance(pos, check_index(i,self->size()));
3576     return pos;
3577   }
3578
3579   template <class Sequence, class Difference>
3580   inline typename Sequence::const_iterator
3581   cgetpos(const Sequence* self, Difference i)  {
3582     typename Sequence::const_iterator pos = self->begin();
3583     std::advance(pos, check_index(i,self->size()));
3584     return pos;
3585   }
3586
3587   template <class Sequence, class Difference>
3588   inline Sequence*
3589   getslice(const Sequence* self, Difference i, Difference j) {
3590     typename Sequence::size_type size = self->size();
3591     typename Sequence::size_type ii = swig::check_index(i, size);
3592     typename Sequence::size_type jj = swig::slice_index(j, size);
3593
3594     if (jj > ii) {
3595       typename Sequence::const_iterator vb = self->begin();
3596       typename Sequence::const_iterator ve = self->begin();
3597       std::advance(vb,ii);
3598       std::advance(ve,jj);
3599       return new Sequence(vb, ve);
3600     } else {
3601       return new Sequence();
3602     }
3603   }
3604
3605   template <class Sequence, class Difference, class InputSeq>
3606   inline void
3607   setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
3608     typename Sequence::size_type size = self->size();
3609     typename Sequence::size_type ii = swig::check_index(i, size, true);
3610     typename Sequence::size_type jj = swig::slice_index(j, size);
3611     if (jj < ii) jj = ii;
3612     size_t ssize = jj - ii;
3613     if (ssize <= v.size()) {
3614       typename Sequence::iterator sb = self->begin();
3615       typename InputSeq::const_iterator vmid = v.begin();
3616       std::advance(sb,ii);
3617       std::advance(vmid, jj - ii);
3618       self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
3619     } else {
3620       typename Sequence::iterator sb = self->begin();
3621       typename Sequence::iterator se = self->begin();
3622       std::advance(sb,ii);
3623       std::advance(se,jj);
3624       self->erase(sb,se);
3625       self->insert(sb, v.begin(), v.end());
3626     }
3627   }
3628
3629   template <class Sequence, class Difference>
3630   inline void
3631   delslice(Sequence* self, Difference i, Difference j) {
3632     typename Sequence::size_type size = self->size();
3633     typename Sequence::size_type ii = swig::check_index(i, size, true);
3634     typename Sequence::size_type jj = swig::slice_index(j, size);
3635     if (jj > ii) {
3636       typename Sequence::iterator sb = self->begin();
3637       typename Sequence::iterator se = self->begin();
3638       std::advance(sb,ii);
3639       std::advance(se,jj);
3640       self->erase(sb,se);
3641     }
3642   }
3643 }
3644
3645
3646 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
3647 #  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
3648 #    define SWIG_STD_NOITERATOR_TRAITS_STL
3649 #  endif
3650 #endif
3651
3652 #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
3653 #include <iterator>
3654 #else
3655 namespace std {
3656   template <class Iterator>
3657   struct iterator_traits {
3658     typedef ptrdiff_t difference_type;
3659     typedef typename Iterator::value_type value_type;
3660   };
3661
3662   template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
3663   struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
3664     typedef Distance difference_type;
3665     typedef T value_type;
3666   };
3667
3668   template <class T>
3669   struct iterator_traits<T*> {
3670     typedef T value_type;
3671     typedef ptrdiff_t difference_type;
3672   };
3673
3674   template<typename _InputIterator>
3675   inline typename iterator_traits<_InputIterator>::difference_type
3676   distance(_InputIterator __first, _InputIterator __last)
3677   {
3678     typename iterator_traits<_InputIterator>::difference_type __n = 0;
3679     while (__first != __last) {
3680       ++__first; ++__n;
3681     }
3682     return __n;
3683   }
3684 }
3685 #endif
3686
3687
3688 namespace swig {
3689   template<typename OutIterator>
3690   class SwigPyIterator_T :  public SwigPyIterator
3691   {
3692   public:
3693     typedef OutIterator out_iterator;
3694     typedef typename std::iterator_traits<out_iterator>::value_type value_type;
3695     typedef SwigPyIterator_T<out_iterator> self_type;
3696
3697     SwigPyIterator_T(out_iterator curr, PyObject *seq)
3698       : SwigPyIterator(seq), current(curr)
3699     {
3700     }
3701
3702     const out_iterator& get_current() const
3703     {
3704       return current;
3705     }
3706
3707
3708     bool equal (const SwigPyIterator &iter) const
3709     {
3710       const self_type *iters = dynamic_cast<const self_type *>(&iter);
3711       if (iters) {
3712         return (current == iters->get_current());
3713       } else {
3714         throw std::invalid_argument("bad iterator type");
3715       }
3716     }
3717
3718     ptrdiff_t distance(const SwigPyIterator &iter) const
3719     {
3720       const self_type *iters = dynamic_cast<const self_type *>(&iter);
3721       if (iters) {
3722         return std::distance(current, iters->get_current());
3723       } else {
3724         throw std::invalid_argument("bad iterator type");
3725       }
3726     }
3727
3728   protected:
3729     out_iterator current;
3730   };
3731
3732   template <class ValueType>
3733   struct from_oper
3734   {
3735     typedef const ValueType& argument_type;
3736     typedef PyObject *result_type;
3737     result_type operator()(argument_type v) const
3738     {
3739       return swig::from(v);
3740     }
3741   };
3742
3743   template<typename OutIterator,
3744            typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3745            typename FromOper = from_oper<ValueType> >
3746   class SwigPyIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
3747   {
3748   public:
3749     FromOper from;
3750     typedef OutIterator out_iterator;
3751     typedef ValueType value_type;
3752     typedef SwigPyIterator_T<out_iterator>  base;
3753     typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
3754
3755     SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
3756       : SwigPyIterator_T<OutIterator>(curr, seq)
3757     {
3758     }
3759
3760     PyObject *value() const {
3761       return from(static_cast<const value_type&>(*(base::current)));
3762     }
3763
3764     SwigPyIterator *copy() const
3765     {
3766       return new self_type(*this);
3767     }
3768
3769     SwigPyIterator *incr(size_t n = 1)
3770     {
3771       while (n--) {
3772         ++base::current;
3773       }
3774       return this;
3775     }
3776
3777     SwigPyIterator *decr(size_t n = 1)
3778     {
3779       while (n--) {
3780         --base::current;
3781       }
3782       return this;
3783     }
3784   };
3785
3786   template<typename OutIterator,
3787            typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3788            typename FromOper = from_oper<ValueType> >
3789   class SwigPyIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
3790   {
3791   public:
3792     FromOper from;
3793     typedef OutIterator out_iterator;
3794     typedef ValueType value_type;
3795     typedef SwigPyIterator_T<out_iterator>  base;
3796     typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
3797
3798     SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
3799       : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
3800     {
3801     }
3802
3803     PyObject *value() const {
3804       if (base::current == end) {
3805         throw stop_iteration();
3806       } else {
3807         return from(static_cast<const value_type&>(*(base::current)));
3808       }
3809     }
3810
3811     SwigPyIterator *copy() const
3812     {
3813       return new self_type(*this);
3814     }
3815
3816     SwigPyIterator *incr(size_t n = 1)
3817     {
3818       while (n--) {
3819         if (base::current == end) {
3820           throw stop_iteration();
3821         } else {
3822           ++base::current;
3823         }
3824       }
3825       return this;
3826     }
3827
3828     SwigPyIterator *decr(size_t n = 1)
3829     {
3830       while (n--) {
3831         if (base::current == begin) {
3832           throw stop_iteration();
3833         } else {
3834           --base::current;
3835         }
3836       }
3837       return this;
3838     }
3839
3840   private:
3841     out_iterator begin;
3842     out_iterator end;
3843   };
3844
3845   template<typename OutIter>
3846   inline SwigPyIterator*
3847   make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
3848   {
3849     return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
3850   }
3851
3852   template<typename OutIter>
3853   inline SwigPyIterator*
3854   make_output_iterator(const OutIter& current, PyObject *seq = 0)
3855   {
3856     return new SwigPyIteratorOpen_T<OutIter>(current, seq);
3857   }
3858 }
3859
3860
3861 namespace swig
3862 {
3863   template <class T>
3864   struct SwigPySequence_Ref
3865   {
3866     SwigPySequence_Ref(PyObject* seq, int index)
3867       : _seq(seq), _index(index)
3868     {
3869     }
3870
3871     operator T () const
3872     {
3873       swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
3874       try {
3875         return swig::as<T>(item, true);
3876       } catch (std::exception& e) {
3877         char msg[1024];
3878         sprintf(msg, "in sequence element %d ", _index);
3879         if (!PyErr_Occurred()) {
3880           ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
3881         }
3882         SWIG_Python_AddErrorMsg(msg);
3883         SWIG_Python_AddErrorMsg(e.what());
3884         throw;
3885       }
3886     }
3887
3888     SwigPySequence_Ref& operator=(const T& v)
3889     {
3890       PySequence_SetItem(_seq, _index, swig::from<T>(v));
3891       return *this;
3892     }
3893
3894   private:
3895     PyObject* _seq;
3896     int _index;
3897   };
3898
3899   template <class T>
3900   struct SwigPySequence_ArrowProxy
3901   {
3902     SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
3903     const T* operator->() const { return &m_value; }
3904     operator const T*() const { return &m_value; }
3905     T m_value;
3906   };
3907
3908   template <class T, class Reference >
3909   struct SwigPySequence_InputIterator
3910   {
3911     typedef SwigPySequence_InputIterator<T, Reference > self;
3912
3913     typedef std::random_access_iterator_tag iterator_category;
3914     typedef Reference reference;
3915     typedef T value_type;
3916     typedef T* pointer;
3917     typedef int difference_type;
3918
3919     SwigPySequence_InputIterator()
3920     {
3921     }
3922
3923     SwigPySequence_InputIterator(PyObject* seq, int index)
3924       : _seq(seq), _index(index)
3925     {
3926     }
3927
3928     reference operator*() const
3929     {
3930       return reference(_seq, _index);
3931     }
3932
3933     SwigPySequence_ArrowProxy<T>
3934     operator->() const {
3935       return SwigPySequence_ArrowProxy<T>(operator*());
3936     }
3937
3938     bool operator==(const self& ri) const
3939     {
3940       return (_index == ri._index) && (_seq == ri._seq);
3941     }
3942
3943     bool operator!=(const self& ri) const
3944     {
3945       return !(operator==(ri));
3946     }
3947
3948     self& operator ++ ()
3949     {
3950       ++_index;
3951       return *this;
3952     }
3953
3954     self& operator -- ()
3955     {
3956       --_index;
3957       return *this;
3958     }
3959
3960     self& operator += (difference_type n)
3961     {
3962       _index += n;
3963       return *this;
3964     }
3965
3966     self operator +(difference_type n) const
3967     {
3968       return self(_seq, _index + n);
3969     }
3970
3971     self& operator -= (difference_type n)
3972     {
3973       _index -= n;
3974       return *this;
3975     }
3976
3977     self operator -(difference_type n) const
3978     {
3979       return self(_seq, _index - n);
3980     }
3981
3982     difference_type operator - (const self& ri) const
3983     {
3984       return _index - ri._index;
3985     }
3986
3987     bool operator < (const self& ri) const
3988     {
3989       return _index < ri._index;
3990     }
3991
3992     reference
3993     operator[](difference_type n) const
3994     {
3995       return reference(_seq, _index + n);
3996     }
3997
3998   private:
3999     PyObject* _seq;
4000     difference_type _index;
4001   };
4002
4003   template <class T>
4004   struct SwigPySequence_Cont
4005   {
4006     typedef SwigPySequence_Ref<T> reference;
4007     typedef const SwigPySequence_Ref<T> const_reference;
4008     typedef T value_type;
4009     typedef T* pointer;
4010     typedef int difference_type;
4011     typedef int size_type;
4012     typedef const pointer const_pointer;
4013     typedef SwigPySequence_InputIterator<T, reference> iterator;
4014     typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
4015
4016     SwigPySequence_Cont(PyObject* seq) : _seq(0)
4017     {
4018       if (!PySequence_Check(seq)) {
4019         throw std::invalid_argument("a sequence is expected");
4020       }
4021       _seq = seq;
4022       Py_INCREF(_seq);
4023     }
4024
4025     ~SwigPySequence_Cont()
4026     {
4027       Py_XDECREF(_seq);
4028     }
4029
4030     size_type size() const
4031     {
4032       return static_cast<size_type>(PySequence_Size(_seq));
4033     }
4034
4035     bool empty() const
4036     {
4037       return size() == 0;
4038     }
4039
4040     iterator begin()
4041     {
4042       return iterator(_seq, 0);
4043     }
4044
4045     const_iterator begin() const
4046     {
4047       return const_iterator(_seq, 0);
4048     }
4049
4050     iterator end()
4051     {
4052       return iterator(_seq, size());
4053     }
4054
4055     const_iterator end() const
4056     {
4057       return const_iterator(_seq, size());
4058     }
4059
4060     reference operator[](difference_type n)
4061     {
4062       return reference(_seq, n);
4063     }
4064
4065     const_reference operator[](difference_type n)  const
4066     {
4067       return const_reference(_seq, n);
4068     }
4069
4070     bool check(bool set_err = true) const
4071     {
4072       int s = size();
4073       for (int i = 0; i < s; ++i) {
4074         swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
4075         if (!swig::check<value_type>(item)) {
4076           if (set_err) {
4077             char msg[1024];
4078             sprintf(msg, "in sequence element %d", i);
4079             SWIG_Error(SWIG_RuntimeError, msg);
4080           }
4081           return false;
4082         }
4083       }
4084       return true;
4085     }
4086
4087   private:
4088     PyObject* _seq;
4089   };
4090
4091 }
4092
4093
4094   namespace swig {
4095     template <>  struct traits<Hex::Hexa > {
4096       typedef pointer_category category;
4097       static const char* type_name() { return"Hex::Hexa"; }
4098     };
4099   }
4100
4101
4102 namespace swig {
4103   template <class SwigPySeq, class Seq>
4104   inline void
4105   assign(const SwigPySeq& swigpyseq, Seq* seq) {
4106     // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
4107     typedef typename SwigPySeq::value_type value_type;
4108     typename SwigPySeq::const_iterator it = swigpyseq.begin();
4109     for (;it != swigpyseq.end(); ++it) {
4110       seq->insert(seq->end(),(value_type)(*it));
4111     }
4112   }
4113
4114   template <class Seq, class T = typename Seq::value_type >
4115   struct traits_asptr_stdseq {
4116     typedef Seq sequence;
4117     typedef T value_type;
4118
4119     static int asptr(PyObject *obj, sequence **seq) {
4120       if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
4121         sequence *p;
4122         if (::SWIG_ConvertPtr(obj,(void**)&p,
4123                               swig::type_info<sequence>(),0) == SWIG_OK) {
4124           if (seq) *seq = p;
4125           return SWIG_OLDOBJ;
4126         }
4127       } else if (PySequence_Check(obj)) {
4128         try {
4129           SwigPySequence_Cont<value_type> swigpyseq(obj);
4130           if (seq) {
4131             sequence *pseq = new sequence();
4132             assign(swigpyseq, pseq);
4133             *seq = pseq;
4134             return SWIG_NEWOBJ;
4135           } else {
4136             return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
4137           }
4138         } catch (std::exception& e) {
4139           if (seq) {
4140             if (!PyErr_Occurred()) {
4141               PyErr_SetString(PyExc_TypeError, e.what());
4142             }
4143           }
4144           return SWIG_ERROR;
4145         }
4146       }
4147       return SWIG_ERROR;
4148     }
4149   };
4150
4151   template <class Seq, class T = typename Seq::value_type >
4152   struct traits_from_stdseq {
4153     typedef Seq sequence;
4154     typedef T value_type;
4155     typedef typename Seq::size_type size_type;
4156     typedef typename sequence::const_iterator const_iterator;
4157
4158     static PyObject *from(const sequence& seq) {
4159 #ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
4160       swig_type_info *desc = swig::type_info<sequence>();
4161       if (desc && desc->clientdata) {
4162         return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
4163       }
4164 #endif
4165       size_type size = seq.size();
4166       if (size <= (size_type)INT_MAX) {
4167         PyObject *obj = PyTuple_New((int)size);
4168         int i = 0;
4169         for (const_iterator it = seq.begin();
4170              it != seq.end(); ++it, ++i) {
4171           PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
4172         }
4173         return obj;
4174       } else {
4175         PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
4176         return NULL;
4177       }
4178     }
4179   };
4180 }
4181
4182
4183   namespace swig {
4184     template <class T>
4185     struct traits_asptr<std::vector<T> >  {
4186       static int asptr(PyObject *obj, std::vector<T> **vec) {
4187         return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
4188       }
4189     };
4190
4191     template <class T>
4192     struct traits_from<std::vector<T> > {
4193       static PyObject *from(const std::vector<T>& vec) {
4194         return traits_from_stdseq<std::vector<T> >::from(vec);
4195       }
4196     };
4197   }
4198
4199
4200       namespace swig {
4201         template <>  struct traits<std::vector<Hex::Hexa*, std::allocator< Hex::Hexa * > > > {
4202           typedef value_category category;
4203           static const char* type_name() {
4204             return "std::vector<" "Hex::Hexa" " *," "std::allocator< Hex::Hexa * >" " >";
4205           }
4206         };
4207       }
4208
4209 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(std::vector< Hex::Hexa * > *self,PyObject **PYTHON_SELF){
4210       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4211     }
4212 SWIGINTERN bool std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__(std::vector< Hex::Hexa * > const *self){
4213       return !(self->empty());
4214     }
4215 SWIGINTERN bool std_vector_Sl_Hex_Hexa_Sm__Sg____bool__(std::vector< Hex::Hexa * > const *self){
4216       return !(self->empty());
4217     }
4218 SWIGINTERN std::vector< Hex::Hexa * >::size_type std_vector_Sl_Hex_Hexa_Sm__Sg____len__(std::vector< Hex::Hexa * > const *self){
4219       return self->size();
4220     }
4221
4222 SWIGINTERNINLINE PyObject*
4223 SWIG_From_unsigned_SS_long  (unsigned long value)
4224 {
4225   return (value > LONG_MAX) ?
4226     PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
4227 }
4228
4229
4230 SWIGINTERNINLINE PyObject *
4231 SWIG_From_size_t  (size_t value)
4232 {
4233   return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
4234 }
4235
4236 SWIGINTERN std::vector< Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg__pop(std::vector< Hex::Hexa * > *self){
4237       if (self->size() == 0)
4238         throw std::out_of_range("pop from empty container");
4239       std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >::value_type x = self->back();
4240       self->pop_back();
4241       return x;
4242     }
4243 SWIGINTERN std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *std_vector_Sl_Hex_Hexa_Sm__Sg____getslice__(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i,std::vector< Hex::Hexa * >::difference_type j){
4244       return swig::getslice(self, i, j);
4245     }
4246 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setslice__(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i,std::vector< Hex::Hexa * >::difference_type j,std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &v){
4247       swig::setslice(self, i, j, v);
4248     }
4249 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delslice__(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i,std::vector< Hex::Hexa * >::difference_type j){
4250       swig::delslice(self, i, j);
4251     }
4252 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i){
4253       self->erase(swig::getpos(self,i));
4254     }
4255 SWIGINTERN std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Hexa * > *self,PySliceObject *slice){
4256       Py_ssize_t i, j, step;
4257       if( !PySlice_Check(slice) ) {
4258         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4259         return NULL;
4260       }
4261       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4262       return swig::getslice(self, i, j);
4263     }
4264 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Hexa * > *self,PySliceObject *slice,std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &v){
4265       Py_ssize_t i, j, step;
4266       if( !PySlice_Check(slice) ) {
4267         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4268         return;
4269       }
4270       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4271       swig::setslice(self, i, j, v);
4272     }
4273 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Hexa * > *self,PySliceObject *slice){
4274       Py_ssize_t i, j, step;
4275       if( !PySlice_Check(slice) ) {
4276         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4277         return;
4278       }
4279       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4280       swig::delslice(self, i,j);
4281     }
4282 SWIGINTERN std::vector< Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i){
4283       return *(swig::cgetpos(self, i));
4284     }
4285 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i,std::vector< Hex::Hexa * >::value_type x){
4286       *(swig::getpos(self,i)) = x;
4287     }
4288 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg__append(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::value_type x){
4289       self->push_back(x);
4290     }
4291
4292   namespace swig {
4293     template <>  struct traits<Hex::Quad > {
4294       typedef pointer_category category;
4295       static const char* type_name() { return"Hex::Quad"; }
4296     };
4297   }
4298
4299
4300       namespace swig {
4301         template <>  struct traits<std::vector<Hex::Quad*, std::allocator< Hex::Quad * > > > {
4302           typedef value_category category;
4303           static const char* type_name() {
4304             return "std::vector<" "Hex::Quad" " *," "std::allocator< Hex::Quad * >" " >";
4305           }
4306         };
4307       }
4308
4309 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Quad_Sm__Sg__iterator(std::vector< Hex::Quad * > *self,PyObject **PYTHON_SELF){
4310       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4311     }
4312 SWIGINTERN bool std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__(std::vector< Hex::Quad * > const *self){
4313       return !(self->empty());
4314     }
4315 SWIGINTERN bool std_vector_Sl_Hex_Quad_Sm__Sg____bool__(std::vector< Hex::Quad * > const *self){
4316       return !(self->empty());
4317     }
4318 SWIGINTERN std::vector< Hex::Quad * >::size_type std_vector_Sl_Hex_Quad_Sm__Sg____len__(std::vector< Hex::Quad * > const *self){
4319       return self->size();
4320     }
4321 SWIGINTERN std::vector< Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg__pop(std::vector< Hex::Quad * > *self){
4322       if (self->size() == 0)
4323         throw std::out_of_range("pop from empty container");
4324       std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >::value_type x = self->back();
4325       self->pop_back();
4326       return x;
4327     }
4328 SWIGINTERN std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *std_vector_Sl_Hex_Quad_Sm__Sg____getslice__(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i,std::vector< Hex::Quad * >::difference_type j){
4329       return swig::getslice(self, i, j);
4330     }
4331 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setslice__(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i,std::vector< Hex::Quad * >::difference_type j,std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &v){
4332       swig::setslice(self, i, j, v);
4333     }
4334 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delslice__(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i,std::vector< Hex::Quad * >::difference_type j){
4335       swig::delslice(self, i, j);
4336     }
4337 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i){
4338       self->erase(swig::getpos(self,i));
4339     }
4340 SWIGINTERN std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Quad * > *self,PySliceObject *slice){
4341       Py_ssize_t i, j, step;
4342       if( !PySlice_Check(slice) ) {
4343         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4344         return NULL;
4345       }
4346       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4347       return swig::getslice(self, i, j);
4348     }
4349 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Quad * > *self,PySliceObject *slice,std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &v){
4350       Py_ssize_t i, j, step;
4351       if( !PySlice_Check(slice) ) {
4352         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4353         return;
4354       }
4355       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4356       swig::setslice(self, i, j, v);
4357     }
4358 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Quad * > *self,PySliceObject *slice){
4359       Py_ssize_t i, j, step;
4360       if( !PySlice_Check(slice) ) {
4361         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4362         return;
4363       }
4364       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4365       swig::delslice(self, i,j);
4366     }
4367 SWIGINTERN std::vector< Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i){
4368       return *(swig::cgetpos(self, i));
4369     }
4370 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i,std::vector< Hex::Quad * >::value_type x){
4371       *(swig::getpos(self,i)) = x;
4372     }
4373 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg__append(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::value_type x){
4374       self->push_back(x);
4375     }
4376
4377   namespace swig {
4378     template <>  struct traits<Hex::Edge > {
4379       typedef pointer_category category;
4380       static const char* type_name() { return"Hex::Edge"; }
4381     };
4382   }
4383
4384
4385       namespace swig {
4386         template <>  struct traits<std::vector<Hex::Edge*, std::allocator< Hex::Edge * > > > {
4387           typedef value_category category;
4388           static const char* type_name() {
4389             return "std::vector<" "Hex::Edge" " *," "std::allocator< Hex::Edge * >" " >";
4390           }
4391         };
4392       }
4393
4394 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Edge_Sm__Sg__iterator(std::vector< Hex::Edge * > *self,PyObject **PYTHON_SELF){
4395       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4396     }
4397 SWIGINTERN bool std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__(std::vector< Hex::Edge * > const *self){
4398       return !(self->empty());
4399     }
4400 SWIGINTERN bool std_vector_Sl_Hex_Edge_Sm__Sg____bool__(std::vector< Hex::Edge * > const *self){
4401       return !(self->empty());
4402     }
4403 SWIGINTERN std::vector< Hex::Edge * >::size_type std_vector_Sl_Hex_Edge_Sm__Sg____len__(std::vector< Hex::Edge * > const *self){
4404       return self->size();
4405     }
4406 SWIGINTERN std::vector< Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg__pop(std::vector< Hex::Edge * > *self){
4407       if (self->size() == 0)
4408         throw std::out_of_range("pop from empty container");
4409       std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >::value_type x = self->back();
4410       self->pop_back();
4411       return x;
4412     }
4413 SWIGINTERN std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *std_vector_Sl_Hex_Edge_Sm__Sg____getslice__(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i,std::vector< Hex::Edge * >::difference_type j){
4414       return swig::getslice(self, i, j);
4415     }
4416 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setslice__(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i,std::vector< Hex::Edge * >::difference_type j,std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &v){
4417       swig::setslice(self, i, j, v);
4418     }
4419 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delslice__(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i,std::vector< Hex::Edge * >::difference_type j){
4420       swig::delslice(self, i, j);
4421     }
4422 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i){
4423       self->erase(swig::getpos(self,i));
4424     }
4425 SWIGINTERN std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Edge * > *self,PySliceObject *slice){
4426       Py_ssize_t i, j, step;
4427       if( !PySlice_Check(slice) ) {
4428         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4429         return NULL;
4430       }
4431       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4432       return swig::getslice(self, i, j);
4433     }
4434 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Edge * > *self,PySliceObject *slice,std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &v){
4435       Py_ssize_t i, j, step;
4436       if( !PySlice_Check(slice) ) {
4437         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4438         return;
4439       }
4440       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4441       swig::setslice(self, i, j, v);
4442     }
4443 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Edge * > *self,PySliceObject *slice){
4444       Py_ssize_t i, j, step;
4445       if( !PySlice_Check(slice) ) {
4446         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4447         return;
4448       }
4449       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4450       swig::delslice(self, i,j);
4451     }
4452 SWIGINTERN std::vector< Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i){
4453       return *(swig::cgetpos(self, i));
4454     }
4455 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i,std::vector< Hex::Edge * >::value_type x){
4456       *(swig::getpos(self,i)) = x;
4457     }
4458 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg__append(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::value_type x){
4459       self->push_back(x);
4460     }
4461
4462   namespace swig {
4463     template <>  struct traits<Hex::Vertex > {
4464       typedef pointer_category category;
4465       static const char* type_name() { return"Hex::Vertex"; }
4466     };
4467   }
4468
4469
4470       namespace swig {
4471         template <>  struct traits<std::vector<Hex::Vertex*, std::allocator< Hex::Vertex * > > > {
4472           typedef value_category category;
4473           static const char* type_name() {
4474             return "std::vector<" "Hex::Vertex" " *," "std::allocator< Hex::Vertex * >" " >";
4475           }
4476         };
4477       }
4478
4479 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(std::vector< Hex::Vertex * > *self,PyObject **PYTHON_SELF){
4480       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4481     }
4482 SWIGINTERN bool std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__(std::vector< Hex::Vertex * > const *self){
4483       return !(self->empty());
4484     }
4485 SWIGINTERN bool std_vector_Sl_Hex_Vertex_Sm__Sg____bool__(std::vector< Hex::Vertex * > const *self){
4486       return !(self->empty());
4487     }
4488 SWIGINTERN std::vector< Hex::Vertex * >::size_type std_vector_Sl_Hex_Vertex_Sm__Sg____len__(std::vector< Hex::Vertex * > const *self){
4489       return self->size();
4490     }
4491 SWIGINTERN std::vector< Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg__pop(std::vector< Hex::Vertex * > *self){
4492       if (self->size() == 0)
4493         throw std::out_of_range("pop from empty container");
4494       std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >::value_type x = self->back();
4495       self->pop_back();
4496       return x;
4497     }
4498 SWIGINTERN std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *std_vector_Sl_Hex_Vertex_Sm__Sg____getslice__(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i,std::vector< Hex::Vertex * >::difference_type j){
4499       return swig::getslice(self, i, j);
4500     }
4501 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setslice__(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i,std::vector< Hex::Vertex * >::difference_type j,std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &v){
4502       swig::setslice(self, i, j, v);
4503     }
4504 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delslice__(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i,std::vector< Hex::Vertex * >::difference_type j){
4505       swig::delslice(self, i, j);
4506     }
4507 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i){
4508       self->erase(swig::getpos(self,i));
4509     }
4510 SWIGINTERN std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Vertex * > *self,PySliceObject *slice){
4511       Py_ssize_t i, j, step;
4512       if( !PySlice_Check(slice) ) {
4513         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4514         return NULL;
4515       }
4516       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4517       return swig::getslice(self, i, j);
4518     }
4519 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Vertex * > *self,PySliceObject *slice,std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &v){
4520       Py_ssize_t i, j, step;
4521       if( !PySlice_Check(slice) ) {
4522         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4523         return;
4524       }
4525       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4526       swig::setslice(self, i, j, v);
4527     }
4528 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Vertex * > *self,PySliceObject *slice){
4529       Py_ssize_t i, j, step;
4530       if( !PySlice_Check(slice) ) {
4531         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4532         return;
4533       }
4534       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4535       swig::delslice(self, i,j);
4536     }
4537 SWIGINTERN std::vector< Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i){
4538       return *(swig::cgetpos(self, i));
4539     }
4540 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i,std::vector< Hex::Vertex * >::value_type x){
4541       *(swig::getpos(self,i)) = x;
4542     }
4543 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg__append(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::value_type x){
4544       self->push_back(x);
4545     }
4546
4547   namespace swig {
4548     template <>  struct traits<Hex::NewShape > {
4549       typedef pointer_category category;
4550       static const char* type_name() { return"Hex::NewShape"; }
4551     };
4552   }
4553
4554
4555       namespace swig {
4556         template <>  struct traits<std::vector<Hex::NewShape*, std::allocator< Hex::NewShape * > > > {
4557           typedef value_category category;
4558           static const char* type_name() {
4559             return "std::vector<" "Hex::NewShape" " *," "std::allocator< Hex::NewShape * >" " >";
4560           }
4561         };
4562       }
4563
4564 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(std::vector< Hex::NewShape * > *self,PyObject **PYTHON_SELF){
4565       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4566     }
4567 SWIGINTERN bool std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__(std::vector< Hex::NewShape * > const *self){
4568       return !(self->empty());
4569     }
4570 SWIGINTERN bool std_vector_Sl_Hex_NewShape_Sm__Sg____bool__(std::vector< Hex::NewShape * > const *self){
4571       return !(self->empty());
4572     }
4573 SWIGINTERN std::vector< Hex::NewShape * >::size_type std_vector_Sl_Hex_NewShape_Sm__Sg____len__(std::vector< Hex::NewShape * > const *self){
4574       return self->size();
4575     }
4576 SWIGINTERN std::vector< Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg__pop(std::vector< Hex::NewShape * > *self){
4577       if (self->size() == 0)
4578         throw std::out_of_range("pop from empty container");
4579       std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >::value_type x = self->back();
4580       self->pop_back();
4581       return x;
4582     }
4583 SWIGINTERN std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *std_vector_Sl_Hex_NewShape_Sm__Sg____getslice__(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i,std::vector< Hex::NewShape * >::difference_type j){
4584       return swig::getslice(self, i, j);
4585     }
4586 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setslice__(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i,std::vector< Hex::NewShape * >::difference_type j,std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &v){
4587       swig::setslice(self, i, j, v);
4588     }
4589 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delslice__(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i,std::vector< Hex::NewShape * >::difference_type j){
4590       swig::delslice(self, i, j);
4591     }
4592 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_0(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i){
4593       self->erase(swig::getpos(self,i));
4594     }
4595 SWIGINTERN std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_0(std::vector< Hex::NewShape * > *self,PySliceObject *slice){
4596       Py_ssize_t i, j, step;
4597       if( !PySlice_Check(slice) ) {
4598         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4599         return NULL;
4600       }
4601       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4602       return swig::getslice(self, i, j);
4603     }
4604 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_0(std::vector< Hex::NewShape * > *self,PySliceObject *slice,std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &v){
4605       Py_ssize_t i, j, step;
4606       if( !PySlice_Check(slice) ) {
4607         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4608         return;
4609       }
4610       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4611       swig::setslice(self, i, j, v);
4612     }
4613 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_1(std::vector< Hex::NewShape * > *self,PySliceObject *slice){
4614       Py_ssize_t i, j, step;
4615       if( !PySlice_Check(slice) ) {
4616         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4617         return;
4618       }
4619       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4620       swig::delslice(self, i,j);
4621     }
4622 SWIGINTERN std::vector< Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_1(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i){
4623       return *(swig::cgetpos(self, i));
4624     }
4625 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_1(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i,std::vector< Hex::NewShape * >::value_type x){
4626       *(swig::getpos(self,i)) = x;
4627     }
4628 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg__append(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::value_type x){
4629       self->push_back(x);
4630     }
4631
4632   #define SWIG_From_double   PyFloat_FromDouble
4633
4634
4635 namespace swig {
4636   template <> struct traits<double > {
4637     typedef value_category category;
4638     static const char* type_name() { return"double"; }
4639   };
4640   template <>  struct traits_asval<double > {
4641     typedef double value_type;
4642     static int asval(PyObject *obj, value_type *val) {
4643       return SWIG_AsVal_double (obj, val);
4644     }
4645   };
4646   template <>  struct traits_from<double > {
4647     typedef double value_type;
4648     static PyObject *from(const value_type& val) {
4649       return SWIG_From_double  (val);
4650     }
4651   };
4652 }
4653
4654
4655       namespace swig {
4656         template <>  struct traits<std::vector<double, std::allocator< double > > > {
4657           typedef pointer_category category;
4658           static const char* type_name() {
4659             return "std::vector<" "double" "," "std::allocator< double >" " >";
4660           }
4661         };
4662       }
4663
4664 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
4665       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4666     }
4667 SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
4668       return !(self->empty());
4669     }
4670 SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
4671       return !(self->empty());
4672     }
4673 SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
4674       return self->size();
4675     }
4676 SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
4677       if (self->size() == 0)
4678         throw std::out_of_range("pop from empty container");
4679       std::vector<double,std::allocator< double > >::value_type x = self->back();
4680       self->pop_back();
4681       return x;
4682     }
4683 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
4684       return swig::getslice(self, i, j);
4685     }
4686 SWIGINTERN void std_vector_Sl_double_Sg____setslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
4687       swig::setslice(self, i, j, v);
4688     }
4689 SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
4690       swig::delslice(self, i, j);
4691     }
4692 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
4693       self->erase(swig::getpos(self,i));
4694     }
4695 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
4696       Py_ssize_t i, j, step;
4697       if( !PySlice_Check(slice) ) {
4698         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4699         return NULL;
4700       }
4701       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4702       return swig::getslice(self, i, j);
4703     }
4704 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
4705       Py_ssize_t i, j, step;
4706       if( !PySlice_Check(slice) ) {
4707         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4708         return;
4709       }
4710       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4711       swig::setslice(self, i, j, v);
4712     }
4713 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
4714       Py_ssize_t i, j, step;
4715       if( !PySlice_Check(slice) ) {
4716         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4717         return;
4718       }
4719       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4720       swig::delslice(self, i,j);
4721     }
4722 SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
4723       return *(swig::cgetpos(self, i));
4724     }
4725 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
4726       *(swig::getpos(self,i)) = x;
4727     }
4728 SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
4729       self->push_back(x);
4730     }
4731
4732 #include <limits.h>
4733 #if !defined(SWIG_NO_LLONG_MAX)
4734 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
4735 #   define LLONG_MAX __LONG_LONG_MAX__
4736 #   define LLONG_MIN (-LLONG_MAX - 1LL)
4737 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
4738 # endif
4739 #endif
4740
4741
4742 SWIGINTERN int
4743 SWIG_AsVal_int (PyObject * obj, int *val)
4744 {
4745   long v;
4746   int res = SWIG_AsVal_long (obj, &v);
4747   if (SWIG_IsOK(res)) {
4748     if ((v < INT_MIN || v > INT_MAX)) {
4749       return SWIG_OverflowError;
4750     } else {
4751       if (val) *val = static_cast< int >(v);
4752     }
4753   }
4754   return res;
4755 }
4756
4757
4758 SWIGINTERNINLINE PyObject *
4759 SWIG_From_int  (int value)
4760 {
4761   return SWIG_From_long  (value);
4762 }
4763
4764
4765 namespace swig {
4766   template <> struct traits<int > {
4767     typedef value_category category;
4768     static const char* type_name() { return"int"; }
4769   };
4770   template <>  struct traits_asval<int > {
4771     typedef int value_type;
4772     static int asval(PyObject *obj, value_type *val) {
4773       return SWIG_AsVal_int (obj, val);
4774     }
4775   };
4776   template <>  struct traits_from<int > {
4777     typedef int value_type;
4778     static PyObject *from(const value_type& val) {
4779       return SWIG_From_int  (val);
4780     }
4781   };
4782 }
4783
4784
4785       namespace swig {
4786         template <>  struct traits<std::vector<int, std::allocator< int > > > {
4787           typedef pointer_category category;
4788           static const char* type_name() {
4789             return "std::vector<" "int" "," "std::allocator< int >" " >";
4790           }
4791         };
4792       }
4793
4794 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
4795       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4796     }
4797 SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
4798       return !(self->empty());
4799     }
4800 SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
4801       return !(self->empty());
4802     }
4803 SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
4804       return self->size();
4805     }
4806 SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
4807       if (self->size() == 0)
4808         throw std::out_of_range("pop from empty container");
4809       std::vector<int,std::allocator< int > >::value_type x = self->back();
4810       self->pop_back();
4811       return x;
4812     }
4813 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
4814       return swig::getslice(self, i, j);
4815     }
4816 SWIGINTERN void std_vector_Sl_int_Sg____setslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
4817       swig::setslice(self, i, j, v);
4818     }
4819 SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
4820       swig::delslice(self, i, j);
4821     }
4822 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
4823       self->erase(swig::getpos(self,i));
4824     }
4825 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
4826       Py_ssize_t i, j, step;
4827       if( !PySlice_Check(slice) ) {
4828         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4829         return NULL;
4830       }
4831       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4832       return swig::getslice(self, i, j);
4833     }
4834 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
4835       Py_ssize_t i, j, step;
4836       if( !PySlice_Check(slice) ) {
4837         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4838         return;
4839       }
4840       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4841       swig::setslice(self, i, j, v);
4842     }
4843 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
4844       Py_ssize_t i, j, step;
4845       if( !PySlice_Check(slice) ) {
4846         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4847         return;
4848       }
4849       PySlice_GetIndices(slice, self->size(), &i, &j, &step);
4850       swig::delslice(self, i,j);
4851     }
4852 SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){
4853       return *(swig::cgetpos(self, i));
4854     }
4855 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
4856       *(swig::getpos(self,i)) = x;
4857     }
4858 SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
4859       self->push_back(x);
4860     }
4861
4862 SWIGINTERN swig_type_info*
4863 SWIG_pchar_descriptor(void)
4864 {
4865   static int init = 0;
4866   static swig_type_info* info = 0;
4867   if (!init) {
4868     info = SWIG_TypeQuery("_p_char");
4869     init = 1;
4870   }
4871   return info;
4872 }
4873
4874
4875 SWIGINTERNINLINE PyObject *
4876 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
4877 {
4878   if (carray) {
4879     if (size > INT_MAX) {
4880       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4881       return pchar_descriptor ?
4882         SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
4883     } else {
4884 #if PY_VERSION_HEX >= 0x03000000
4885       return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
4886 #else
4887       return PyString_FromStringAndSize(carray, static_cast< int >(size));
4888 #endif
4889     }
4890   } else {
4891     return SWIG_Py_Void();
4892   }
4893 }
4894
4895
4896 SWIGINTERNINLINE PyObject *
4897 SWIG_From_char  (char c)
4898 {
4899   return SWIG_FromCharPtrAndSize(&c,1);
4900 }
4901
4902
4903 SWIGINTERNINLINE PyObject *
4904 SWIG_FromCharPtr(const char *cptr)
4905 {
4906   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
4907 }
4908
4909
4910 SWIGINTERN int
4911 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
4912 {
4913 #if PY_VERSION_HEX>=0x03000000
4914   if (PyUnicode_Check(obj))
4915 #else
4916   if (PyString_Check(obj))
4917 #endif
4918   {
4919     char *cstr; Py_ssize_t len;
4920 #if PY_VERSION_HEX>=0x03000000
4921     if (!alloc && cptr) {
4922         /* We can't allow converting without allocation, since the internal
4923            representation of string in Python 3 is UCS-2/UCS-4 but we require
4924            a UTF-8 representation.
4925            TODO(bhy) More detailed explanation */
4926         return SWIG_RuntimeError;
4927     }
4928     obj = PyUnicode_AsUTF8String(obj);
4929     PyBytes_AsStringAndSize(obj, &cstr, &len);
4930     if(alloc) *alloc = SWIG_NEWOBJ;
4931 #else
4932     PyString_AsStringAndSize(obj, &cstr, &len);
4933 #endif
4934     if (cptr) {
4935       if (alloc) {
4936         /*
4937            In python the user should not be able to modify the inner
4938            string representation. To warranty that, if you define
4939            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
4940            buffer is always returned.
4941
4942            The default behavior is just to return the pointer value,
4943            so, be careful.
4944         */
4945 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
4946         if (*alloc != SWIG_OLDOBJ)
4947 #else
4948         if (*alloc == SWIG_NEWOBJ)
4949 #endif
4950           {
4951             *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
4952             *alloc = SWIG_NEWOBJ;
4953           }
4954         else {
4955           *cptr = cstr;
4956           *alloc = SWIG_OLDOBJ;
4957         }
4958       } else {
4959         #if PY_VERSION_HEX>=0x03000000
4960         assert(0); /* Should never reach here in Python 3 */
4961         #endif
4962         *cptr = SWIG_Python_str_AsChar(obj);
4963       }
4964     }
4965     if (psize) *psize = len + 1;
4966 #if PY_VERSION_HEX>=0x03000000
4967     Py_XDECREF(obj);
4968 #endif
4969     return SWIG_OK;
4970   } else {
4971     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4972     if (pchar_descriptor) {
4973       void* vptr = 0;
4974       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
4975         if (cptr) *cptr = (char *) vptr;
4976         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
4977         if (alloc) *alloc = SWIG_OLDOBJ;
4978         return SWIG_OK;
4979       }
4980     }
4981   }
4982   return SWIG_TypeError;
4983 }
4984
4985
4986
4987
4988
4989 SWIGINTERN int
4990 SWIG_AsVal_bool (PyObject *obj, bool *val)
4991 {
4992   int r = PyObject_IsTrue(obj);
4993   if (r == -1)
4994     return SWIG_ERROR;
4995   if (val) *val = r ? true : false;
4996   return SWIG_OK;
4997 }
4998
4999 #ifdef __cplusplus
5000 extern "C" {
5001 #endif
5002 SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5003   PyObject *resultobj = 0;
5004   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5005   void *argp1 = 0 ;
5006   int res1 = 0 ;
5007   PyObject * obj0 = 0 ;
5008
5009   if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail;
5010   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
5011   if (!SWIG_IsOK(res1)) {
5012     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5013   }
5014   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5015   delete arg1;
5016   resultobj = SWIG_Py_Void();
5017   return resultobj;
5018 fail:
5019   return NULL;
5020 }
5021
5022
5023 SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5024   PyObject *resultobj = 0;
5025   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5026   void *argp1 = 0 ;
5027   int res1 = 0 ;
5028   PyObject * obj0 = 0 ;
5029   PyObject *result = 0 ;
5030
5031   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail;
5032   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5033   if (!SWIG_IsOK(res1)) {
5034     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5035   }
5036   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5037   try {
5038     result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
5039   }
5040   catch(swig::stop_iteration &_e) {
5041     {
5042       (void)_e;
5043       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5044       SWIG_fail;
5045     }
5046   }
5047
5048   resultobj = result;
5049   return resultobj;
5050 fail:
5051   return NULL;
5052 }
5053
5054
5055 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5056   PyObject *resultobj = 0;
5057   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5058   size_t arg2 ;
5059   void *argp1 = 0 ;
5060   int res1 = 0 ;
5061   size_t val2 ;
5062   int ecode2 = 0 ;
5063   PyObject * obj0 = 0 ;
5064   PyObject * obj1 = 0 ;
5065   swig::SwigPyIterator *result = 0 ;
5066
5067   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail;
5068   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5069   if (!SWIG_IsOK(res1)) {
5070     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5071   }
5072   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5073   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
5074   if (!SWIG_IsOK(ecode2)) {
5075     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
5076   }
5077   arg2 = static_cast< size_t >(val2);
5078   try {
5079     result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
5080   }
5081   catch(swig::stop_iteration &_e) {
5082     {
5083       (void)_e;
5084       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5085       SWIG_fail;
5086     }
5087   }
5088
5089   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5090   return resultobj;
5091 fail:
5092   return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097   PyObject *resultobj = 0;
5098   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5099   void *argp1 = 0 ;
5100   int res1 = 0 ;
5101   PyObject * obj0 = 0 ;
5102   swig::SwigPyIterator *result = 0 ;
5103
5104   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail;
5105   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5106   if (!SWIG_IsOK(res1)) {
5107     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5108   }
5109   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5110   try {
5111     result = (swig::SwigPyIterator *)(arg1)->incr();
5112   }
5113   catch(swig::stop_iteration &_e) {
5114     {
5115       (void)_e;
5116       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5117       SWIG_fail;
5118     }
5119   }
5120
5121   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5122   return resultobj;
5123 fail:
5124   return NULL;
5125 }
5126
5127
5128 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
5129   int argc;
5130   PyObject *argv[3];
5131   int ii;
5132
5133   if (!PyTuple_Check(args)) SWIG_fail;
5134   argc = (int)PyObject_Length(args);
5135   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5136     argv[ii] = PyTuple_GET_ITEM(args,ii);
5137   }
5138   if (argc == 1) {
5139     int _v;
5140     void *vptr = 0;
5141     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
5142     _v = SWIG_CheckState(res);
5143     if (_v) {
5144       return _wrap_SwigPyIterator_incr__SWIG_1(self, args);
5145     }
5146   }
5147   if (argc == 2) {
5148     int _v;
5149     void *vptr = 0;
5150     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
5151     _v = SWIG_CheckState(res);
5152     if (_v) {
5153       {
5154         int res = SWIG_AsVal_size_t(argv[1], NULL);
5155         _v = SWIG_CheckState(res);
5156       }
5157       if (_v) {
5158         return _wrap_SwigPyIterator_incr__SWIG_0(self, args);
5159       }
5160     }
5161   }
5162
5163 fail:
5164   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SwigPyIterator_incr'.\n"
5165     "  Possible C/C++ prototypes are:\n"
5166     "    incr(swig::SwigPyIterator *,size_t)\n"
5167     "    incr(swig::SwigPyIterator *)\n");
5168   return NULL;
5169 }
5170
5171
5172 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5173   PyObject *resultobj = 0;
5174   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5175   size_t arg2 ;
5176   void *argp1 = 0 ;
5177   int res1 = 0 ;
5178   size_t val2 ;
5179   int ecode2 = 0 ;
5180   PyObject * obj0 = 0 ;
5181   PyObject * obj1 = 0 ;
5182   swig::SwigPyIterator *result = 0 ;
5183
5184   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail;
5185   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5186   if (!SWIG_IsOK(res1)) {
5187     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5188   }
5189   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5190   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
5191   if (!SWIG_IsOK(ecode2)) {
5192     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
5193   }
5194   arg2 = static_cast< size_t >(val2);
5195   try {
5196     result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
5197   }
5198   catch(swig::stop_iteration &_e) {
5199     {
5200       (void)_e;
5201       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5202       SWIG_fail;
5203     }
5204   }
5205
5206   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5207   return resultobj;
5208 fail:
5209   return NULL;
5210 }
5211
5212
5213 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5214   PyObject *resultobj = 0;
5215   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5216   void *argp1 = 0 ;
5217   int res1 = 0 ;
5218   PyObject * obj0 = 0 ;
5219   swig::SwigPyIterator *result = 0 ;
5220
5221   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail;
5222   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5223   if (!SWIG_IsOK(res1)) {
5224     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5225   }
5226   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5227   try {
5228     result = (swig::SwigPyIterator *)(arg1)->decr();
5229   }
5230   catch(swig::stop_iteration &_e) {
5231     {
5232       (void)_e;
5233       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5234       SWIG_fail;
5235     }
5236   }
5237
5238   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5239   return resultobj;
5240 fail:
5241   return NULL;
5242 }
5243
5244
5245 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
5246   int argc;
5247   PyObject *argv[3];
5248   int ii;
5249
5250   if (!PyTuple_Check(args)) SWIG_fail;
5251   argc = (int)PyObject_Length(args);
5252   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5253     argv[ii] = PyTuple_GET_ITEM(args,ii);
5254   }
5255   if (argc == 1) {
5256     int _v;
5257     void *vptr = 0;
5258     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
5259     _v = SWIG_CheckState(res);
5260     if (_v) {
5261       return _wrap_SwigPyIterator_decr__SWIG_1(self, args);
5262     }
5263   }
5264   if (argc == 2) {
5265     int _v;
5266     void *vptr = 0;
5267     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
5268     _v = SWIG_CheckState(res);
5269     if (_v) {
5270       {
5271         int res = SWIG_AsVal_size_t(argv[1], NULL);
5272         _v = SWIG_CheckState(res);
5273       }
5274       if (_v) {
5275         return _wrap_SwigPyIterator_decr__SWIG_0(self, args);
5276       }
5277     }
5278   }
5279
5280 fail:
5281   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SwigPyIterator_decr'.\n"
5282     "  Possible C/C++ prototypes are:\n"
5283     "    decr(swig::SwigPyIterator *,size_t)\n"
5284     "    decr(swig::SwigPyIterator *)\n");
5285   return NULL;
5286 }
5287
5288
5289 SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5290   PyObject *resultobj = 0;
5291   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5292   swig::SwigPyIterator *arg2 = 0 ;
5293   void *argp1 = 0 ;
5294   int res1 = 0 ;
5295   void *argp2 = 0 ;
5296   int res2 = 0 ;
5297   PyObject * obj0 = 0 ;
5298   PyObject * obj1 = 0 ;
5299   ptrdiff_t result;
5300
5301   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail;
5302   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5303   if (!SWIG_IsOK(res1)) {
5304     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5305   }
5306   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5307   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
5308   if (!SWIG_IsOK(res2)) {
5309     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5310   }
5311   if (!argp2) {
5312     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5313   }
5314   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5315   try {
5316     result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
5317   }
5318   catch(std::invalid_argument &_e) {
5319     SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
5320   }
5321
5322   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5323   return resultobj;
5324 fail:
5325   return NULL;
5326 }
5327
5328
5329 SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5330   PyObject *resultobj = 0;
5331   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5332   swig::SwigPyIterator *arg2 = 0 ;
5333   void *argp1 = 0 ;
5334   int res1 = 0 ;
5335   void *argp2 = 0 ;
5336   int res2 = 0 ;
5337   PyObject * obj0 = 0 ;
5338   PyObject * obj1 = 0 ;
5339   bool result;
5340
5341   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail;
5342   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5343   if (!SWIG_IsOK(res1)) {
5344     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5345   }
5346   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5347   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
5348   if (!SWIG_IsOK(res2)) {
5349     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5350   }
5351   if (!argp2) {
5352     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5353   }
5354   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5355   try {
5356     result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
5357   }
5358   catch(std::invalid_argument &_e) {
5359     SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
5360   }
5361
5362   resultobj = SWIG_From_bool(static_cast< bool >(result));
5363   return resultobj;
5364 fail:
5365   return NULL;
5366 }
5367
5368
5369 SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5370   PyObject *resultobj = 0;
5371   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5372   void *argp1 = 0 ;
5373   int res1 = 0 ;
5374   PyObject * obj0 = 0 ;
5375   swig::SwigPyIterator *result = 0 ;
5376
5377   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail;
5378   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5379   if (!SWIG_IsOK(res1)) {
5380     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5381   }
5382   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5383   result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
5384   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
5385   return resultobj;
5386 fail:
5387   return NULL;
5388 }
5389
5390
5391 SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5392   PyObject *resultobj = 0;
5393   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5394   void *argp1 = 0 ;
5395   int res1 = 0 ;
5396   PyObject * obj0 = 0 ;
5397   PyObject *result = 0 ;
5398
5399   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail;
5400   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5401   if (!SWIG_IsOK(res1)) {
5402     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5403   }
5404   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5405   try {
5406     result = (PyObject *)(arg1)->next();
5407   }
5408   catch(swig::stop_iteration &_e) {
5409     {
5410       (void)_e;
5411       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5412       SWIG_fail;
5413     }
5414   }
5415
5416   resultobj = result;
5417   return resultobj;
5418 fail:
5419   return NULL;
5420 }
5421
5422
5423 SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5424   PyObject *resultobj = 0;
5425   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5426   void *argp1 = 0 ;
5427   int res1 = 0 ;
5428   PyObject * obj0 = 0 ;
5429   PyObject *result = 0 ;
5430
5431   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail;
5432   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5433   if (!SWIG_IsOK(res1)) {
5434     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5435   }
5436   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5437   try {
5438     result = (PyObject *)(arg1)->__next__();
5439   }
5440   catch(swig::stop_iteration &_e) {
5441     {
5442       (void)_e;
5443       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5444       SWIG_fail;
5445     }
5446   }
5447
5448   resultobj = result;
5449   return resultobj;
5450 fail:
5451   return NULL;
5452 }
5453
5454
5455 SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5456   PyObject *resultobj = 0;
5457   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5458   void *argp1 = 0 ;
5459   int res1 = 0 ;
5460   PyObject * obj0 = 0 ;
5461   PyObject *result = 0 ;
5462
5463   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail;
5464   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5465   if (!SWIG_IsOK(res1)) {
5466     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5467   }
5468   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5469   try {
5470     result = (PyObject *)(arg1)->previous();
5471   }
5472   catch(swig::stop_iteration &_e) {
5473     {
5474       (void)_e;
5475       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5476       SWIG_fail;
5477     }
5478   }
5479
5480   resultobj = result;
5481   return resultobj;
5482 fail:
5483   return NULL;
5484 }
5485
5486
5487 SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5488   PyObject *resultobj = 0;
5489   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5490   ptrdiff_t arg2 ;
5491   void *argp1 = 0 ;
5492   int res1 = 0 ;
5493   ptrdiff_t val2 ;
5494   int ecode2 = 0 ;
5495   PyObject * obj0 = 0 ;
5496   PyObject * obj1 = 0 ;
5497   swig::SwigPyIterator *result = 0 ;
5498
5499   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail;
5500   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5501   if (!SWIG_IsOK(res1)) {
5502     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5503   }
5504   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5505   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5506   if (!SWIG_IsOK(ecode2)) {
5507     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
5508   }
5509   arg2 = static_cast< ptrdiff_t >(val2);
5510   try {
5511     result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
5512   }
5513   catch(swig::stop_iteration &_e) {
5514     {
5515       (void)_e;
5516       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5517       SWIG_fail;
5518     }
5519   }
5520
5521   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5522   return resultobj;
5523 fail:
5524   return NULL;
5525 }
5526
5527
5528 SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5529   PyObject *resultobj = 0;
5530   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5531   swig::SwigPyIterator *arg2 = 0 ;
5532   void *argp1 = 0 ;
5533   int res1 = 0 ;
5534   void *argp2 = 0 ;
5535   int res2 = 0 ;
5536   PyObject * obj0 = 0 ;
5537   PyObject * obj1 = 0 ;
5538   bool result;
5539
5540   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail;
5541   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5542   if (!SWIG_IsOK(res1)) {
5543     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5544   }
5545   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5546   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
5547   if (!SWIG_IsOK(res2)) {
5548     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5549   }
5550   if (!argp2) {
5551     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5552   }
5553   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5554   result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
5555   resultobj = SWIG_From_bool(static_cast< bool >(result));
5556   return resultobj;
5557 fail:
5558   return NULL;
5559 }
5560
5561
5562 SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5563   PyObject *resultobj = 0;
5564   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5565   swig::SwigPyIterator *arg2 = 0 ;
5566   void *argp1 = 0 ;
5567   int res1 = 0 ;
5568   void *argp2 = 0 ;
5569   int res2 = 0 ;
5570   PyObject * obj0 = 0 ;
5571   PyObject * obj1 = 0 ;
5572   bool result;
5573
5574   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail;
5575   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5576   if (!SWIG_IsOK(res1)) {
5577     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5578   }
5579   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5580   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
5581   if (!SWIG_IsOK(res2)) {
5582     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5583   }
5584   if (!argp2) {
5585     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5586   }
5587   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5588   result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
5589   resultobj = SWIG_From_bool(static_cast< bool >(result));
5590   return resultobj;
5591 fail:
5592   return NULL;
5593 }
5594
5595
5596 SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5597   PyObject *resultobj = 0;
5598   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5599   ptrdiff_t arg2 ;
5600   void *argp1 = 0 ;
5601   int res1 = 0 ;
5602   ptrdiff_t val2 ;
5603   int ecode2 = 0 ;
5604   PyObject * obj0 = 0 ;
5605   PyObject * obj1 = 0 ;
5606   swig::SwigPyIterator *result = 0 ;
5607
5608   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail;
5609   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
5610   if (!SWIG_IsOK(res1)) {
5611     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5612   }
5613   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5614   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5615   if (!SWIG_IsOK(ecode2)) {
5616     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
5617   }
5618   arg2 = static_cast< ptrdiff_t >(val2);
5619   try {
5620     result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
5621   }
5622   catch(swig::stop_iteration &_e) {
5623     {
5624       (void)_e;
5625       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5626       SWIG_fail;
5627     }
5628   }
5629
5630   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
5631   return resultobj;
5632 fail:
5633   return NULL;
5634 }
5635
5636
5637 SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5638   PyObject *resultobj = 0;
5639   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5640   ptrdiff_t arg2 ;
5641   void *argp1 = 0 ;
5642   int res1 = 0 ;
5643   ptrdiff_t val2 ;
5644   int ecode2 = 0 ;
5645   PyObject * obj0 = 0 ;
5646   PyObject * obj1 = 0 ;
5647   swig::SwigPyIterator *result = 0 ;
5648
5649   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail;
5650   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
5651   if (!SWIG_IsOK(res1)) {
5652     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5653   }
5654   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5655   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5656   if (!SWIG_IsOK(ecode2)) {
5657     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5658   }
5659   arg2 = static_cast< ptrdiff_t >(val2);
5660   try {
5661     result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
5662   }
5663   catch(swig::stop_iteration &_e) {
5664     {
5665       (void)_e;
5666       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5667       SWIG_fail;
5668     }
5669   }
5670
5671   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
5672   return resultobj;
5673 fail:
5674   return NULL;
5675 }
5676
5677
5678 SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5679   PyObject *resultobj = 0;
5680   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5681   ptrdiff_t arg2 ;
5682   void *argp1 = 0 ;
5683   int res1 = 0 ;
5684   ptrdiff_t val2 ;
5685   int ecode2 = 0 ;
5686   PyObject * obj0 = 0 ;
5687   PyObject * obj1 = 0 ;
5688   swig::SwigPyIterator *result = 0 ;
5689
5690   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail;
5691   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5692   if (!SWIG_IsOK(res1)) {
5693     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5694   }
5695   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5696   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5697   if (!SWIG_IsOK(ecode2)) {
5698     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
5699   }
5700   arg2 = static_cast< ptrdiff_t >(val2);
5701   try {
5702     result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
5703   }
5704   catch(swig::stop_iteration &_e) {
5705     {
5706       (void)_e;
5707       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5708       SWIG_fail;
5709     }
5710   }
5711
5712   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
5713   return resultobj;
5714 fail:
5715   return NULL;
5716 }
5717
5718
5719 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5720   PyObject *resultobj = 0;
5721   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5722   ptrdiff_t arg2 ;
5723   void *argp1 = 0 ;
5724   int res1 = 0 ;
5725   ptrdiff_t val2 ;
5726   int ecode2 = 0 ;
5727   PyObject * obj0 = 0 ;
5728   PyObject * obj1 = 0 ;
5729   swig::SwigPyIterator *result = 0 ;
5730
5731   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
5732   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5733   if (!SWIG_IsOK(res1)) {
5734     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5735   }
5736   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5737   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5738   if (!SWIG_IsOK(ecode2)) {
5739     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5740   }
5741   arg2 = static_cast< ptrdiff_t >(val2);
5742   try {
5743     result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
5744   }
5745   catch(swig::stop_iteration &_e) {
5746     {
5747       (void)_e;
5748       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5749       SWIG_fail;
5750     }
5751   }
5752
5753   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
5754   return resultobj;
5755 fail:
5756   return NULL;
5757 }
5758
5759
5760 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5761   PyObject *resultobj = 0;
5762   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5763   swig::SwigPyIterator *arg2 = 0 ;
5764   void *argp1 = 0 ;
5765   int res1 = 0 ;
5766   void *argp2 = 0 ;
5767   int res2 = 0 ;
5768   PyObject * obj0 = 0 ;
5769   PyObject * obj1 = 0 ;
5770   ptrdiff_t result;
5771
5772   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
5773   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5774   if (!SWIG_IsOK(res1)) {
5775     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5776   }
5777   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5778   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
5779   if (!SWIG_IsOK(res2)) {
5780     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5781   }
5782   if (!argp2) {
5783     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5784   }
5785   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5786   result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
5787   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5788   return resultobj;
5789 fail:
5790   return NULL;
5791 }
5792
5793
5794 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
5795   int argc;
5796   PyObject *argv[3];
5797   int ii;
5798
5799   if (!PyTuple_Check(args)) SWIG_fail;
5800   argc = (int)PyObject_Length(args);
5801   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5802     argv[ii] = PyTuple_GET_ITEM(args,ii);
5803   }
5804   if (argc == 2) {
5805     int _v;
5806     void *vptr = 0;
5807     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
5808     _v = SWIG_CheckState(res);
5809     if (_v) {
5810       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
5811       _v = SWIG_CheckState(res);
5812       if (_v) {
5813         return _wrap_SwigPyIterator___sub____SWIG_1(self, args);
5814       }
5815     }
5816   }
5817   if (argc == 2) {
5818     int _v;
5819     void *vptr = 0;
5820     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
5821     _v = SWIG_CheckState(res);
5822     if (_v) {
5823       {
5824         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
5825         _v = SWIG_CheckState(res);
5826       }
5827       if (_v) {
5828         return _wrap_SwigPyIterator___sub____SWIG_0(self, args);
5829       }
5830     }
5831   }
5832
5833 fail:
5834   Py_INCREF(Py_NotImplemented);
5835   return Py_NotImplemented;
5836 }
5837
5838
5839 SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5840   PyObject *obj;
5841   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5842   SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
5843   return SWIG_Py_Void();
5844 }
5845
5846 SWIGINTERN PyObject *_wrap_VectorHexas_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5847   PyObject *resultobj = 0;
5848   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
5849   PyObject **arg2 = (PyObject **) 0 ;
5850   void *argp1 = 0 ;
5851   int res1 = 0 ;
5852   PyObject * obj0 = 0 ;
5853   swig::SwigPyIterator *result = 0 ;
5854
5855   arg2 = &obj0;
5856   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_iterator",&obj0)) SWIG_fail;
5857   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
5858   if (!SWIG_IsOK(res1)) {
5859     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_iterator" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
5860   }
5861   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
5862   result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(arg1,arg2);
5863   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
5864   return resultobj;
5865 fail:
5866   return NULL;
5867 }
5868
5869
5870 SWIGINTERN PyObject *_wrap_VectorHexas___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5871   PyObject *resultobj = 0;
5872   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
5873   void *argp1 = 0 ;
5874   int res1 = 0 ;
5875   PyObject * obj0 = 0 ;
5876   bool result;
5877
5878   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___nonzero__",&obj0)) SWIG_fail;
5879   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
5880   if (!SWIG_IsOK(res1)) {
5881     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
5882   }
5883   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
5884   result = (bool)std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__((std::vector< Hex::Hexa * > const *)arg1);
5885   resultobj = SWIG_From_bool(static_cast< bool >(result));
5886   return resultobj;
5887 fail:
5888   return NULL;
5889 }
5890
5891
5892 SWIGINTERN PyObject *_wrap_VectorHexas___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5893   PyObject *resultobj = 0;
5894   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
5895   void *argp1 = 0 ;
5896   int res1 = 0 ;
5897   PyObject * obj0 = 0 ;
5898   bool result;
5899
5900   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___bool__",&obj0)) SWIG_fail;
5901   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
5902   if (!SWIG_IsOK(res1)) {
5903     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___bool__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
5904   }
5905   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
5906   result = (bool)std_vector_Sl_Hex_Hexa_Sm__Sg____bool__((std::vector< Hex::Hexa * > const *)arg1);
5907   resultobj = SWIG_From_bool(static_cast< bool >(result));
5908   return resultobj;
5909 fail:
5910   return NULL;
5911 }
5912
5913
5914 SWIGINTERN PyObject *_wrap_VectorHexas___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5915   PyObject *resultobj = 0;
5916   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
5917   void *argp1 = 0 ;
5918   int res1 = 0 ;
5919   PyObject * obj0 = 0 ;
5920   std::vector< Hex::Hexa * >::size_type result;
5921
5922   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___len__",&obj0)) SWIG_fail;
5923   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
5924   if (!SWIG_IsOK(res1)) {
5925     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___len__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
5926   }
5927   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
5928   result = std_vector_Sl_Hex_Hexa_Sm__Sg____len__((std::vector< Hex::Hexa * > const *)arg1);
5929   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
5930   return resultobj;
5931 fail:
5932   return NULL;
5933 }
5934
5935
5936 SWIGINTERN PyObject *_wrap_VectorHexas_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5937   PyObject *resultobj = 0;
5938   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
5939   void *argp1 = 0 ;
5940   int res1 = 0 ;
5941   PyObject * obj0 = 0 ;
5942   std::vector< Hex::Hexa * >::value_type result;
5943
5944   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop",&obj0)) SWIG_fail;
5945   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
5946   if (!SWIG_IsOK(res1)) {
5947     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
5948   }
5949   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
5950   try {
5951     result = (std::vector< Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg__pop(arg1);
5952   }
5953   catch(std::out_of_range &_e) {
5954     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5955   }
5956
5957   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
5958   return resultobj;
5959 fail:
5960   return NULL;
5961 }
5962
5963
5964 SWIGINTERN PyObject *_wrap_VectorHexas___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5965   PyObject *resultobj = 0;
5966   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
5967   std::vector< Hex::Hexa * >::difference_type arg2 ;
5968   std::vector< Hex::Hexa * >::difference_type arg3 ;
5969   void *argp1 = 0 ;
5970   int res1 = 0 ;
5971   ptrdiff_t val2 ;
5972   int ecode2 = 0 ;
5973   ptrdiff_t val3 ;
5974   int ecode3 = 0 ;
5975   PyObject * obj0 = 0 ;
5976   PyObject * obj1 = 0 ;
5977   PyObject * obj2 = 0 ;
5978   std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *result = 0 ;
5979
5980   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
5981   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
5982   if (!SWIG_IsOK(res1)) {
5983     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
5984   }
5985   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
5986   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5987   if (!SWIG_IsOK(ecode2)) {
5988     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
5989   }
5990   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
5991   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
5992   if (!SWIG_IsOK(ecode3)) {
5993     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
5994   }
5995   arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
5996   try {
5997     result = (std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *)std_vector_Sl_Hex_Hexa_Sm__Sg____getslice__(arg1,arg2,arg3);
5998   }
5999   catch(std::out_of_range &_e) {
6000     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6001   }
6002
6003   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_OWN |  0 );
6004   return resultobj;
6005 fail:
6006   return NULL;
6007 }
6008
6009
6010 SWIGINTERN PyObject *_wrap_VectorHexas___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6011   PyObject *resultobj = 0;
6012   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6013   std::vector< Hex::Hexa * >::difference_type arg2 ;
6014   std::vector< Hex::Hexa * >::difference_type arg3 ;
6015   std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *arg4 = 0 ;
6016   void *argp1 = 0 ;
6017   int res1 = 0 ;
6018   ptrdiff_t val2 ;
6019   int ecode2 = 0 ;
6020   ptrdiff_t val3 ;
6021   int ecode3 = 0 ;
6022   int res4 = SWIG_OLDOBJ ;
6023   PyObject * obj0 = 0 ;
6024   PyObject * obj1 = 0 ;
6025   PyObject * obj2 = 0 ;
6026   PyObject * obj3 = 0 ;
6027
6028   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6029   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6030   if (!SWIG_IsOK(res1)) {
6031     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6032   }
6033   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6034   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6035   if (!SWIG_IsOK(ecode2)) {
6036     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6037   }
6038   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
6039   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6040   if (!SWIG_IsOK(ecode3)) {
6041     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6042   }
6043   arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
6044   {
6045     std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
6046     res4 = swig::asptr(obj3, &ptr);
6047     if (!SWIG_IsOK(res4)) {
6048       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
6049     }
6050     if (!ptr) {
6051       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
6052     }
6053     arg4 = ptr;
6054   }
6055   try {
6056     std_vector_Sl_Hex_Hexa_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)*arg4);
6057   }
6058   catch(std::out_of_range &_e) {
6059     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6060   }
6061   catch(std::invalid_argument &_e) {
6062     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6063   }
6064
6065   resultobj = SWIG_Py_Void();
6066   if (SWIG_IsNewObj(res4)) delete arg4;
6067   return resultobj;
6068 fail:
6069   if (SWIG_IsNewObj(res4)) delete arg4;
6070   return NULL;
6071 }
6072
6073
6074 SWIGINTERN PyObject *_wrap_VectorHexas___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6075   PyObject *resultobj = 0;
6076   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6077   std::vector< Hex::Hexa * >::difference_type arg2 ;
6078   std::vector< Hex::Hexa * >::difference_type arg3 ;
6079   void *argp1 = 0 ;
6080   int res1 = 0 ;
6081   ptrdiff_t val2 ;
6082   int ecode2 = 0 ;
6083   ptrdiff_t val3 ;
6084   int ecode3 = 0 ;
6085   PyObject * obj0 = 0 ;
6086   PyObject * obj1 = 0 ;
6087   PyObject * obj2 = 0 ;
6088
6089   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
6090   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6091   if (!SWIG_IsOK(res1)) {
6092     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6093   }
6094   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6095   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6096   if (!SWIG_IsOK(ecode2)) {
6097     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6098   }
6099   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
6100   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6101   if (!SWIG_IsOK(ecode3)) {
6102     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6103   }
6104   arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
6105   try {
6106     std_vector_Sl_Hex_Hexa_Sm__Sg____delslice__(arg1,arg2,arg3);
6107   }
6108   catch(std::out_of_range &_e) {
6109     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6110   }
6111
6112   resultobj = SWIG_Py_Void();
6113   return resultobj;
6114 fail:
6115   return NULL;
6116 }
6117
6118
6119 SWIGINTERN PyObject *_wrap_VectorHexas___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6120   PyObject *resultobj = 0;
6121   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6122   std::vector< Hex::Hexa * >::difference_type arg2 ;
6123   void *argp1 = 0 ;
6124   int res1 = 0 ;
6125   ptrdiff_t val2 ;
6126   int ecode2 = 0 ;
6127   PyObject * obj0 = 0 ;
6128   PyObject * obj1 = 0 ;
6129
6130   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___delitem__",&obj0,&obj1)) SWIG_fail;
6131   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6132   if (!SWIG_IsOK(res1)) {
6133     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6134   }
6135   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6136   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6137   if (!SWIG_IsOK(ecode2)) {
6138     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6139   }
6140   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
6141   try {
6142     std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_0(arg1,arg2);
6143   }
6144   catch(std::out_of_range &_e) {
6145     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6146   }
6147
6148   resultobj = SWIG_Py_Void();
6149   return resultobj;
6150 fail:
6151   return NULL;
6152 }
6153
6154
6155 SWIGINTERN PyObject *_wrap_VectorHexas___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6156   PyObject *resultobj = 0;
6157   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6158   PySliceObject *arg2 = (PySliceObject *) 0 ;
6159   void *argp1 = 0 ;
6160   int res1 = 0 ;
6161   PyObject * obj0 = 0 ;
6162   PyObject * obj1 = 0 ;
6163   std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *result = 0 ;
6164
6165   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___getitem__",&obj0,&obj1)) SWIG_fail;
6166   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6167   if (!SWIG_IsOK(res1)) {
6168     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6169   }
6170   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6171   {
6172     arg2 = (PySliceObject *) obj1;
6173   }
6174   try {
6175     result = (std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *)std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_0(arg1,arg2);
6176   }
6177   catch(std::out_of_range &_e) {
6178     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6179   }
6180
6181   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6182   return resultobj;
6183 fail:
6184   return NULL;
6185 }
6186
6187
6188 SWIGINTERN PyObject *_wrap_VectorHexas___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6189   PyObject *resultobj = 0;
6190   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6191   PySliceObject *arg2 = (PySliceObject *) 0 ;
6192   std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *arg3 = 0 ;
6193   void *argp1 = 0 ;
6194   int res1 = 0 ;
6195   int res3 = SWIG_OLDOBJ ;
6196   PyObject * obj0 = 0 ;
6197   PyObject * obj1 = 0 ;
6198   PyObject * obj2 = 0 ;
6199
6200   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
6201   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6202   if (!SWIG_IsOK(res1)) {
6203     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6204   }
6205   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6206   {
6207     arg2 = (PySliceObject *) obj1;
6208   }
6209   {
6210     std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
6211     res3 = swig::asptr(obj2, &ptr);
6212     if (!SWIG_IsOK(res3)) {
6213       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
6214     }
6215     if (!ptr) {
6216       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
6217     }
6218     arg3 = ptr;
6219   }
6220   try {
6221     std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)*arg3);
6222   }
6223   catch(std::out_of_range &_e) {
6224     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6225   }
6226   catch(std::invalid_argument &_e) {
6227     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6228   }
6229
6230   resultobj = SWIG_Py_Void();
6231   if (SWIG_IsNewObj(res3)) delete arg3;
6232   return resultobj;
6233 fail:
6234   if (SWIG_IsNewObj(res3)) delete arg3;
6235   return NULL;
6236 }
6237
6238
6239 SWIGINTERN PyObject *_wrap_VectorHexas___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6240   PyObject *resultobj = 0;
6241   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6242   PySliceObject *arg2 = (PySliceObject *) 0 ;
6243   void *argp1 = 0 ;
6244   int res1 = 0 ;
6245   PyObject * obj0 = 0 ;
6246   PyObject * obj1 = 0 ;
6247
6248   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___delitem__",&obj0,&obj1)) SWIG_fail;
6249   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6250   if (!SWIG_IsOK(res1)) {
6251     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6252   }
6253   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6254   {
6255     arg2 = (PySliceObject *) obj1;
6256   }
6257   try {
6258     std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_1(arg1,arg2);
6259   }
6260   catch(std::out_of_range &_e) {
6261     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6262   }
6263
6264   resultobj = SWIG_Py_Void();
6265   return resultobj;
6266 fail:
6267   return NULL;
6268 }
6269
6270
6271 SWIGINTERN PyObject *_wrap_VectorHexas___delitem__(PyObject *self, PyObject *args) {
6272   int argc;
6273   PyObject *argv[3];
6274   int ii;
6275
6276   if (!PyTuple_Check(args)) SWIG_fail;
6277   argc = (int)PyObject_Length(args);
6278   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
6279     argv[ii] = PyTuple_GET_ITEM(args,ii);
6280   }
6281   if (argc == 2) {
6282     int _v;
6283     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
6284     _v = SWIG_CheckState(res);
6285     if (_v) {
6286       {
6287         _v = PySlice_Check(argv[1]);
6288       }
6289       if (_v) {
6290         return _wrap_VectorHexas___delitem____SWIG_1(self, args);
6291       }
6292     }
6293   }
6294   if (argc == 2) {
6295     int _v;
6296     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
6297     _v = SWIG_CheckState(res);
6298     if (_v) {
6299       {
6300         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6301         _v = SWIG_CheckState(res);
6302       }
6303       if (_v) {
6304         return _wrap_VectorHexas___delitem____SWIG_0(self, args);
6305       }
6306     }
6307   }
6308
6309 fail:
6310   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas___delitem__'.\n"
6311     "  Possible C/C++ prototypes are:\n"
6312     "    __delitem__(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::difference_type)\n"
6313     "    __delitem__(std::vector< Hex::Hexa * > *,PySliceObject *)\n");
6314   return NULL;
6315 }
6316
6317
6318 SWIGINTERN PyObject *_wrap_VectorHexas___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6319   PyObject *resultobj = 0;
6320   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6321   std::vector< Hex::Hexa * >::difference_type arg2 ;
6322   void *argp1 = 0 ;
6323   int res1 = 0 ;
6324   ptrdiff_t val2 ;
6325   int ecode2 = 0 ;
6326   PyObject * obj0 = 0 ;
6327   PyObject * obj1 = 0 ;
6328   std::vector< Hex::Hexa * >::value_type result;
6329
6330   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___getitem__",&obj0,&obj1)) SWIG_fail;
6331   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6332   if (!SWIG_IsOK(res1)) {
6333     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6334   }
6335   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6336   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6337   if (!SWIG_IsOK(ecode2)) {
6338     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6339   }
6340   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
6341   try {
6342     result = (std::vector< Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_1(arg1,arg2);
6343   }
6344   catch(std::out_of_range &_e) {
6345     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6346   }
6347
6348   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
6349   return resultobj;
6350 fail:
6351   return NULL;
6352 }
6353
6354
6355 SWIGINTERN PyObject *_wrap_VectorHexas___getitem__(PyObject *self, PyObject *args) {
6356   int argc;
6357   PyObject *argv[3];
6358   int ii;
6359
6360   if (!PyTuple_Check(args)) SWIG_fail;
6361   argc = (int)PyObject_Length(args);
6362   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
6363     argv[ii] = PyTuple_GET_ITEM(args,ii);
6364   }
6365   if (argc == 2) {
6366     int _v;
6367     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
6368     _v = SWIG_CheckState(res);
6369     if (_v) {
6370       {
6371         _v = PySlice_Check(argv[1]);
6372       }
6373       if (_v) {
6374         return _wrap_VectorHexas___getitem____SWIG_0(self, args);
6375       }
6376     }
6377   }
6378   if (argc == 2) {
6379     int _v;
6380     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
6381     _v = SWIG_CheckState(res);
6382     if (_v) {
6383       {
6384         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6385         _v = SWIG_CheckState(res);
6386       }
6387       if (_v) {
6388         return _wrap_VectorHexas___getitem____SWIG_1(self, args);
6389       }
6390     }
6391   }
6392
6393 fail:
6394   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas___getitem__'.\n"
6395     "  Possible C/C++ prototypes are:\n"
6396     "    __getitem__(std::vector< Hex::Hexa * > *,PySliceObject *)\n"
6397     "    __getitem__(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::difference_type)\n");
6398   return NULL;
6399 }
6400
6401
6402 SWIGINTERN PyObject *_wrap_VectorHexas___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6403   PyObject *resultobj = 0;
6404   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6405   std::vector< Hex::Hexa * >::difference_type arg2 ;
6406   std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
6407   void *argp1 = 0 ;
6408   int res1 = 0 ;
6409   ptrdiff_t val2 ;
6410   int ecode2 = 0 ;
6411   void *argp3 = 0 ;
6412   int res3 = 0 ;
6413   PyObject * obj0 = 0 ;
6414   PyObject * obj1 = 0 ;
6415   PyObject * obj2 = 0 ;
6416
6417   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
6418   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6419   if (!SWIG_IsOK(res1)) {
6420     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6421   }
6422   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6423   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6424   if (!SWIG_IsOK(ecode2)) {
6425     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6426   }
6427   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
6428   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
6429   if (!SWIG_IsOK(res3)) {
6430     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
6431   }
6432   arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
6433   try {
6434     std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_1(arg1,arg2,arg3);
6435   }
6436   catch(std::out_of_range &_e) {
6437     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6438   }
6439
6440   resultobj = SWIG_Py_Void();
6441   return resultobj;
6442 fail:
6443   return NULL;
6444 }
6445
6446
6447 SWIGINTERN PyObject *_wrap_VectorHexas___setitem__(PyObject *self, PyObject *args) {
6448   int argc;
6449   PyObject *argv[4];
6450   int ii;
6451
6452   if (!PyTuple_Check(args)) SWIG_fail;
6453   argc = (int)PyObject_Length(args);
6454   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6455     argv[ii] = PyTuple_GET_ITEM(args,ii);
6456   }
6457   if (argc == 3) {
6458     int _v;
6459     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
6460     _v = SWIG_CheckState(res);
6461     if (_v) {
6462       {
6463         _v = PySlice_Check(argv[1]);
6464       }
6465       if (_v) {
6466         int res = swig::asptr(argv[2], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
6467         _v = SWIG_CheckState(res);
6468         if (_v) {
6469           return _wrap_VectorHexas___setitem____SWIG_0(self, args);
6470         }
6471       }
6472     }
6473   }
6474   if (argc == 3) {
6475     int _v;
6476     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
6477     _v = SWIG_CheckState(res);
6478     if (_v) {
6479       {
6480         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6481         _v = SWIG_CheckState(res);
6482       }
6483       if (_v) {
6484         void *vptr = 0;
6485         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0);
6486         _v = SWIG_CheckState(res);
6487         if (_v) {
6488           return _wrap_VectorHexas___setitem____SWIG_1(self, args);
6489         }
6490       }
6491     }
6492   }
6493
6494 fail:
6495   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas___setitem__'.\n"
6496     "  Possible C/C++ prototypes are:\n"
6497     "    __setitem__(std::vector< Hex::Hexa * > *,PySliceObject *,std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)\n"
6498     "    __setitem__(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::difference_type,std::vector< Hex::Hexa * >::value_type)\n");
6499   return NULL;
6500 }
6501
6502
6503 SWIGINTERN PyObject *_wrap_VectorHexas_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6504   PyObject *resultobj = 0;
6505   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6506   std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
6507   void *argp1 = 0 ;
6508   int res1 = 0 ;
6509   void *argp2 = 0 ;
6510   int res2 = 0 ;
6511   PyObject * obj0 = 0 ;
6512   PyObject * obj1 = 0 ;
6513
6514   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_append",&obj0,&obj1)) SWIG_fail;
6515   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6516   if (!SWIG_IsOK(res1)) {
6517     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_append" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6518   }
6519   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6520   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
6521   if (!SWIG_IsOK(res2)) {
6522     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_append" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
6523   }
6524   arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
6525   std_vector_Sl_Hex_Hexa_Sm__Sg__append(arg1,arg2);
6526   resultobj = SWIG_Py_Void();
6527   return resultobj;
6528 fail:
6529   return NULL;
6530 }
6531
6532
6533 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6534   PyObject *resultobj = 0;
6535   std::vector< Hex::Hexa * > *result = 0 ;
6536
6537   if (!PyArg_ParseTuple(args,(char *)":new_VectorHexas")) SWIG_fail;
6538   result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >();
6539   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
6540   return resultobj;
6541 fail:
6542   return NULL;
6543 }
6544
6545
6546 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6547   PyObject *resultobj = 0;
6548   std::vector< Hex::Hexa * > *arg1 = 0 ;
6549   int res1 = SWIG_OLDOBJ ;
6550   PyObject * obj0 = 0 ;
6551   std::vector< Hex::Hexa * > *result = 0 ;
6552
6553   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
6554   {
6555     std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
6556     res1 = swig::asptr(obj0, &ptr);
6557     if (!SWIG_IsOK(res1)) {
6558       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const &""'");
6559     }
6560     if (!ptr) {
6561       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const &""'");
6562     }
6563     arg1 = ptr;
6564   }
6565   result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >((std::vector< Hex::Hexa * > const &)*arg1);
6566   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
6567   if (SWIG_IsNewObj(res1)) delete arg1;
6568   return resultobj;
6569 fail:
6570   if (SWIG_IsNewObj(res1)) delete arg1;
6571   return NULL;
6572 }
6573
6574
6575 SWIGINTERN PyObject *_wrap_VectorHexas_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6576   PyObject *resultobj = 0;
6577   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6578   void *argp1 = 0 ;
6579   int res1 = 0 ;
6580   PyObject * obj0 = 0 ;
6581   bool result;
6582
6583   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_empty",&obj0)) SWIG_fail;
6584   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6585   if (!SWIG_IsOK(res1)) {
6586     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_empty" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6587   }
6588   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6589   result = (bool)((std::vector< Hex::Hexa * > const *)arg1)->empty();
6590   resultobj = SWIG_From_bool(static_cast< bool >(result));
6591   return resultobj;
6592 fail:
6593   return NULL;
6594 }
6595
6596
6597 SWIGINTERN PyObject *_wrap_VectorHexas_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6598   PyObject *resultobj = 0;
6599   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6600   void *argp1 = 0 ;
6601   int res1 = 0 ;
6602   PyObject * obj0 = 0 ;
6603   std::vector< Hex::Hexa * >::size_type result;
6604
6605   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_size",&obj0)) SWIG_fail;
6606   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6607   if (!SWIG_IsOK(res1)) {
6608     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_size" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6609   }
6610   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6611   result = ((std::vector< Hex::Hexa * > const *)arg1)->size();
6612   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6613   return resultobj;
6614 fail:
6615   return NULL;
6616 }
6617
6618
6619 SWIGINTERN PyObject *_wrap_VectorHexas_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6620   PyObject *resultobj = 0;
6621   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6622   void *argp1 = 0 ;
6623   int res1 = 0 ;
6624   PyObject * obj0 = 0 ;
6625
6626   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_clear",&obj0)) SWIG_fail;
6627   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6628   if (!SWIG_IsOK(res1)) {
6629     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_clear" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6630   }
6631   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6632   (arg1)->clear();
6633   resultobj = SWIG_Py_Void();
6634   return resultobj;
6635 fail:
6636   return NULL;
6637 }
6638
6639
6640 SWIGINTERN PyObject *_wrap_VectorHexas_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6641   PyObject *resultobj = 0;
6642   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6643   std::vector< Hex::Hexa * > *arg2 = 0 ;
6644   void *argp1 = 0 ;
6645   int res1 = 0 ;
6646   void *argp2 = 0 ;
6647   int res2 = 0 ;
6648   PyObject * obj0 = 0 ;
6649   PyObject * obj1 = 0 ;
6650
6651   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_swap",&obj0,&obj1)) SWIG_fail;
6652   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6653   if (!SWIG_IsOK(res1)) {
6654     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_swap" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6655   }
6656   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6657   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t,  0 );
6658   if (!SWIG_IsOK(res2)) {
6659     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector< Hex::Hexa * > &""'");
6660   }
6661   if (!argp2) {
6662     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector< Hex::Hexa * > &""'");
6663   }
6664   arg2 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp2);
6665   (arg1)->swap(*arg2);
6666   resultobj = SWIG_Py_Void();
6667   return resultobj;
6668 fail:
6669   return NULL;
6670 }
6671
6672
6673 SWIGINTERN PyObject *_wrap_VectorHexas_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6674   PyObject *resultobj = 0;
6675   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6676   void *argp1 = 0 ;
6677   int res1 = 0 ;
6678   PyObject * obj0 = 0 ;
6679   SwigValueWrapper< std::allocator< Hex::Hexa * > > result;
6680
6681   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_get_allocator",&obj0)) SWIG_fail;
6682   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6683   if (!SWIG_IsOK(res1)) {
6684     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6685   }
6686   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6687   result = ((std::vector< Hex::Hexa * > const *)arg1)->get_allocator();
6688   resultobj = SWIG_NewPointerObj((new std::vector< Hex::Hexa * >::allocator_type(static_cast< const std::vector< Hex::Hexa * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
6689   return resultobj;
6690 fail:
6691   return NULL;
6692 }
6693
6694
6695 SWIGINTERN PyObject *_wrap_VectorHexas_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6696   PyObject *resultobj = 0;
6697   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6698   void *argp1 = 0 ;
6699   int res1 = 0 ;
6700   PyObject * obj0 = 0 ;
6701   std::vector< Hex::Hexa * >::const_iterator result;
6702
6703   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_begin",&obj0)) SWIG_fail;
6704   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6705   if (!SWIG_IsOK(res1)) {
6706     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_begin" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6707   }
6708   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6709   result = ((std::vector< Hex::Hexa * > const *)arg1)->begin();
6710   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::const_iterator & >(result)),
6711     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
6712   return resultobj;
6713 fail:
6714   return NULL;
6715 }
6716
6717
6718 SWIGINTERN PyObject *_wrap_VectorHexas_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6719   PyObject *resultobj = 0;
6720   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6721   void *argp1 = 0 ;
6722   int res1 = 0 ;
6723   PyObject * obj0 = 0 ;
6724   std::vector< Hex::Hexa * >::const_iterator result;
6725
6726   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_end",&obj0)) SWIG_fail;
6727   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6728   if (!SWIG_IsOK(res1)) {
6729     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_end" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6730   }
6731   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6732   result = ((std::vector< Hex::Hexa * > const *)arg1)->end();
6733   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::const_iterator & >(result)),
6734     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
6735   return resultobj;
6736 fail:
6737   return NULL;
6738 }
6739
6740
6741 SWIGINTERN PyObject *_wrap_VectorHexas_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6742   PyObject *resultobj = 0;
6743   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6744   void *argp1 = 0 ;
6745   int res1 = 0 ;
6746   PyObject * obj0 = 0 ;
6747   std::vector< Hex::Hexa * >::const_reverse_iterator result;
6748
6749   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rbegin",&obj0)) SWIG_fail;
6750   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6751   if (!SWIG_IsOK(res1)) {
6752     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6753   }
6754   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6755   result = ((std::vector< Hex::Hexa * > const *)arg1)->rbegin();
6756   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::const_reverse_iterator & >(result)),
6757     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
6758   return resultobj;
6759 fail:
6760   return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_VectorHexas_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6765   PyObject *resultobj = 0;
6766   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6767   void *argp1 = 0 ;
6768   int res1 = 0 ;
6769   PyObject * obj0 = 0 ;
6770   std::vector< Hex::Hexa * >::const_reverse_iterator result;
6771
6772   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rend",&obj0)) SWIG_fail;
6773   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6774   if (!SWIG_IsOK(res1)) {
6775     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rend" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6776   }
6777   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6778   result = ((std::vector< Hex::Hexa * > const *)arg1)->rend();
6779   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::const_reverse_iterator & >(result)),
6780     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
6781   return resultobj;
6782 fail:
6783   return NULL;
6784 }
6785
6786
6787 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6788   PyObject *resultobj = 0;
6789   std::vector< Hex::Hexa * >::size_type arg1 ;
6790   size_t val1 ;
6791   int ecode1 = 0 ;
6792   PyObject * obj0 = 0 ;
6793   std::vector< Hex::Hexa * > *result = 0 ;
6794
6795   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
6796   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
6797   if (!SWIG_IsOK(ecode1)) {
6798     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
6799   }
6800   arg1 = static_cast< std::vector< Hex::Hexa * >::size_type >(val1);
6801   result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >(arg1);
6802   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
6803   return resultobj;
6804 fail:
6805   return NULL;
6806 }
6807
6808
6809 SWIGINTERN PyObject *_wrap_VectorHexas_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6810   PyObject *resultobj = 0;
6811   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6812   void *argp1 = 0 ;
6813   int res1 = 0 ;
6814   PyObject * obj0 = 0 ;
6815
6816   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop_back",&obj0)) SWIG_fail;
6817   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6818   if (!SWIG_IsOK(res1)) {
6819     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6820   }
6821   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6822   (arg1)->pop_back();
6823   resultobj = SWIG_Py_Void();
6824   return resultobj;
6825 fail:
6826   return NULL;
6827 }
6828
6829
6830 SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6831   PyObject *resultobj = 0;
6832   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6833   std::vector< Hex::Hexa * >::size_type arg2 ;
6834   void *argp1 = 0 ;
6835   int res1 = 0 ;
6836   size_t val2 ;
6837   int ecode2 = 0 ;
6838   PyObject * obj0 = 0 ;
6839   PyObject * obj1 = 0 ;
6840
6841   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_resize",&obj0,&obj1)) SWIG_fail;
6842   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6843   if (!SWIG_IsOK(res1)) {
6844     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6845   }
6846   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6847   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6848   if (!SWIG_IsOK(ecode2)) {
6849     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
6850   }
6851   arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
6852   (arg1)->resize(arg2);
6853   resultobj = SWIG_Py_Void();
6854   return resultobj;
6855 fail:
6856   return NULL;
6857 }
6858
6859
6860 SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6861   PyObject *resultobj = 0;
6862   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6863   std::vector< Hex::Hexa * >::iterator arg2 ;
6864   void *argp1 = 0 ;
6865   int res1 = 0 ;
6866   swig::SwigPyIterator *iter2 = 0 ;
6867   int res2 ;
6868   PyObject * obj0 = 0 ;
6869   PyObject * obj1 = 0 ;
6870   std::vector< Hex::Hexa * >::iterator result;
6871
6872   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_erase",&obj0,&obj1)) SWIG_fail;
6873   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6874   if (!SWIG_IsOK(res1)) {
6875     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6876   }
6877   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6878   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
6879   if (!SWIG_IsOK(res2) || !iter2) {
6880     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
6881   } else {
6882     swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
6883     if (iter_t) {
6884       arg2 = iter_t->get_current();
6885     } else {
6886       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
6887     }
6888   }
6889   result = (arg1)->erase(arg2);
6890   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
6891     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
6892   return resultobj;
6893 fail:
6894   return NULL;
6895 }
6896
6897
6898 SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6899   PyObject *resultobj = 0;
6900   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6901   std::vector< Hex::Hexa * >::iterator arg2 ;
6902   std::vector< Hex::Hexa * >::iterator arg3 ;
6903   void *argp1 = 0 ;
6904   int res1 = 0 ;
6905   swig::SwigPyIterator *iter2 = 0 ;
6906   int res2 ;
6907   swig::SwigPyIterator *iter3 = 0 ;
6908   int res3 ;
6909   PyObject * obj0 = 0 ;
6910   PyObject * obj1 = 0 ;
6911   PyObject * obj2 = 0 ;
6912   std::vector< Hex::Hexa * >::iterator result;
6913
6914   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_erase",&obj0,&obj1,&obj2)) SWIG_fail;
6915   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6916   if (!SWIG_IsOK(res1)) {
6917     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6918   }
6919   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6920   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
6921   if (!SWIG_IsOK(res2) || !iter2) {
6922     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
6923   } else {
6924     swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
6925     if (iter_t) {
6926       arg2 = iter_t->get_current();
6927     } else {
6928       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
6929     }
6930   }
6931   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
6932   if (!SWIG_IsOK(res3) || !iter3) {
6933     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
6934   } else {
6935     swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter3);
6936     if (iter_t) {
6937       arg3 = iter_t->get_current();
6938     } else {
6939       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
6940     }
6941   }
6942   result = (arg1)->erase(arg2,arg3);
6943   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
6944     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
6945   return resultobj;
6946 fail:
6947   return NULL;
6948 }
6949
6950
6951 SWIGINTERN PyObject *_wrap_VectorHexas_erase(PyObject *self, PyObject *args) {
6952   int argc;
6953   PyObject *argv[4];
6954   int ii;
6955
6956   if (!PyTuple_Check(args)) SWIG_fail;
6957   argc = (int)PyObject_Length(args);
6958   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6959     argv[ii] = PyTuple_GET_ITEM(args,ii);
6960   }
6961   if (argc == 2) {
6962     int _v;
6963     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
6964     _v = SWIG_CheckState(res);
6965     if (_v) {
6966       swig::SwigPyIterator *iter = 0;
6967       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
6968       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
6969       if (_v) {
6970         return _wrap_VectorHexas_erase__SWIG_0(self, args);
6971       }
6972     }
6973   }
6974   if (argc == 3) {
6975     int _v;
6976     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
6977     _v = SWIG_CheckState(res);
6978     if (_v) {
6979       swig::SwigPyIterator *iter = 0;
6980       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
6981       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
6982       if (_v) {
6983         swig::SwigPyIterator *iter = 0;
6984         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
6985         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
6986         if (_v) {
6987           return _wrap_VectorHexas_erase__SWIG_1(self, args);
6988         }
6989       }
6990     }
6991   }
6992
6993 fail:
6994   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_erase'.\n"
6995     "  Possible C/C++ prototypes are:\n"
6996     "    erase(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::iterator)\n"
6997     "    erase(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::iterator)\n");
6998   return NULL;
6999 }
7000
7001
7002 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7003   PyObject *resultobj = 0;
7004   std::vector< Hex::Hexa * >::size_type arg1 ;
7005   std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
7006   size_t val1 ;
7007   int ecode1 = 0 ;
7008   void *argp2 = 0 ;
7009   int res2 = 0 ;
7010   PyObject * obj0 = 0 ;
7011   PyObject * obj1 = 0 ;
7012   std::vector< Hex::Hexa * > *result = 0 ;
7013
7014   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorHexas",&obj0,&obj1)) SWIG_fail;
7015   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
7016   if (!SWIG_IsOK(ecode1)) {
7017     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
7018   }
7019   arg1 = static_cast< std::vector< Hex::Hexa * >::size_type >(val1);
7020   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
7021   if (!SWIG_IsOK(res2)) {
7022     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorHexas" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
7023   }
7024   arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
7025   result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >(arg1,arg2);
7026   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
7027   return resultobj;
7028 fail:
7029   return NULL;
7030 }
7031
7032
7033 SWIGINTERN PyObject *_wrap_new_VectorHexas(PyObject *self, PyObject *args) {
7034   int argc;
7035   PyObject *argv[3];
7036   int ii;
7037
7038   if (!PyTuple_Check(args)) SWIG_fail;
7039   argc = (int)PyObject_Length(args);
7040   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7041     argv[ii] = PyTuple_GET_ITEM(args,ii);
7042   }
7043   if (argc == 0) {
7044     return _wrap_new_VectorHexas__SWIG_0(self, args);
7045   }
7046   if (argc == 1) {
7047     int _v;
7048     {
7049       int res = SWIG_AsVal_size_t(argv[0], NULL);
7050       _v = SWIG_CheckState(res);
7051     }
7052     if (_v) {
7053       return _wrap_new_VectorHexas__SWIG_2(self, args);
7054     }
7055   }
7056   if (argc == 1) {
7057     int _v;
7058     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7059     _v = SWIG_CheckState(res);
7060     if (_v) {
7061       return _wrap_new_VectorHexas__SWIG_1(self, args);
7062     }
7063   }
7064   if (argc == 2) {
7065     int _v;
7066     {
7067       int res = SWIG_AsVal_size_t(argv[0], NULL);
7068       _v = SWIG_CheckState(res);
7069     }
7070     if (_v) {
7071       void *vptr = 0;
7072       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0);
7073       _v = SWIG_CheckState(res);
7074       if (_v) {
7075         return _wrap_new_VectorHexas__SWIG_3(self, args);
7076       }
7077     }
7078   }
7079
7080 fail:
7081   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorHexas'.\n"
7082     "  Possible C/C++ prototypes are:\n"
7083     "    std::vector< Hex::Hexa * >()\n"
7084     "    std::vector< Hex::Hexa * >(std::vector< Hex::Hexa * > const &)\n"
7085     "    std::vector< Hex::Hexa * >(std::vector< Hex::Hexa * >::size_type)\n"
7086     "    std::vector< Hex::Hexa * >(std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
7087   return NULL;
7088 }
7089
7090
7091 SWIGINTERN PyObject *_wrap_VectorHexas_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7092   PyObject *resultobj = 0;
7093   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7094   std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
7095   void *argp1 = 0 ;
7096   int res1 = 0 ;
7097   void *argp2 = 0 ;
7098   int res2 = 0 ;
7099   PyObject * obj0 = 0 ;
7100   PyObject * obj1 = 0 ;
7101
7102   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_push_back",&obj0,&obj1)) SWIG_fail;
7103   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7104   if (!SWIG_IsOK(res1)) {
7105     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_push_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7106   }
7107   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7108   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
7109   if (!SWIG_IsOK(res2)) {
7110     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_push_back" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
7111   }
7112   arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
7113   (arg1)->push_back(arg2);
7114   resultobj = SWIG_Py_Void();
7115   return resultobj;
7116 fail:
7117   return NULL;
7118 }
7119
7120
7121 SWIGINTERN PyObject *_wrap_VectorHexas_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7122   PyObject *resultobj = 0;
7123   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7124   void *argp1 = 0 ;
7125   int res1 = 0 ;
7126   PyObject * obj0 = 0 ;
7127   std::vector< Hex::Hexa * >::value_type result;
7128
7129   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_front",&obj0)) SWIG_fail;
7130   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7131   if (!SWIG_IsOK(res1)) {
7132     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_front" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
7133   }
7134   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7135   result = (std::vector< Hex::Hexa * >::value_type)((std::vector< Hex::Hexa * > const *)arg1)->front();
7136   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
7137   return resultobj;
7138 fail:
7139   return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_VectorHexas_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7144   PyObject *resultobj = 0;
7145   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7146   void *argp1 = 0 ;
7147   int res1 = 0 ;
7148   PyObject * obj0 = 0 ;
7149   std::vector< Hex::Hexa * >::value_type result;
7150
7151   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_back",&obj0)) SWIG_fail;
7152   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7153   if (!SWIG_IsOK(res1)) {
7154     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
7155   }
7156   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7157   result = (std::vector< Hex::Hexa * >::value_type)((std::vector< Hex::Hexa * > const *)arg1)->back();
7158   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
7159   return resultobj;
7160 fail:
7161   return NULL;
7162 }
7163
7164
7165 SWIGINTERN PyObject *_wrap_VectorHexas_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7166   PyObject *resultobj = 0;
7167   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7168   std::vector< Hex::Hexa * >::size_type arg2 ;
7169   std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
7170   void *argp1 = 0 ;
7171   int res1 = 0 ;
7172   size_t val2 ;
7173   int ecode2 = 0 ;
7174   void *argp3 = 0 ;
7175   int res3 = 0 ;
7176   PyObject * obj0 = 0 ;
7177   PyObject * obj1 = 0 ;
7178   PyObject * obj2 = 0 ;
7179
7180   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_assign",&obj0,&obj1,&obj2)) SWIG_fail;
7181   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7182   if (!SWIG_IsOK(res1)) {
7183     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_assign" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7184   }
7185   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7186   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7187   if (!SWIG_IsOK(ecode2)) {
7188     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_assign" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
7189   }
7190   arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
7191   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
7192   if (!SWIG_IsOK(res3)) {
7193     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_assign" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
7194   }
7195   arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
7196   (arg1)->assign(arg2,arg3);
7197   resultobj = SWIG_Py_Void();
7198   return resultobj;
7199 fail:
7200   return NULL;
7201 }
7202
7203
7204 SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7205   PyObject *resultobj = 0;
7206   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7207   std::vector< Hex::Hexa * >::size_type arg2 ;
7208   std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
7209   void *argp1 = 0 ;
7210   int res1 = 0 ;
7211   size_t val2 ;
7212   int ecode2 = 0 ;
7213   void *argp3 = 0 ;
7214   int res3 = 0 ;
7215   PyObject * obj0 = 0 ;
7216   PyObject * obj1 = 0 ;
7217   PyObject * obj2 = 0 ;
7218
7219   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_resize",&obj0,&obj1,&obj2)) SWIG_fail;
7220   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7221   if (!SWIG_IsOK(res1)) {
7222     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7223   }
7224   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7225   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7226   if (!SWIG_IsOK(ecode2)) {
7227     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
7228   }
7229   arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
7230   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
7231   if (!SWIG_IsOK(res3)) {
7232     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_resize" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
7233   }
7234   arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
7235   (arg1)->resize(arg2,arg3);
7236   resultobj = SWIG_Py_Void();
7237   return resultobj;
7238 fail:
7239   return NULL;
7240 }
7241
7242
7243 SWIGINTERN PyObject *_wrap_VectorHexas_resize(PyObject *self, PyObject *args) {
7244   int argc;
7245   PyObject *argv[4];
7246   int ii;
7247
7248   if (!PyTuple_Check(args)) SWIG_fail;
7249   argc = (int)PyObject_Length(args);
7250   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
7251     argv[ii] = PyTuple_GET_ITEM(args,ii);
7252   }
7253   if (argc == 2) {
7254     int _v;
7255     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7256     _v = SWIG_CheckState(res);
7257     if (_v) {
7258       {
7259         int res = SWIG_AsVal_size_t(argv[1], NULL);
7260         _v = SWIG_CheckState(res);
7261       }
7262       if (_v) {
7263         return _wrap_VectorHexas_resize__SWIG_0(self, args);
7264       }
7265     }
7266   }
7267   if (argc == 3) {
7268     int _v;
7269     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7270     _v = SWIG_CheckState(res);
7271     if (_v) {
7272       {
7273         int res = SWIG_AsVal_size_t(argv[1], NULL);
7274         _v = SWIG_CheckState(res);
7275       }
7276       if (_v) {
7277         void *vptr = 0;
7278         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0);
7279         _v = SWIG_CheckState(res);
7280         if (_v) {
7281           return _wrap_VectorHexas_resize__SWIG_1(self, args);
7282         }
7283       }
7284     }
7285   }
7286
7287 fail:
7288   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_resize'.\n"
7289     "  Possible C/C++ prototypes are:\n"
7290     "    resize(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::size_type)\n"
7291     "    resize(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
7292   return NULL;
7293 }
7294
7295
7296 SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7297   PyObject *resultobj = 0;
7298   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7299   std::vector< Hex::Hexa * >::iterator arg2 ;
7300   std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
7301   void *argp1 = 0 ;
7302   int res1 = 0 ;
7303   swig::SwigPyIterator *iter2 = 0 ;
7304   int res2 ;
7305   void *argp3 = 0 ;
7306   int res3 = 0 ;
7307   PyObject * obj0 = 0 ;
7308   PyObject * obj1 = 0 ;
7309   PyObject * obj2 = 0 ;
7310   std::vector< Hex::Hexa * >::iterator result;
7311
7312   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_insert",&obj0,&obj1,&obj2)) SWIG_fail;
7313   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7314   if (!SWIG_IsOK(res1)) {
7315     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7316   }
7317   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7318   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
7319   if (!SWIG_IsOK(res2) || !iter2) {
7320     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7321   } else {
7322     swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
7323     if (iter_t) {
7324       arg2 = iter_t->get_current();
7325     } else {
7326       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7327     }
7328   }
7329   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
7330   if (!SWIG_IsOK(res3)) {
7331     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
7332   }
7333   arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
7334   result = (arg1)->insert(arg2,arg3);
7335   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
7336     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7337   return resultobj;
7338 fail:
7339   return NULL;
7340 }
7341
7342
7343 SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7344   PyObject *resultobj = 0;
7345   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7346   std::vector< Hex::Hexa * >::iterator arg2 ;
7347   std::vector< Hex::Hexa * >::size_type arg3 ;
7348   std::vector< Hex::Hexa * >::value_type arg4 = (std::vector< Hex::Hexa * >::value_type) 0 ;
7349   void *argp1 = 0 ;
7350   int res1 = 0 ;
7351   swig::SwigPyIterator *iter2 = 0 ;
7352   int res2 ;
7353   size_t val3 ;
7354   int ecode3 = 0 ;
7355   void *argp4 = 0 ;
7356   int res4 = 0 ;
7357   PyObject * obj0 = 0 ;
7358   PyObject * obj1 = 0 ;
7359   PyObject * obj2 = 0 ;
7360   PyObject * obj3 = 0 ;
7361
7362   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7363   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7364   if (!SWIG_IsOK(res1)) {
7365     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7366   }
7367   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7368   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
7369   if (!SWIG_IsOK(res2) || !iter2) {
7370     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7371   } else {
7372     swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
7373     if (iter_t) {
7374       arg2 = iter_t->get_current();
7375     } else {
7376       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7377     }
7378   }
7379   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
7380   if (!SWIG_IsOK(ecode3)) {
7381     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
7382   }
7383   arg3 = static_cast< std::vector< Hex::Hexa * >::size_type >(val3);
7384   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0 |  0 );
7385   if (!SWIG_IsOK(res4)) {
7386     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas_insert" "', argument " "4"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
7387   }
7388   arg4 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp4);
7389   (arg1)->insert(arg2,arg3,arg4);
7390   resultobj = SWIG_Py_Void();
7391   return resultobj;
7392 fail:
7393   return NULL;
7394 }
7395
7396
7397 SWIGINTERN PyObject *_wrap_VectorHexas_insert(PyObject *self, PyObject *args) {
7398   int argc;
7399   PyObject *argv[5];
7400   int ii;
7401
7402   if (!PyTuple_Check(args)) SWIG_fail;
7403   argc = (int)PyObject_Length(args);
7404   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
7405     argv[ii] = PyTuple_GET_ITEM(args,ii);
7406   }
7407   if (argc == 3) {
7408     int _v;
7409     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7410     _v = SWIG_CheckState(res);
7411     if (_v) {
7412       swig::SwigPyIterator *iter = 0;
7413       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
7414       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
7415       if (_v) {
7416         void *vptr = 0;
7417         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0);
7418         _v = SWIG_CheckState(res);
7419         if (_v) {
7420           return _wrap_VectorHexas_insert__SWIG_0(self, args);
7421         }
7422       }
7423     }
7424   }
7425   if (argc == 4) {
7426     int _v;
7427     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7428     _v = SWIG_CheckState(res);
7429     if (_v) {
7430       swig::SwigPyIterator *iter = 0;
7431       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
7432       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
7433       if (_v) {
7434         {
7435           int res = SWIG_AsVal_size_t(argv[2], NULL);
7436           _v = SWIG_CheckState(res);
7437         }
7438         if (_v) {
7439           void *vptr = 0;
7440           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0);
7441           _v = SWIG_CheckState(res);
7442           if (_v) {
7443             return _wrap_VectorHexas_insert__SWIG_1(self, args);
7444           }
7445         }
7446       }
7447     }
7448   }
7449
7450 fail:
7451   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_insert'.\n"
7452     "  Possible C/C++ prototypes are:\n"
7453     "    insert(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::value_type)\n"
7454     "    insert(std::vector< Hex::Hexa * > *,std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
7455   return NULL;
7456 }
7457
7458
7459 SWIGINTERN PyObject *_wrap_VectorHexas_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7460   PyObject *resultobj = 0;
7461   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7462   std::vector< Hex::Hexa * >::size_type arg2 ;
7463   void *argp1 = 0 ;
7464   int res1 = 0 ;
7465   size_t val2 ;
7466   int ecode2 = 0 ;
7467   PyObject * obj0 = 0 ;
7468   PyObject * obj1 = 0 ;
7469
7470   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_reserve",&obj0,&obj1)) SWIG_fail;
7471   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7472   if (!SWIG_IsOK(res1)) {
7473     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_reserve" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7474   }
7475   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7476   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7477   if (!SWIG_IsOK(ecode2)) {
7478     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_reserve" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
7479   }
7480   arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
7481   (arg1)->reserve(arg2);
7482   resultobj = SWIG_Py_Void();
7483   return resultobj;
7484 fail:
7485   return NULL;
7486 }
7487
7488
7489 SWIGINTERN PyObject *_wrap_VectorHexas_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7490   PyObject *resultobj = 0;
7491   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7492   void *argp1 = 0 ;
7493   int res1 = 0 ;
7494   PyObject * obj0 = 0 ;
7495   std::vector< Hex::Hexa * >::size_type result;
7496
7497   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_capacity",&obj0)) SWIG_fail;
7498   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7499   if (!SWIG_IsOK(res1)) {
7500     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_capacity" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
7501   }
7502   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7503   result = ((std::vector< Hex::Hexa * > const *)arg1)->capacity();
7504   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7505   return resultobj;
7506 fail:
7507   return NULL;
7508 }
7509
7510
7511 SWIGINTERN PyObject *_wrap_delete_VectorHexas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7512   PyObject *resultobj = 0;
7513   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7514   void *argp1 = 0 ;
7515   int res1 = 0 ;
7516   PyObject * obj0 = 0 ;
7517
7518   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorHexas",&obj0)) SWIG_fail;
7519   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_DISOWN |  0 );
7520   if (!SWIG_IsOK(res1)) {
7521     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7522   }
7523   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7524   delete arg1;
7525   resultobj = SWIG_Py_Void();
7526   return resultobj;
7527 fail:
7528   return NULL;
7529 }
7530
7531
7532 SWIGINTERN PyObject *VectorHexas_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7533   PyObject *obj;
7534   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
7535   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_NewClientData(obj));
7536   return SWIG_Py_Void();
7537 }
7538
7539 SWIGINTERN PyObject *_wrap_VectorQuads_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7540   PyObject *resultobj = 0;
7541   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7542   PyObject **arg2 = (PyObject **) 0 ;
7543   void *argp1 = 0 ;
7544   int res1 = 0 ;
7545   PyObject * obj0 = 0 ;
7546   swig::SwigPyIterator *result = 0 ;
7547
7548   arg2 = &obj0;
7549   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_iterator",&obj0)) SWIG_fail;
7550   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7551   if (!SWIG_IsOK(res1)) {
7552     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_iterator" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
7553   }
7554   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7555   result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Quad_Sm__Sg__iterator(arg1,arg2);
7556   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
7557   return resultobj;
7558 fail:
7559   return NULL;
7560 }
7561
7562
7563 SWIGINTERN PyObject *_wrap_VectorQuads___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7564   PyObject *resultobj = 0;
7565   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7566   void *argp1 = 0 ;
7567   int res1 = 0 ;
7568   PyObject * obj0 = 0 ;
7569   bool result;
7570
7571   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___nonzero__",&obj0)) SWIG_fail;
7572   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7573   if (!SWIG_IsOK(res1)) {
7574     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
7575   }
7576   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7577   result = (bool)std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__((std::vector< Hex::Quad * > const *)arg1);
7578   resultobj = SWIG_From_bool(static_cast< bool >(result));
7579   return resultobj;
7580 fail:
7581   return NULL;
7582 }
7583
7584
7585 SWIGINTERN PyObject *_wrap_VectorQuads___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7586   PyObject *resultobj = 0;
7587   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7588   void *argp1 = 0 ;
7589   int res1 = 0 ;
7590   PyObject * obj0 = 0 ;
7591   bool result;
7592
7593   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___bool__",&obj0)) SWIG_fail;
7594   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7595   if (!SWIG_IsOK(res1)) {
7596     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___bool__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
7597   }
7598   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7599   result = (bool)std_vector_Sl_Hex_Quad_Sm__Sg____bool__((std::vector< Hex::Quad * > const *)arg1);
7600   resultobj = SWIG_From_bool(static_cast< bool >(result));
7601   return resultobj;
7602 fail:
7603   return NULL;
7604 }
7605
7606
7607 SWIGINTERN PyObject *_wrap_VectorQuads___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7608   PyObject *resultobj = 0;
7609   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7610   void *argp1 = 0 ;
7611   int res1 = 0 ;
7612   PyObject * obj0 = 0 ;
7613   std::vector< Hex::Quad * >::size_type result;
7614
7615   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___len__",&obj0)) SWIG_fail;
7616   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7617   if (!SWIG_IsOK(res1)) {
7618     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___len__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
7619   }
7620   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7621   result = std_vector_Sl_Hex_Quad_Sm__Sg____len__((std::vector< Hex::Quad * > const *)arg1);
7622   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7623   return resultobj;
7624 fail:
7625   return NULL;
7626 }
7627
7628
7629 SWIGINTERN PyObject *_wrap_VectorQuads_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7630   PyObject *resultobj = 0;
7631   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7632   void *argp1 = 0 ;
7633   int res1 = 0 ;
7634   PyObject * obj0 = 0 ;
7635   std::vector< Hex::Quad * >::value_type result;
7636
7637   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop",&obj0)) SWIG_fail;
7638   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7639   if (!SWIG_IsOK(res1)) {
7640     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
7641   }
7642   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7643   try {
7644     result = (std::vector< Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg__pop(arg1);
7645   }
7646   catch(std::out_of_range &_e) {
7647     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7648   }
7649
7650   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
7651   return resultobj;
7652 fail:
7653   return NULL;
7654 }
7655
7656
7657 SWIGINTERN PyObject *_wrap_VectorQuads___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7658   PyObject *resultobj = 0;
7659   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7660   std::vector< Hex::Quad * >::difference_type arg2 ;
7661   std::vector< Hex::Quad * >::difference_type arg3 ;
7662   void *argp1 = 0 ;
7663   int res1 = 0 ;
7664   ptrdiff_t val2 ;
7665   int ecode2 = 0 ;
7666   ptrdiff_t val3 ;
7667   int ecode3 = 0 ;
7668   PyObject * obj0 = 0 ;
7669   PyObject * obj1 = 0 ;
7670   PyObject * obj2 = 0 ;
7671   std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *result = 0 ;
7672
7673   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7674   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7675   if (!SWIG_IsOK(res1)) {
7676     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
7677   }
7678   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7679   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7680   if (!SWIG_IsOK(ecode2)) {
7681     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
7682   }
7683   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
7684   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7685   if (!SWIG_IsOK(ecode3)) {
7686     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
7687   }
7688   arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
7689   try {
7690     result = (std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *)std_vector_Sl_Hex_Quad_Sm__Sg____getslice__(arg1,arg2,arg3);
7691   }
7692   catch(std::out_of_range &_e) {
7693     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7694   }
7695
7696   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_OWN |  0 );
7697   return resultobj;
7698 fail:
7699   return NULL;
7700 }
7701
7702
7703 SWIGINTERN PyObject *_wrap_VectorQuads___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7704   PyObject *resultobj = 0;
7705   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7706   std::vector< Hex::Quad * >::difference_type arg2 ;
7707   std::vector< Hex::Quad * >::difference_type arg3 ;
7708   std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *arg4 = 0 ;
7709   void *argp1 = 0 ;
7710   int res1 = 0 ;
7711   ptrdiff_t val2 ;
7712   int ecode2 = 0 ;
7713   ptrdiff_t val3 ;
7714   int ecode3 = 0 ;
7715   int res4 = SWIG_OLDOBJ ;
7716   PyObject * obj0 = 0 ;
7717   PyObject * obj1 = 0 ;
7718   PyObject * obj2 = 0 ;
7719   PyObject * obj3 = 0 ;
7720
7721   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7722   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7723   if (!SWIG_IsOK(res1)) {
7724     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
7725   }
7726   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7727   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7728   if (!SWIG_IsOK(ecode2)) {
7729     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
7730   }
7731   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
7732   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7733   if (!SWIG_IsOK(ecode3)) {
7734     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
7735   }
7736   arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
7737   {
7738     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
7739     res4 = swig::asptr(obj3, &ptr);
7740     if (!SWIG_IsOK(res4)) {
7741       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
7742     }
7743     if (!ptr) {
7744       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
7745     }
7746     arg4 = ptr;
7747   }
7748   try {
7749     std_vector_Sl_Hex_Quad_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)*arg4);
7750   }
7751   catch(std::out_of_range &_e) {
7752     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7753   }
7754   catch(std::invalid_argument &_e) {
7755     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7756   }
7757
7758   resultobj = SWIG_Py_Void();
7759   if (SWIG_IsNewObj(res4)) delete arg4;
7760   return resultobj;
7761 fail:
7762   if (SWIG_IsNewObj(res4)) delete arg4;
7763   return NULL;
7764 }
7765
7766
7767 SWIGINTERN PyObject *_wrap_VectorQuads___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7768   PyObject *resultobj = 0;
7769   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7770   std::vector< Hex::Quad * >::difference_type arg2 ;
7771   std::vector< Hex::Quad * >::difference_type arg3 ;
7772   void *argp1 = 0 ;
7773   int res1 = 0 ;
7774   ptrdiff_t val2 ;
7775   int ecode2 = 0 ;
7776   ptrdiff_t val3 ;
7777   int ecode3 = 0 ;
7778   PyObject * obj0 = 0 ;
7779   PyObject * obj1 = 0 ;
7780   PyObject * obj2 = 0 ;
7781
7782   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7783   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7784   if (!SWIG_IsOK(res1)) {
7785     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
7786   }
7787   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7788   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7789   if (!SWIG_IsOK(ecode2)) {
7790     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
7791   }
7792   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
7793   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7794   if (!SWIG_IsOK(ecode3)) {
7795     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
7796   }
7797   arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
7798   try {
7799     std_vector_Sl_Hex_Quad_Sm__Sg____delslice__(arg1,arg2,arg3);
7800   }
7801   catch(std::out_of_range &_e) {
7802     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7803   }
7804
7805   resultobj = SWIG_Py_Void();
7806   return resultobj;
7807 fail:
7808   return NULL;
7809 }
7810
7811
7812 SWIGINTERN PyObject *_wrap_VectorQuads___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7813   PyObject *resultobj = 0;
7814   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7815   std::vector< Hex::Quad * >::difference_type arg2 ;
7816   void *argp1 = 0 ;
7817   int res1 = 0 ;
7818   ptrdiff_t val2 ;
7819   int ecode2 = 0 ;
7820   PyObject * obj0 = 0 ;
7821   PyObject * obj1 = 0 ;
7822
7823   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___delitem__",&obj0,&obj1)) SWIG_fail;
7824   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7825   if (!SWIG_IsOK(res1)) {
7826     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
7827   }
7828   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7829   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7830   if (!SWIG_IsOK(ecode2)) {
7831     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
7832   }
7833   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
7834   try {
7835     std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_0(arg1,arg2);
7836   }
7837   catch(std::out_of_range &_e) {
7838     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7839   }
7840
7841   resultobj = SWIG_Py_Void();
7842   return resultobj;
7843 fail:
7844   return NULL;
7845 }
7846
7847
7848 SWIGINTERN PyObject *_wrap_VectorQuads___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7849   PyObject *resultobj = 0;
7850   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7851   PySliceObject *arg2 = (PySliceObject *) 0 ;
7852   void *argp1 = 0 ;
7853   int res1 = 0 ;
7854   PyObject * obj0 = 0 ;
7855   PyObject * obj1 = 0 ;
7856   std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *result = 0 ;
7857
7858   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___getitem__",&obj0,&obj1)) SWIG_fail;
7859   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7860   if (!SWIG_IsOK(res1)) {
7861     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
7862   }
7863   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7864   {
7865     arg2 = (PySliceObject *) obj1;
7866   }
7867   try {
7868     result = (std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *)std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_0(arg1,arg2);
7869   }
7870   catch(std::out_of_range &_e) {
7871     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7872   }
7873
7874   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7875   return resultobj;
7876 fail:
7877   return NULL;
7878 }
7879
7880
7881 SWIGINTERN PyObject *_wrap_VectorQuads___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7882   PyObject *resultobj = 0;
7883   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7884   PySliceObject *arg2 = (PySliceObject *) 0 ;
7885   std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *arg3 = 0 ;
7886   void *argp1 = 0 ;
7887   int res1 = 0 ;
7888   int res3 = SWIG_OLDOBJ ;
7889   PyObject * obj0 = 0 ;
7890   PyObject * obj1 = 0 ;
7891   PyObject * obj2 = 0 ;
7892
7893   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
7894   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7895   if (!SWIG_IsOK(res1)) {
7896     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
7897   }
7898   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7899   {
7900     arg2 = (PySliceObject *) obj1;
7901   }
7902   {
7903     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
7904     res3 = swig::asptr(obj2, &ptr);
7905     if (!SWIG_IsOK(res3)) {
7906       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
7907     }
7908     if (!ptr) {
7909       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
7910     }
7911     arg3 = ptr;
7912   }
7913   try {
7914     std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)*arg3);
7915   }
7916   catch(std::out_of_range &_e) {
7917     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7918   }
7919   catch(std::invalid_argument &_e) {
7920     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7921   }
7922
7923   resultobj = SWIG_Py_Void();
7924   if (SWIG_IsNewObj(res3)) delete arg3;
7925   return resultobj;
7926 fail:
7927   if (SWIG_IsNewObj(res3)) delete arg3;
7928   return NULL;
7929 }
7930
7931
7932 SWIGINTERN PyObject *_wrap_VectorQuads___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7933   PyObject *resultobj = 0;
7934   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
7935   PySliceObject *arg2 = (PySliceObject *) 0 ;
7936   void *argp1 = 0 ;
7937   int res1 = 0 ;
7938   PyObject * obj0 = 0 ;
7939   PyObject * obj1 = 0 ;
7940
7941   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___delitem__",&obj0,&obj1)) SWIG_fail;
7942   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
7943   if (!SWIG_IsOK(res1)) {
7944     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
7945   }
7946   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
7947   {
7948     arg2 = (PySliceObject *) obj1;
7949   }
7950   try {
7951     std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_1(arg1,arg2);
7952   }
7953   catch(std::out_of_range &_e) {
7954     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7955   }
7956
7957   resultobj = SWIG_Py_Void();
7958   return resultobj;
7959 fail:
7960   return NULL;
7961 }
7962
7963
7964 SWIGINTERN PyObject *_wrap_VectorQuads___delitem__(PyObject *self, PyObject *args) {
7965   int argc;
7966   PyObject *argv[3];
7967   int ii;
7968
7969   if (!PyTuple_Check(args)) SWIG_fail;
7970   argc = (int)PyObject_Length(args);
7971   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7972     argv[ii] = PyTuple_GET_ITEM(args,ii);
7973   }
7974   if (argc == 2) {
7975     int _v;
7976     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
7977     _v = SWIG_CheckState(res);
7978     if (_v) {
7979       {
7980         _v = PySlice_Check(argv[1]);
7981       }
7982       if (_v) {
7983         return _wrap_VectorQuads___delitem____SWIG_1(self, args);
7984       }
7985     }
7986   }
7987   if (argc == 2) {
7988     int _v;
7989     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
7990     _v = SWIG_CheckState(res);
7991     if (_v) {
7992       {
7993         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
7994         _v = SWIG_CheckState(res);
7995       }
7996       if (_v) {
7997         return _wrap_VectorQuads___delitem____SWIG_0(self, args);
7998       }
7999     }
8000   }
8001
8002 fail:
8003   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads___delitem__'.\n"
8004     "  Possible C/C++ prototypes are:\n"
8005     "    __delitem__(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::difference_type)\n"
8006     "    __delitem__(std::vector< Hex::Quad * > *,PySliceObject *)\n");
8007   return NULL;
8008 }
8009
8010
8011 SWIGINTERN PyObject *_wrap_VectorQuads___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8012   PyObject *resultobj = 0;
8013   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8014   std::vector< Hex::Quad * >::difference_type arg2 ;
8015   void *argp1 = 0 ;
8016   int res1 = 0 ;
8017   ptrdiff_t val2 ;
8018   int ecode2 = 0 ;
8019   PyObject * obj0 = 0 ;
8020   PyObject * obj1 = 0 ;
8021   std::vector< Hex::Quad * >::value_type result;
8022
8023   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___getitem__",&obj0,&obj1)) SWIG_fail;
8024   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8025   if (!SWIG_IsOK(res1)) {
8026     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8027   }
8028   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8029   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8030   if (!SWIG_IsOK(ecode2)) {
8031     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8032   }
8033   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8034   try {
8035     result = (std::vector< Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_1(arg1,arg2);
8036   }
8037   catch(std::out_of_range &_e) {
8038     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8039   }
8040
8041   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
8042   return resultobj;
8043 fail:
8044   return NULL;
8045 }
8046
8047
8048 SWIGINTERN PyObject *_wrap_VectorQuads___getitem__(PyObject *self, PyObject *args) {
8049   int argc;
8050   PyObject *argv[3];
8051   int ii;
8052
8053   if (!PyTuple_Check(args)) SWIG_fail;
8054   argc = (int)PyObject_Length(args);
8055   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
8056     argv[ii] = PyTuple_GET_ITEM(args,ii);
8057   }
8058   if (argc == 2) {
8059     int _v;
8060     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8061     _v = SWIG_CheckState(res);
8062     if (_v) {
8063       {
8064         _v = PySlice_Check(argv[1]);
8065       }
8066       if (_v) {
8067         return _wrap_VectorQuads___getitem____SWIG_0(self, args);
8068       }
8069     }
8070   }
8071   if (argc == 2) {
8072     int _v;
8073     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8074     _v = SWIG_CheckState(res);
8075     if (_v) {
8076       {
8077         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
8078         _v = SWIG_CheckState(res);
8079       }
8080       if (_v) {
8081         return _wrap_VectorQuads___getitem____SWIG_1(self, args);
8082       }
8083     }
8084   }
8085
8086 fail:
8087   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads___getitem__'.\n"
8088     "  Possible C/C++ prototypes are:\n"
8089     "    __getitem__(std::vector< Hex::Quad * > *,PySliceObject *)\n"
8090     "    __getitem__(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::difference_type)\n");
8091   return NULL;
8092 }
8093
8094
8095 SWIGINTERN PyObject *_wrap_VectorQuads___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8096   PyObject *resultobj = 0;
8097   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8098   std::vector< Hex::Quad * >::difference_type arg2 ;
8099   std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
8100   void *argp1 = 0 ;
8101   int res1 = 0 ;
8102   ptrdiff_t val2 ;
8103   int ecode2 = 0 ;
8104   void *argp3 = 0 ;
8105   int res3 = 0 ;
8106   PyObject * obj0 = 0 ;
8107   PyObject * obj1 = 0 ;
8108   PyObject * obj2 = 0 ;
8109
8110   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
8111   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8112   if (!SWIG_IsOK(res1)) {
8113     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8114   }
8115   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8116   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8117   if (!SWIG_IsOK(ecode2)) {
8118     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8119   }
8120   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8121   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
8122   if (!SWIG_IsOK(res3)) {
8123     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
8124   }
8125   arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
8126   try {
8127     std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_1(arg1,arg2,arg3);
8128   }
8129   catch(std::out_of_range &_e) {
8130     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8131   }
8132
8133   resultobj = SWIG_Py_Void();
8134   return resultobj;
8135 fail:
8136   return NULL;
8137 }
8138
8139
8140 SWIGINTERN PyObject *_wrap_VectorQuads___setitem__(PyObject *self, PyObject *args) {
8141   int argc;
8142   PyObject *argv[4];
8143   int ii;
8144
8145   if (!PyTuple_Check(args)) SWIG_fail;
8146   argc = (int)PyObject_Length(args);
8147   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8148     argv[ii] = PyTuple_GET_ITEM(args,ii);
8149   }
8150   if (argc == 3) {
8151     int _v;
8152     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8153     _v = SWIG_CheckState(res);
8154     if (_v) {
8155       {
8156         _v = PySlice_Check(argv[1]);
8157       }
8158       if (_v) {
8159         int res = swig::asptr(argv[2], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8160         _v = SWIG_CheckState(res);
8161         if (_v) {
8162           return _wrap_VectorQuads___setitem____SWIG_0(self, args);
8163         }
8164       }
8165     }
8166   }
8167   if (argc == 3) {
8168     int _v;
8169     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8170     _v = SWIG_CheckState(res);
8171     if (_v) {
8172       {
8173         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
8174         _v = SWIG_CheckState(res);
8175       }
8176       if (_v) {
8177         void *vptr = 0;
8178         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0);
8179         _v = SWIG_CheckState(res);
8180         if (_v) {
8181           return _wrap_VectorQuads___setitem____SWIG_1(self, args);
8182         }
8183       }
8184     }
8185   }
8186
8187 fail:
8188   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads___setitem__'.\n"
8189     "  Possible C/C++ prototypes are:\n"
8190     "    __setitem__(std::vector< Hex::Quad * > *,PySliceObject *,std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)\n"
8191     "    __setitem__(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::difference_type,std::vector< Hex::Quad * >::value_type)\n");
8192   return NULL;
8193 }
8194
8195
8196 SWIGINTERN PyObject *_wrap_VectorQuads_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8197   PyObject *resultobj = 0;
8198   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8199   std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
8200   void *argp1 = 0 ;
8201   int res1 = 0 ;
8202   void *argp2 = 0 ;
8203   int res2 = 0 ;
8204   PyObject * obj0 = 0 ;
8205   PyObject * obj1 = 0 ;
8206
8207   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_append",&obj0,&obj1)) SWIG_fail;
8208   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8209   if (!SWIG_IsOK(res1)) {
8210     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_append" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8211   }
8212   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8213   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
8214   if (!SWIG_IsOK(res2)) {
8215     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_append" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
8216   }
8217   arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
8218   std_vector_Sl_Hex_Quad_Sm__Sg__append(arg1,arg2);
8219   resultobj = SWIG_Py_Void();
8220   return resultobj;
8221 fail:
8222   return NULL;
8223 }
8224
8225
8226 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8227   PyObject *resultobj = 0;
8228   std::vector< Hex::Quad * > *result = 0 ;
8229
8230   if (!PyArg_ParseTuple(args,(char *)":new_VectorQuads")) SWIG_fail;
8231   result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >();
8232   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
8233   return resultobj;
8234 fail:
8235   return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8240   PyObject *resultobj = 0;
8241   std::vector< Hex::Quad * > *arg1 = 0 ;
8242   int res1 = SWIG_OLDOBJ ;
8243   PyObject * obj0 = 0 ;
8244   std::vector< Hex::Quad * > *result = 0 ;
8245
8246   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
8247   {
8248     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
8249     res1 = swig::asptr(obj0, &ptr);
8250     if (!SWIG_IsOK(res1)) {
8251       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const &""'");
8252     }
8253     if (!ptr) {
8254       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const &""'");
8255     }
8256     arg1 = ptr;
8257   }
8258   result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >((std::vector< Hex::Quad * > const &)*arg1);
8259   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
8260   if (SWIG_IsNewObj(res1)) delete arg1;
8261   return resultobj;
8262 fail:
8263   if (SWIG_IsNewObj(res1)) delete arg1;
8264   return NULL;
8265 }
8266
8267
8268 SWIGINTERN PyObject *_wrap_VectorQuads_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8269   PyObject *resultobj = 0;
8270   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8271   void *argp1 = 0 ;
8272   int res1 = 0 ;
8273   PyObject * obj0 = 0 ;
8274   bool result;
8275
8276   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_empty",&obj0)) SWIG_fail;
8277   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8278   if (!SWIG_IsOK(res1)) {
8279     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_empty" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8280   }
8281   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8282   result = (bool)((std::vector< Hex::Quad * > const *)arg1)->empty();
8283   resultobj = SWIG_From_bool(static_cast< bool >(result));
8284   return resultobj;
8285 fail:
8286   return NULL;
8287 }
8288
8289
8290 SWIGINTERN PyObject *_wrap_VectorQuads_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8291   PyObject *resultobj = 0;
8292   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8293   void *argp1 = 0 ;
8294   int res1 = 0 ;
8295   PyObject * obj0 = 0 ;
8296   std::vector< Hex::Quad * >::size_type result;
8297
8298   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_size",&obj0)) SWIG_fail;
8299   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8300   if (!SWIG_IsOK(res1)) {
8301     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_size" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8302   }
8303   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8304   result = ((std::vector< Hex::Quad * > const *)arg1)->size();
8305   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8306   return resultobj;
8307 fail:
8308   return NULL;
8309 }
8310
8311
8312 SWIGINTERN PyObject *_wrap_VectorQuads_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8313   PyObject *resultobj = 0;
8314   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8315   void *argp1 = 0 ;
8316   int res1 = 0 ;
8317   PyObject * obj0 = 0 ;
8318
8319   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_clear",&obj0)) SWIG_fail;
8320   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8321   if (!SWIG_IsOK(res1)) {
8322     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_clear" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8323   }
8324   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8325   (arg1)->clear();
8326   resultobj = SWIG_Py_Void();
8327   return resultobj;
8328 fail:
8329   return NULL;
8330 }
8331
8332
8333 SWIGINTERN PyObject *_wrap_VectorQuads_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8334   PyObject *resultobj = 0;
8335   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8336   std::vector< Hex::Quad * > *arg2 = 0 ;
8337   void *argp1 = 0 ;
8338   int res1 = 0 ;
8339   void *argp2 = 0 ;
8340   int res2 = 0 ;
8341   PyObject * obj0 = 0 ;
8342   PyObject * obj1 = 0 ;
8343
8344   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_swap",&obj0,&obj1)) SWIG_fail;
8345   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8346   if (!SWIG_IsOK(res1)) {
8347     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_swap" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8348   }
8349   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8350   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t,  0 );
8351   if (!SWIG_IsOK(res2)) {
8352     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector< Hex::Quad * > &""'");
8353   }
8354   if (!argp2) {
8355     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector< Hex::Quad * > &""'");
8356   }
8357   arg2 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp2);
8358   (arg1)->swap(*arg2);
8359   resultobj = SWIG_Py_Void();
8360   return resultobj;
8361 fail:
8362   return NULL;
8363 }
8364
8365
8366 SWIGINTERN PyObject *_wrap_VectorQuads_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8367   PyObject *resultobj = 0;
8368   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8369   void *argp1 = 0 ;
8370   int res1 = 0 ;
8371   PyObject * obj0 = 0 ;
8372   SwigValueWrapper< std::allocator< Hex::Quad * > > result;
8373
8374   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_get_allocator",&obj0)) SWIG_fail;
8375   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8376   if (!SWIG_IsOK(res1)) {
8377     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8378   }
8379   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8380   result = ((std::vector< Hex::Quad * > const *)arg1)->get_allocator();
8381   resultobj = SWIG_NewPointerObj((new std::vector< Hex::Quad * >::allocator_type(static_cast< const std::vector< Hex::Quad * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
8382   return resultobj;
8383 fail:
8384   return NULL;
8385 }
8386
8387
8388 SWIGINTERN PyObject *_wrap_VectorQuads_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8389   PyObject *resultobj = 0;
8390   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8391   void *argp1 = 0 ;
8392   int res1 = 0 ;
8393   PyObject * obj0 = 0 ;
8394   std::vector< Hex::Quad * >::const_iterator result;
8395
8396   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_begin",&obj0)) SWIG_fail;
8397   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8398   if (!SWIG_IsOK(res1)) {
8399     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_begin" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8400   }
8401   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8402   result = ((std::vector< Hex::Quad * > const *)arg1)->begin();
8403   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::const_iterator & >(result)),
8404     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
8405   return resultobj;
8406 fail:
8407   return NULL;
8408 }
8409
8410
8411 SWIGINTERN PyObject *_wrap_VectorQuads_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8412   PyObject *resultobj = 0;
8413   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8414   void *argp1 = 0 ;
8415   int res1 = 0 ;
8416   PyObject * obj0 = 0 ;
8417   std::vector< Hex::Quad * >::const_iterator result;
8418
8419   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_end",&obj0)) SWIG_fail;
8420   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8421   if (!SWIG_IsOK(res1)) {
8422     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_end" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8423   }
8424   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8425   result = ((std::vector< Hex::Quad * > const *)arg1)->end();
8426   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::const_iterator & >(result)),
8427     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
8428   return resultobj;
8429 fail:
8430   return NULL;
8431 }
8432
8433
8434 SWIGINTERN PyObject *_wrap_VectorQuads_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8435   PyObject *resultobj = 0;
8436   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8437   void *argp1 = 0 ;
8438   int res1 = 0 ;
8439   PyObject * obj0 = 0 ;
8440   std::vector< Hex::Quad * >::const_reverse_iterator result;
8441
8442   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rbegin",&obj0)) SWIG_fail;
8443   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8444   if (!SWIG_IsOK(res1)) {
8445     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8446   }
8447   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8448   result = ((std::vector< Hex::Quad * > const *)arg1)->rbegin();
8449   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::const_reverse_iterator & >(result)),
8450     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
8451   return resultobj;
8452 fail:
8453   return NULL;
8454 }
8455
8456
8457 SWIGINTERN PyObject *_wrap_VectorQuads_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8458   PyObject *resultobj = 0;
8459   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8460   void *argp1 = 0 ;
8461   int res1 = 0 ;
8462   PyObject * obj0 = 0 ;
8463   std::vector< Hex::Quad * >::const_reverse_iterator result;
8464
8465   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rend",&obj0)) SWIG_fail;
8466   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8467   if (!SWIG_IsOK(res1)) {
8468     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rend" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8469   }
8470   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8471   result = ((std::vector< Hex::Quad * > const *)arg1)->rend();
8472   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::const_reverse_iterator & >(result)),
8473     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
8474   return resultobj;
8475 fail:
8476   return NULL;
8477 }
8478
8479
8480 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8481   PyObject *resultobj = 0;
8482   std::vector< Hex::Quad * >::size_type arg1 ;
8483   size_t val1 ;
8484   int ecode1 = 0 ;
8485   PyObject * obj0 = 0 ;
8486   std::vector< Hex::Quad * > *result = 0 ;
8487
8488   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
8489   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
8490   if (!SWIG_IsOK(ecode1)) {
8491     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * >::size_type""'");
8492   }
8493   arg1 = static_cast< std::vector< Hex::Quad * >::size_type >(val1);
8494   result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >(arg1);
8495   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
8496   return resultobj;
8497 fail:
8498   return NULL;
8499 }
8500
8501
8502 SWIGINTERN PyObject *_wrap_VectorQuads_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8503   PyObject *resultobj = 0;
8504   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8505   void *argp1 = 0 ;
8506   int res1 = 0 ;
8507   PyObject * obj0 = 0 ;
8508
8509   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop_back",&obj0)) SWIG_fail;
8510   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8511   if (!SWIG_IsOK(res1)) {
8512     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8513   }
8514   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8515   (arg1)->pop_back();
8516   resultobj = SWIG_Py_Void();
8517   return resultobj;
8518 fail:
8519   return NULL;
8520 }
8521
8522
8523 SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8524   PyObject *resultobj = 0;
8525   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8526   std::vector< Hex::Quad * >::size_type arg2 ;
8527   void *argp1 = 0 ;
8528   int res1 = 0 ;
8529   size_t val2 ;
8530   int ecode2 = 0 ;
8531   PyObject * obj0 = 0 ;
8532   PyObject * obj1 = 0 ;
8533
8534   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_resize",&obj0,&obj1)) SWIG_fail;
8535   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8536   if (!SWIG_IsOK(res1)) {
8537     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8538   }
8539   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8540   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8541   if (!SWIG_IsOK(ecode2)) {
8542     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
8543   }
8544   arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
8545   (arg1)->resize(arg2);
8546   resultobj = SWIG_Py_Void();
8547   return resultobj;
8548 fail:
8549   return NULL;
8550 }
8551
8552
8553 SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8554   PyObject *resultobj = 0;
8555   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8556   std::vector< Hex::Quad * >::iterator arg2 ;
8557   void *argp1 = 0 ;
8558   int res1 = 0 ;
8559   swig::SwigPyIterator *iter2 = 0 ;
8560   int res2 ;
8561   PyObject * obj0 = 0 ;
8562   PyObject * obj1 = 0 ;
8563   std::vector< Hex::Quad * >::iterator result;
8564
8565   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_erase",&obj0,&obj1)) SWIG_fail;
8566   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8567   if (!SWIG_IsOK(res1)) {
8568     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8569   }
8570   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8571   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
8572   if (!SWIG_IsOK(res2) || !iter2) {
8573     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
8574   } else {
8575     swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
8576     if (iter_t) {
8577       arg2 = iter_t->get_current();
8578     } else {
8579       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
8580     }
8581   }
8582   result = (arg1)->erase(arg2);
8583   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
8584     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
8585   return resultobj;
8586 fail:
8587   return NULL;
8588 }
8589
8590
8591 SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8592   PyObject *resultobj = 0;
8593   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8594   std::vector< Hex::Quad * >::iterator arg2 ;
8595   std::vector< Hex::Quad * >::iterator arg3 ;
8596   void *argp1 = 0 ;
8597   int res1 = 0 ;
8598   swig::SwigPyIterator *iter2 = 0 ;
8599   int res2 ;
8600   swig::SwigPyIterator *iter3 = 0 ;
8601   int res3 ;
8602   PyObject * obj0 = 0 ;
8603   PyObject * obj1 = 0 ;
8604   PyObject * obj2 = 0 ;
8605   std::vector< Hex::Quad * >::iterator result;
8606
8607   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_erase",&obj0,&obj1,&obj2)) SWIG_fail;
8608   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8609   if (!SWIG_IsOK(res1)) {
8610     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8611   }
8612   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8613   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
8614   if (!SWIG_IsOK(res2) || !iter2) {
8615     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
8616   } else {
8617     swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
8618     if (iter_t) {
8619       arg2 = iter_t->get_current();
8620     } else {
8621       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
8622     }
8623   }
8624   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
8625   if (!SWIG_IsOK(res3) || !iter3) {
8626     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::iterator""'");
8627   } else {
8628     swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter3);
8629     if (iter_t) {
8630       arg3 = iter_t->get_current();
8631     } else {
8632       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::iterator""'");
8633     }
8634   }
8635   result = (arg1)->erase(arg2,arg3);
8636   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
8637     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
8638   return resultobj;
8639 fail:
8640   return NULL;
8641 }
8642
8643
8644 SWIGINTERN PyObject *_wrap_VectorQuads_erase(PyObject *self, PyObject *args) {
8645   int argc;
8646   PyObject *argv[4];
8647   int ii;
8648
8649   if (!PyTuple_Check(args)) SWIG_fail;
8650   argc = (int)PyObject_Length(args);
8651   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8652     argv[ii] = PyTuple_GET_ITEM(args,ii);
8653   }
8654   if (argc == 2) {
8655     int _v;
8656     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8657     _v = SWIG_CheckState(res);
8658     if (_v) {
8659       swig::SwigPyIterator *iter = 0;
8660       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8661       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
8662       if (_v) {
8663         return _wrap_VectorQuads_erase__SWIG_0(self, args);
8664       }
8665     }
8666   }
8667   if (argc == 3) {
8668     int _v;
8669     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8670     _v = SWIG_CheckState(res);
8671     if (_v) {
8672       swig::SwigPyIterator *iter = 0;
8673       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8674       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
8675       if (_v) {
8676         swig::SwigPyIterator *iter = 0;
8677         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8678         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
8679         if (_v) {
8680           return _wrap_VectorQuads_erase__SWIG_1(self, args);
8681         }
8682       }
8683     }
8684   }
8685
8686 fail:
8687   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_erase'.\n"
8688     "  Possible C/C++ prototypes are:\n"
8689     "    erase(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::iterator)\n"
8690     "    erase(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::iterator)\n");
8691   return NULL;
8692 }
8693
8694
8695 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8696   PyObject *resultobj = 0;
8697   std::vector< Hex::Quad * >::size_type arg1 ;
8698   std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
8699   size_t val1 ;
8700   int ecode1 = 0 ;
8701   void *argp2 = 0 ;
8702   int res2 = 0 ;
8703   PyObject * obj0 = 0 ;
8704   PyObject * obj1 = 0 ;
8705   std::vector< Hex::Quad * > *result = 0 ;
8706
8707   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorQuads",&obj0,&obj1)) SWIG_fail;
8708   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
8709   if (!SWIG_IsOK(ecode1)) {
8710     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * >::size_type""'");
8711   }
8712   arg1 = static_cast< std::vector< Hex::Quad * >::size_type >(val1);
8713   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
8714   if (!SWIG_IsOK(res2)) {
8715     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorQuads" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
8716   }
8717   arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
8718   result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >(arg1,arg2);
8719   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
8720   return resultobj;
8721 fail:
8722   return NULL;
8723 }
8724
8725
8726 SWIGINTERN PyObject *_wrap_new_VectorQuads(PyObject *self, PyObject *args) {
8727   int argc;
8728   PyObject *argv[3];
8729   int ii;
8730
8731   if (!PyTuple_Check(args)) SWIG_fail;
8732   argc = (int)PyObject_Length(args);
8733   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
8734     argv[ii] = PyTuple_GET_ITEM(args,ii);
8735   }
8736   if (argc == 0) {
8737     return _wrap_new_VectorQuads__SWIG_0(self, args);
8738   }
8739   if (argc == 1) {
8740     int _v;
8741     {
8742       int res = SWIG_AsVal_size_t(argv[0], NULL);
8743       _v = SWIG_CheckState(res);
8744     }
8745     if (_v) {
8746       return _wrap_new_VectorQuads__SWIG_2(self, args);
8747     }
8748   }
8749   if (argc == 1) {
8750     int _v;
8751     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8752     _v = SWIG_CheckState(res);
8753     if (_v) {
8754       return _wrap_new_VectorQuads__SWIG_1(self, args);
8755     }
8756   }
8757   if (argc == 2) {
8758     int _v;
8759     {
8760       int res = SWIG_AsVal_size_t(argv[0], NULL);
8761       _v = SWIG_CheckState(res);
8762     }
8763     if (_v) {
8764       void *vptr = 0;
8765       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0);
8766       _v = SWIG_CheckState(res);
8767       if (_v) {
8768         return _wrap_new_VectorQuads__SWIG_3(self, args);
8769       }
8770     }
8771   }
8772
8773 fail:
8774   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorQuads'.\n"
8775     "  Possible C/C++ prototypes are:\n"
8776     "    std::vector< Hex::Quad * >()\n"
8777     "    std::vector< Hex::Quad * >(std::vector< Hex::Quad * > const &)\n"
8778     "    std::vector< Hex::Quad * >(std::vector< Hex::Quad * >::size_type)\n"
8779     "    std::vector< Hex::Quad * >(std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
8780   return NULL;
8781 }
8782
8783
8784 SWIGINTERN PyObject *_wrap_VectorQuads_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8785   PyObject *resultobj = 0;
8786   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8787   std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
8788   void *argp1 = 0 ;
8789   int res1 = 0 ;
8790   void *argp2 = 0 ;
8791   int res2 = 0 ;
8792   PyObject * obj0 = 0 ;
8793   PyObject * obj1 = 0 ;
8794
8795   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_push_back",&obj0,&obj1)) SWIG_fail;
8796   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8797   if (!SWIG_IsOK(res1)) {
8798     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_push_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8799   }
8800   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8801   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
8802   if (!SWIG_IsOK(res2)) {
8803     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_push_back" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
8804   }
8805   arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
8806   (arg1)->push_back(arg2);
8807   resultobj = SWIG_Py_Void();
8808   return resultobj;
8809 fail:
8810   return NULL;
8811 }
8812
8813
8814 SWIGINTERN PyObject *_wrap_VectorQuads_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8815   PyObject *resultobj = 0;
8816   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8817   void *argp1 = 0 ;
8818   int res1 = 0 ;
8819   PyObject * obj0 = 0 ;
8820   std::vector< Hex::Quad * >::value_type result;
8821
8822   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_front",&obj0)) SWIG_fail;
8823   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8824   if (!SWIG_IsOK(res1)) {
8825     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_front" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8826   }
8827   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8828   result = (std::vector< Hex::Quad * >::value_type)((std::vector< Hex::Quad * > const *)arg1)->front();
8829   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
8830   return resultobj;
8831 fail:
8832   return NULL;
8833 }
8834
8835
8836 SWIGINTERN PyObject *_wrap_VectorQuads_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8837   PyObject *resultobj = 0;
8838   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8839   void *argp1 = 0 ;
8840   int res1 = 0 ;
8841   PyObject * obj0 = 0 ;
8842   std::vector< Hex::Quad * >::value_type result;
8843
8844   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_back",&obj0)) SWIG_fail;
8845   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8846   if (!SWIG_IsOK(res1)) {
8847     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8848   }
8849   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8850   result = (std::vector< Hex::Quad * >::value_type)((std::vector< Hex::Quad * > const *)arg1)->back();
8851   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
8852   return resultobj;
8853 fail:
8854   return NULL;
8855 }
8856
8857
8858 SWIGINTERN PyObject *_wrap_VectorQuads_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8859   PyObject *resultobj = 0;
8860   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8861   std::vector< Hex::Quad * >::size_type arg2 ;
8862   std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
8863   void *argp1 = 0 ;
8864   int res1 = 0 ;
8865   size_t val2 ;
8866   int ecode2 = 0 ;
8867   void *argp3 = 0 ;
8868   int res3 = 0 ;
8869   PyObject * obj0 = 0 ;
8870   PyObject * obj1 = 0 ;
8871   PyObject * obj2 = 0 ;
8872
8873   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_assign",&obj0,&obj1,&obj2)) SWIG_fail;
8874   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8875   if (!SWIG_IsOK(res1)) {
8876     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_assign" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8877   }
8878   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8879   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8880   if (!SWIG_IsOK(ecode2)) {
8881     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_assign" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
8882   }
8883   arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
8884   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
8885   if (!SWIG_IsOK(res3)) {
8886     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_assign" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
8887   }
8888   arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
8889   (arg1)->assign(arg2,arg3);
8890   resultobj = SWIG_Py_Void();
8891   return resultobj;
8892 fail:
8893   return NULL;
8894 }
8895
8896
8897 SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8898   PyObject *resultobj = 0;
8899   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8900   std::vector< Hex::Quad * >::size_type arg2 ;
8901   std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
8902   void *argp1 = 0 ;
8903   int res1 = 0 ;
8904   size_t val2 ;
8905   int ecode2 = 0 ;
8906   void *argp3 = 0 ;
8907   int res3 = 0 ;
8908   PyObject * obj0 = 0 ;
8909   PyObject * obj1 = 0 ;
8910   PyObject * obj2 = 0 ;
8911
8912   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_resize",&obj0,&obj1,&obj2)) SWIG_fail;
8913   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8914   if (!SWIG_IsOK(res1)) {
8915     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8916   }
8917   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8918   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8919   if (!SWIG_IsOK(ecode2)) {
8920     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
8921   }
8922   arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
8923   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
8924   if (!SWIG_IsOK(res3)) {
8925     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_resize" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
8926   }
8927   arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
8928   (arg1)->resize(arg2,arg3);
8929   resultobj = SWIG_Py_Void();
8930   return resultobj;
8931 fail:
8932   return NULL;
8933 }
8934
8935
8936 SWIGINTERN PyObject *_wrap_VectorQuads_resize(PyObject *self, PyObject *args) {
8937   int argc;
8938   PyObject *argv[4];
8939   int ii;
8940
8941   if (!PyTuple_Check(args)) SWIG_fail;
8942   argc = (int)PyObject_Length(args);
8943   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8944     argv[ii] = PyTuple_GET_ITEM(args,ii);
8945   }
8946   if (argc == 2) {
8947     int _v;
8948     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8949     _v = SWIG_CheckState(res);
8950     if (_v) {
8951       {
8952         int res = SWIG_AsVal_size_t(argv[1], NULL);
8953         _v = SWIG_CheckState(res);
8954       }
8955       if (_v) {
8956         return _wrap_VectorQuads_resize__SWIG_0(self, args);
8957       }
8958     }
8959   }
8960   if (argc == 3) {
8961     int _v;
8962     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8963     _v = SWIG_CheckState(res);
8964     if (_v) {
8965       {
8966         int res = SWIG_AsVal_size_t(argv[1], NULL);
8967         _v = SWIG_CheckState(res);
8968       }
8969       if (_v) {
8970         void *vptr = 0;
8971         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0);
8972         _v = SWIG_CheckState(res);
8973         if (_v) {
8974           return _wrap_VectorQuads_resize__SWIG_1(self, args);
8975         }
8976       }
8977     }
8978   }
8979
8980 fail:
8981   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_resize'.\n"
8982     "  Possible C/C++ prototypes are:\n"
8983     "    resize(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::size_type)\n"
8984     "    resize(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
8985   return NULL;
8986 }
8987
8988
8989 SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8990   PyObject *resultobj = 0;
8991   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8992   std::vector< Hex::Quad * >::iterator arg2 ;
8993   std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
8994   void *argp1 = 0 ;
8995   int res1 = 0 ;
8996   swig::SwigPyIterator *iter2 = 0 ;
8997   int res2 ;
8998   void *argp3 = 0 ;
8999   int res3 = 0 ;
9000   PyObject * obj0 = 0 ;
9001   PyObject * obj1 = 0 ;
9002   PyObject * obj2 = 0 ;
9003   std::vector< Hex::Quad * >::iterator result;
9004
9005   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_insert",&obj0,&obj1,&obj2)) SWIG_fail;
9006   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9007   if (!SWIG_IsOK(res1)) {
9008     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9009   }
9010   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9011   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
9012   if (!SWIG_IsOK(res2) || !iter2) {
9013     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9014   } else {
9015     swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
9016     if (iter_t) {
9017       arg2 = iter_t->get_current();
9018     } else {
9019       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9020     }
9021   }
9022   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
9023   if (!SWIG_IsOK(res3)) {
9024     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
9025   }
9026   arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
9027   result = (arg1)->insert(arg2,arg3);
9028   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
9029     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9030   return resultobj;
9031 fail:
9032   return NULL;
9033 }
9034
9035
9036 SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9037   PyObject *resultobj = 0;
9038   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9039   std::vector< Hex::Quad * >::iterator arg2 ;
9040   std::vector< Hex::Quad * >::size_type arg3 ;
9041   std::vector< Hex::Quad * >::value_type arg4 = (std::vector< Hex::Quad * >::value_type) 0 ;
9042   void *argp1 = 0 ;
9043   int res1 = 0 ;
9044   swig::SwigPyIterator *iter2 = 0 ;
9045   int res2 ;
9046   size_t val3 ;
9047   int ecode3 = 0 ;
9048   void *argp4 = 0 ;
9049   int res4 = 0 ;
9050   PyObject * obj0 = 0 ;
9051   PyObject * obj1 = 0 ;
9052   PyObject * obj2 = 0 ;
9053   PyObject * obj3 = 0 ;
9054
9055   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9056   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9057   if (!SWIG_IsOK(res1)) {
9058     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9059   }
9060   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9061   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
9062   if (!SWIG_IsOK(res2) || !iter2) {
9063     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9064   } else {
9065     swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
9066     if (iter_t) {
9067       arg2 = iter_t->get_current();
9068     } else {
9069       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9070     }
9071   }
9072   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9073   if (!SWIG_IsOK(ecode3)) {
9074     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::size_type""'");
9075   }
9076   arg3 = static_cast< std::vector< Hex::Quad * >::size_type >(val3);
9077   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0 |  0 );
9078   if (!SWIG_IsOK(res4)) {
9079     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads_insert" "', argument " "4"" of type '" "std::vector< Hex::Quad * >::value_type""'");
9080   }
9081   arg4 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp4);
9082   (arg1)->insert(arg2,arg3,arg4);
9083   resultobj = SWIG_Py_Void();
9084   return resultobj;
9085 fail:
9086   return NULL;
9087 }
9088
9089
9090 SWIGINTERN PyObject *_wrap_VectorQuads_insert(PyObject *self, PyObject *args) {
9091   int argc;
9092   PyObject *argv[5];
9093   int ii;
9094
9095   if (!PyTuple_Check(args)) SWIG_fail;
9096   argc = (int)PyObject_Length(args);
9097   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
9098     argv[ii] = PyTuple_GET_ITEM(args,ii);
9099   }
9100   if (argc == 3) {
9101     int _v;
9102     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9103     _v = SWIG_CheckState(res);
9104     if (_v) {
9105       swig::SwigPyIterator *iter = 0;
9106       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9107       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
9108       if (_v) {
9109         void *vptr = 0;
9110         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0);
9111         _v = SWIG_CheckState(res);
9112         if (_v) {
9113           return _wrap_VectorQuads_insert__SWIG_0(self, args);
9114         }
9115       }
9116     }
9117   }
9118   if (argc == 4) {
9119     int _v;
9120     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9121     _v = SWIG_CheckState(res);
9122     if (_v) {
9123       swig::SwigPyIterator *iter = 0;
9124       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9125       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
9126       if (_v) {
9127         {
9128           int res = SWIG_AsVal_size_t(argv[2], NULL);
9129           _v = SWIG_CheckState(res);
9130         }
9131         if (_v) {
9132           void *vptr = 0;
9133           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0);
9134           _v = SWIG_CheckState(res);
9135           if (_v) {
9136             return _wrap_VectorQuads_insert__SWIG_1(self, args);
9137           }
9138         }
9139       }
9140     }
9141   }
9142
9143 fail:
9144   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_insert'.\n"
9145     "  Possible C/C++ prototypes are:\n"
9146     "    insert(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::value_type)\n"
9147     "    insert(std::vector< Hex::Quad * > *,std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
9148   return NULL;
9149 }
9150
9151
9152 SWIGINTERN PyObject *_wrap_VectorQuads_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9153   PyObject *resultobj = 0;
9154   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9155   std::vector< Hex::Quad * >::size_type arg2 ;
9156   void *argp1 = 0 ;
9157   int res1 = 0 ;
9158   size_t val2 ;
9159   int ecode2 = 0 ;
9160   PyObject * obj0 = 0 ;
9161   PyObject * obj1 = 0 ;
9162
9163   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_reserve",&obj0,&obj1)) SWIG_fail;
9164   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9165   if (!SWIG_IsOK(res1)) {
9166     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_reserve" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9167   }
9168   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9169   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9170   if (!SWIG_IsOK(ecode2)) {
9171     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_reserve" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
9172   }
9173   arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
9174   (arg1)->reserve(arg2);
9175   resultobj = SWIG_Py_Void();
9176   return resultobj;
9177 fail:
9178   return NULL;
9179 }
9180
9181
9182 SWIGINTERN PyObject *_wrap_VectorQuads_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9183   PyObject *resultobj = 0;
9184   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9185   void *argp1 = 0 ;
9186   int res1 = 0 ;
9187   PyObject * obj0 = 0 ;
9188   std::vector< Hex::Quad * >::size_type result;
9189
9190   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_capacity",&obj0)) SWIG_fail;
9191   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9192   if (!SWIG_IsOK(res1)) {
9193     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_capacity" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
9194   }
9195   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9196   result = ((std::vector< Hex::Quad * > const *)arg1)->capacity();
9197   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9198   return resultobj;
9199 fail:
9200   return NULL;
9201 }
9202
9203
9204 SWIGINTERN PyObject *_wrap_delete_VectorQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9205   PyObject *resultobj = 0;
9206   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9207   void *argp1 = 0 ;
9208   int res1 = 0 ;
9209   PyObject * obj0 = 0 ;
9210
9211   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorQuads",&obj0)) SWIG_fail;
9212   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_DISOWN |  0 );
9213   if (!SWIG_IsOK(res1)) {
9214     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9215   }
9216   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9217   delete arg1;
9218   resultobj = SWIG_Py_Void();
9219   return resultobj;
9220 fail:
9221   return NULL;
9222 }
9223
9224
9225 SWIGINTERN PyObject *VectorQuads_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9226   PyObject *obj;
9227   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
9228   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_NewClientData(obj));
9229   return SWIG_Py_Void();
9230 }
9231
9232 SWIGINTERN PyObject *_wrap_VectorEdges_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9233   PyObject *resultobj = 0;
9234   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9235   PyObject **arg2 = (PyObject **) 0 ;
9236   void *argp1 = 0 ;
9237   int res1 = 0 ;
9238   PyObject * obj0 = 0 ;
9239   swig::SwigPyIterator *result = 0 ;
9240
9241   arg2 = &obj0;
9242   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_iterator",&obj0)) SWIG_fail;
9243   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9244   if (!SWIG_IsOK(res1)) {
9245     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_iterator" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9246   }
9247   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9248   result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Edge_Sm__Sg__iterator(arg1,arg2);
9249   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
9250   return resultobj;
9251 fail:
9252   return NULL;
9253 }
9254
9255
9256 SWIGINTERN PyObject *_wrap_VectorEdges___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9257   PyObject *resultobj = 0;
9258   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9259   void *argp1 = 0 ;
9260   int res1 = 0 ;
9261   PyObject * obj0 = 0 ;
9262   bool result;
9263
9264   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___nonzero__",&obj0)) SWIG_fail;
9265   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9266   if (!SWIG_IsOK(res1)) {
9267     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
9268   }
9269   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9270   result = (bool)std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__((std::vector< Hex::Edge * > const *)arg1);
9271   resultobj = SWIG_From_bool(static_cast< bool >(result));
9272   return resultobj;
9273 fail:
9274   return NULL;
9275 }
9276
9277
9278 SWIGINTERN PyObject *_wrap_VectorEdges___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9279   PyObject *resultobj = 0;
9280   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9281   void *argp1 = 0 ;
9282   int res1 = 0 ;
9283   PyObject * obj0 = 0 ;
9284   bool result;
9285
9286   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___bool__",&obj0)) SWIG_fail;
9287   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9288   if (!SWIG_IsOK(res1)) {
9289     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___bool__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
9290   }
9291   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9292   result = (bool)std_vector_Sl_Hex_Edge_Sm__Sg____bool__((std::vector< Hex::Edge * > const *)arg1);
9293   resultobj = SWIG_From_bool(static_cast< bool >(result));
9294   return resultobj;
9295 fail:
9296   return NULL;
9297 }
9298
9299
9300 SWIGINTERN PyObject *_wrap_VectorEdges___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9301   PyObject *resultobj = 0;
9302   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9303   void *argp1 = 0 ;
9304   int res1 = 0 ;
9305   PyObject * obj0 = 0 ;
9306   std::vector< Hex::Edge * >::size_type result;
9307
9308   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___len__",&obj0)) SWIG_fail;
9309   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9310   if (!SWIG_IsOK(res1)) {
9311     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___len__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
9312   }
9313   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9314   result = std_vector_Sl_Hex_Edge_Sm__Sg____len__((std::vector< Hex::Edge * > const *)arg1);
9315   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9316   return resultobj;
9317 fail:
9318   return NULL;
9319 }
9320
9321
9322 SWIGINTERN PyObject *_wrap_VectorEdges_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9323   PyObject *resultobj = 0;
9324   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9325   void *argp1 = 0 ;
9326   int res1 = 0 ;
9327   PyObject * obj0 = 0 ;
9328   std::vector< Hex::Edge * >::value_type result;
9329
9330   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop",&obj0)) SWIG_fail;
9331   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9332   if (!SWIG_IsOK(res1)) {
9333     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9334   }
9335   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9336   try {
9337     result = (std::vector< Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg__pop(arg1);
9338   }
9339   catch(std::out_of_range &_e) {
9340     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9341   }
9342
9343   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
9344   return resultobj;
9345 fail:
9346   return NULL;
9347 }
9348
9349
9350 SWIGINTERN PyObject *_wrap_VectorEdges___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9351   PyObject *resultobj = 0;
9352   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9353   std::vector< Hex::Edge * >::difference_type arg2 ;
9354   std::vector< Hex::Edge * >::difference_type arg3 ;
9355   void *argp1 = 0 ;
9356   int res1 = 0 ;
9357   ptrdiff_t val2 ;
9358   int ecode2 = 0 ;
9359   ptrdiff_t val3 ;
9360   int ecode3 = 0 ;
9361   PyObject * obj0 = 0 ;
9362   PyObject * obj1 = 0 ;
9363   PyObject * obj2 = 0 ;
9364   std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *result = 0 ;
9365
9366   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
9367   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9368   if (!SWIG_IsOK(res1)) {
9369     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9370   }
9371   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9372   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
9373   if (!SWIG_IsOK(ecode2)) {
9374     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
9375   }
9376   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
9377   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
9378   if (!SWIG_IsOK(ecode3)) {
9379     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
9380   }
9381   arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
9382   try {
9383     result = (std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *)std_vector_Sl_Hex_Edge_Sm__Sg____getslice__(arg1,arg2,arg3);
9384   }
9385   catch(std::out_of_range &_e) {
9386     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9387   }
9388
9389   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_OWN |  0 );
9390   return resultobj;
9391 fail:
9392   return NULL;
9393 }
9394
9395
9396 SWIGINTERN PyObject *_wrap_VectorEdges___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9397   PyObject *resultobj = 0;
9398   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9399   std::vector< Hex::Edge * >::difference_type arg2 ;
9400   std::vector< Hex::Edge * >::difference_type arg3 ;
9401   std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *arg4 = 0 ;
9402   void *argp1 = 0 ;
9403   int res1 = 0 ;
9404   ptrdiff_t val2 ;
9405   int ecode2 = 0 ;
9406   ptrdiff_t val3 ;
9407   int ecode3 = 0 ;
9408   int res4 = SWIG_OLDOBJ ;
9409   PyObject * obj0 = 0 ;
9410   PyObject * obj1 = 0 ;
9411   PyObject * obj2 = 0 ;
9412   PyObject * obj3 = 0 ;
9413
9414   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9415   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9416   if (!SWIG_IsOK(res1)) {
9417     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9418   }
9419   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9420   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
9421   if (!SWIG_IsOK(ecode2)) {
9422     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
9423   }
9424   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
9425   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
9426   if (!SWIG_IsOK(ecode3)) {
9427     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
9428   }
9429   arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
9430   {
9431     std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
9432     res4 = swig::asptr(obj3, &ptr);
9433     if (!SWIG_IsOK(res4)) {
9434       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
9435     }
9436     if (!ptr) {
9437       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
9438     }
9439     arg4 = ptr;
9440   }
9441   try {
9442     std_vector_Sl_Hex_Edge_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)*arg4);
9443   }
9444   catch(std::out_of_range &_e) {
9445     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9446   }
9447   catch(std::invalid_argument &_e) {
9448     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9449   }
9450
9451   resultobj = SWIG_Py_Void();
9452   if (SWIG_IsNewObj(res4)) delete arg4;
9453   return resultobj;
9454 fail:
9455   if (SWIG_IsNewObj(res4)) delete arg4;
9456   return NULL;
9457 }
9458
9459
9460 SWIGINTERN PyObject *_wrap_VectorEdges___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9461   PyObject *resultobj = 0;
9462   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9463   std::vector< Hex::Edge * >::difference_type arg2 ;
9464   std::vector< Hex::Edge * >::difference_type arg3 ;
9465   void *argp1 = 0 ;
9466   int res1 = 0 ;
9467   ptrdiff_t val2 ;
9468   int ecode2 = 0 ;
9469   ptrdiff_t val3 ;
9470   int ecode3 = 0 ;
9471   PyObject * obj0 = 0 ;
9472   PyObject * obj1 = 0 ;
9473   PyObject * obj2 = 0 ;
9474
9475   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
9476   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9477   if (!SWIG_IsOK(res1)) {
9478     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9479   }
9480   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9481   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
9482   if (!SWIG_IsOK(ecode2)) {
9483     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
9484   }
9485   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
9486   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
9487   if (!SWIG_IsOK(ecode3)) {
9488     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
9489   }
9490   arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
9491   try {
9492     std_vector_Sl_Hex_Edge_Sm__Sg____delslice__(arg1,arg2,arg3);
9493   }
9494   catch(std::out_of_range &_e) {
9495     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9496   }
9497
9498   resultobj = SWIG_Py_Void();
9499   return resultobj;
9500 fail:
9501   return NULL;
9502 }
9503
9504
9505 SWIGINTERN PyObject *_wrap_VectorEdges___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9506   PyObject *resultobj = 0;
9507   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9508   std::vector< Hex::Edge * >::difference_type arg2 ;
9509   void *argp1 = 0 ;
9510   int res1 = 0 ;
9511   ptrdiff_t val2 ;
9512   int ecode2 = 0 ;
9513   PyObject * obj0 = 0 ;
9514   PyObject * obj1 = 0 ;
9515
9516   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___delitem__",&obj0,&obj1)) SWIG_fail;
9517   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9518   if (!SWIG_IsOK(res1)) {
9519     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9520   }
9521   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9522   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
9523   if (!SWIG_IsOK(ecode2)) {
9524     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
9525   }
9526   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
9527   try {
9528     std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_0(arg1,arg2);
9529   }
9530   catch(std::out_of_range &_e) {
9531     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9532   }
9533
9534   resultobj = SWIG_Py_Void();
9535   return resultobj;
9536 fail:
9537   return NULL;
9538 }
9539
9540
9541 SWIGINTERN PyObject *_wrap_VectorEdges___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9542   PyObject *resultobj = 0;
9543   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9544   PySliceObject *arg2 = (PySliceObject *) 0 ;
9545   void *argp1 = 0 ;
9546   int res1 = 0 ;
9547   PyObject * obj0 = 0 ;
9548   PyObject * obj1 = 0 ;
9549   std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *result = 0 ;
9550
9551   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___getitem__",&obj0,&obj1)) SWIG_fail;
9552   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9553   if (!SWIG_IsOK(res1)) {
9554     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9555   }
9556   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9557   {
9558     arg2 = (PySliceObject *) obj1;
9559   }
9560   try {
9561     result = (std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *)std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_0(arg1,arg2);
9562   }
9563   catch(std::out_of_range &_e) {
9564     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9565   }
9566
9567   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9568   return resultobj;
9569 fail:
9570   return NULL;
9571 }
9572
9573
9574 SWIGINTERN PyObject *_wrap_VectorEdges___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9575   PyObject *resultobj = 0;
9576   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9577   PySliceObject *arg2 = (PySliceObject *) 0 ;
9578   std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *arg3 = 0 ;
9579   void *argp1 = 0 ;
9580   int res1 = 0 ;
9581   int res3 = SWIG_OLDOBJ ;
9582   PyObject * obj0 = 0 ;
9583   PyObject * obj1 = 0 ;
9584   PyObject * obj2 = 0 ;
9585
9586   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
9587   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9588   if (!SWIG_IsOK(res1)) {
9589     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9590   }
9591   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9592   {
9593     arg2 = (PySliceObject *) obj1;
9594   }
9595   {
9596     std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
9597     res3 = swig::asptr(obj2, &ptr);
9598     if (!SWIG_IsOK(res3)) {
9599       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
9600     }
9601     if (!ptr) {
9602       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
9603     }
9604     arg3 = ptr;
9605   }
9606   try {
9607     std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)*arg3);
9608   }
9609   catch(std::out_of_range &_e) {
9610     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9611   }
9612   catch(std::invalid_argument &_e) {
9613     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9614   }
9615
9616   resultobj = SWIG_Py_Void();
9617   if (SWIG_IsNewObj(res3)) delete arg3;
9618   return resultobj;
9619 fail:
9620   if (SWIG_IsNewObj(res3)) delete arg3;
9621   return NULL;
9622 }
9623
9624
9625 SWIGINTERN PyObject *_wrap_VectorEdges___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9626   PyObject *resultobj = 0;
9627   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9628   PySliceObject *arg2 = (PySliceObject *) 0 ;
9629   void *argp1 = 0 ;
9630   int res1 = 0 ;
9631   PyObject * obj0 = 0 ;
9632   PyObject * obj1 = 0 ;
9633
9634   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___delitem__",&obj0,&obj1)) SWIG_fail;
9635   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9636   if (!SWIG_IsOK(res1)) {
9637     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9638   }
9639   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9640   {
9641     arg2 = (PySliceObject *) obj1;
9642   }
9643   try {
9644     std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_1(arg1,arg2);
9645   }
9646   catch(std::out_of_range &_e) {
9647     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9648   }
9649
9650   resultobj = SWIG_Py_Void();
9651   return resultobj;
9652 fail:
9653   return NULL;
9654 }
9655
9656
9657 SWIGINTERN PyObject *_wrap_VectorEdges___delitem__(PyObject *self, PyObject *args) {
9658   int argc;
9659   PyObject *argv[3];
9660   int ii;
9661
9662   if (!PyTuple_Check(args)) SWIG_fail;
9663   argc = (int)PyObject_Length(args);
9664   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
9665     argv[ii] = PyTuple_GET_ITEM(args,ii);
9666   }
9667   if (argc == 2) {
9668     int _v;
9669     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
9670     _v = SWIG_CheckState(res);
9671     if (_v) {
9672       {
9673         _v = PySlice_Check(argv[1]);
9674       }
9675       if (_v) {
9676         return _wrap_VectorEdges___delitem____SWIG_1(self, args);
9677       }
9678     }
9679   }
9680   if (argc == 2) {
9681     int _v;
9682     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
9683     _v = SWIG_CheckState(res);
9684     if (_v) {
9685       {
9686         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
9687         _v = SWIG_CheckState(res);
9688       }
9689       if (_v) {
9690         return _wrap_VectorEdges___delitem____SWIG_0(self, args);
9691       }
9692     }
9693   }
9694
9695 fail:
9696   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges___delitem__'.\n"
9697     "  Possible C/C++ prototypes are:\n"
9698     "    __delitem__(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::difference_type)\n"
9699     "    __delitem__(std::vector< Hex::Edge * > *,PySliceObject *)\n");
9700   return NULL;
9701 }
9702
9703
9704 SWIGINTERN PyObject *_wrap_VectorEdges___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9705   PyObject *resultobj = 0;
9706   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9707   std::vector< Hex::Edge * >::difference_type arg2 ;
9708   void *argp1 = 0 ;
9709   int res1 = 0 ;
9710   ptrdiff_t val2 ;
9711   int ecode2 = 0 ;
9712   PyObject * obj0 = 0 ;
9713   PyObject * obj1 = 0 ;
9714   std::vector< Hex::Edge * >::value_type result;
9715
9716   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___getitem__",&obj0,&obj1)) SWIG_fail;
9717   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9718   if (!SWIG_IsOK(res1)) {
9719     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9720   }
9721   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9722   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
9723   if (!SWIG_IsOK(ecode2)) {
9724     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
9725   }
9726   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
9727   try {
9728     result = (std::vector< Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_1(arg1,arg2);
9729   }
9730   catch(std::out_of_range &_e) {
9731     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9732   }
9733
9734   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
9735   return resultobj;
9736 fail:
9737   return NULL;
9738 }
9739
9740
9741 SWIGINTERN PyObject *_wrap_VectorEdges___getitem__(PyObject *self, PyObject *args) {
9742   int argc;
9743   PyObject *argv[3];
9744   int ii;
9745
9746   if (!PyTuple_Check(args)) SWIG_fail;
9747   argc = (int)PyObject_Length(args);
9748   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
9749     argv[ii] = PyTuple_GET_ITEM(args,ii);
9750   }
9751   if (argc == 2) {
9752     int _v;
9753     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
9754     _v = SWIG_CheckState(res);
9755     if (_v) {
9756       {
9757         _v = PySlice_Check(argv[1]);
9758       }
9759       if (_v) {
9760         return _wrap_VectorEdges___getitem____SWIG_0(self, args);
9761       }
9762     }
9763   }
9764   if (argc == 2) {
9765     int _v;
9766     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
9767     _v = SWIG_CheckState(res);
9768     if (_v) {
9769       {
9770         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
9771         _v = SWIG_CheckState(res);
9772       }
9773       if (_v) {
9774         return _wrap_VectorEdges___getitem____SWIG_1(self, args);
9775       }
9776     }
9777   }
9778
9779 fail:
9780   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges___getitem__'.\n"
9781     "  Possible C/C++ prototypes are:\n"
9782     "    __getitem__(std::vector< Hex::Edge * > *,PySliceObject *)\n"
9783     "    __getitem__(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::difference_type)\n");
9784   return NULL;
9785 }
9786
9787
9788 SWIGINTERN PyObject *_wrap_VectorEdges___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9789   PyObject *resultobj = 0;
9790   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9791   std::vector< Hex::Edge * >::difference_type arg2 ;
9792   std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
9793   void *argp1 = 0 ;
9794   int res1 = 0 ;
9795   ptrdiff_t val2 ;
9796   int ecode2 = 0 ;
9797   void *argp3 = 0 ;
9798   int res3 = 0 ;
9799   PyObject * obj0 = 0 ;
9800   PyObject * obj1 = 0 ;
9801   PyObject * obj2 = 0 ;
9802
9803   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
9804   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9805   if (!SWIG_IsOK(res1)) {
9806     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9807   }
9808   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9809   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
9810   if (!SWIG_IsOK(ecode2)) {
9811     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
9812   }
9813   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
9814   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
9815   if (!SWIG_IsOK(res3)) {
9816     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
9817   }
9818   arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
9819   try {
9820     std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_1(arg1,arg2,arg3);
9821   }
9822   catch(std::out_of_range &_e) {
9823     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9824   }
9825
9826   resultobj = SWIG_Py_Void();
9827   return resultobj;
9828 fail:
9829   return NULL;
9830 }
9831
9832
9833 SWIGINTERN PyObject *_wrap_VectorEdges___setitem__(PyObject *self, PyObject *args) {
9834   int argc;
9835   PyObject *argv[4];
9836   int ii;
9837
9838   if (!PyTuple_Check(args)) SWIG_fail;
9839   argc = (int)PyObject_Length(args);
9840   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
9841     argv[ii] = PyTuple_GET_ITEM(args,ii);
9842   }
9843   if (argc == 3) {
9844     int _v;
9845     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
9846     _v = SWIG_CheckState(res);
9847     if (_v) {
9848       {
9849         _v = PySlice_Check(argv[1]);
9850       }
9851       if (_v) {
9852         int res = swig::asptr(argv[2], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
9853         _v = SWIG_CheckState(res);
9854         if (_v) {
9855           return _wrap_VectorEdges___setitem____SWIG_0(self, args);
9856         }
9857       }
9858     }
9859   }
9860   if (argc == 3) {
9861     int _v;
9862     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
9863     _v = SWIG_CheckState(res);
9864     if (_v) {
9865       {
9866         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
9867         _v = SWIG_CheckState(res);
9868       }
9869       if (_v) {
9870         void *vptr = 0;
9871         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0);
9872         _v = SWIG_CheckState(res);
9873         if (_v) {
9874           return _wrap_VectorEdges___setitem____SWIG_1(self, args);
9875         }
9876       }
9877     }
9878   }
9879
9880 fail:
9881   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges___setitem__'.\n"
9882     "  Possible C/C++ prototypes are:\n"
9883     "    __setitem__(std::vector< Hex::Edge * > *,PySliceObject *,std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)\n"
9884     "    __setitem__(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::difference_type,std::vector< Hex::Edge * >::value_type)\n");
9885   return NULL;
9886 }
9887
9888
9889 SWIGINTERN PyObject *_wrap_VectorEdges_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9890   PyObject *resultobj = 0;
9891   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9892   std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
9893   void *argp1 = 0 ;
9894   int res1 = 0 ;
9895   void *argp2 = 0 ;
9896   int res2 = 0 ;
9897   PyObject * obj0 = 0 ;
9898   PyObject * obj1 = 0 ;
9899
9900   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_append",&obj0,&obj1)) SWIG_fail;
9901   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9902   if (!SWIG_IsOK(res1)) {
9903     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_append" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
9904   }
9905   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9906   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
9907   if (!SWIG_IsOK(res2)) {
9908     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_append" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
9909   }
9910   arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
9911   std_vector_Sl_Hex_Edge_Sm__Sg__append(arg1,arg2);
9912   resultobj = SWIG_Py_Void();
9913   return resultobj;
9914 fail:
9915   return NULL;
9916 }
9917
9918
9919 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9920   PyObject *resultobj = 0;
9921   std::vector< Hex::Edge * > *result = 0 ;
9922
9923   if (!PyArg_ParseTuple(args,(char *)":new_VectorEdges")) SWIG_fail;
9924   result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >();
9925   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
9926   return resultobj;
9927 fail:
9928   return NULL;
9929 }
9930
9931
9932 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9933   PyObject *resultobj = 0;
9934   std::vector< Hex::Edge * > *arg1 = 0 ;
9935   int res1 = SWIG_OLDOBJ ;
9936   PyObject * obj0 = 0 ;
9937   std::vector< Hex::Edge * > *result = 0 ;
9938
9939   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
9940   {
9941     std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
9942     res1 = swig::asptr(obj0, &ptr);
9943     if (!SWIG_IsOK(res1)) {
9944       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const &""'");
9945     }
9946     if (!ptr) {
9947       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const &""'");
9948     }
9949     arg1 = ptr;
9950   }
9951   result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >((std::vector< Hex::Edge * > const &)*arg1);
9952   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
9953   if (SWIG_IsNewObj(res1)) delete arg1;
9954   return resultobj;
9955 fail:
9956   if (SWIG_IsNewObj(res1)) delete arg1;
9957   return NULL;
9958 }
9959
9960
9961 SWIGINTERN PyObject *_wrap_VectorEdges_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9962   PyObject *resultobj = 0;
9963   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9964   void *argp1 = 0 ;
9965   int res1 = 0 ;
9966   PyObject * obj0 = 0 ;
9967   bool result;
9968
9969   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_empty",&obj0)) SWIG_fail;
9970   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9971   if (!SWIG_IsOK(res1)) {
9972     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_empty" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
9973   }
9974   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9975   result = (bool)((std::vector< Hex::Edge * > const *)arg1)->empty();
9976   resultobj = SWIG_From_bool(static_cast< bool >(result));
9977   return resultobj;
9978 fail:
9979   return NULL;
9980 }
9981
9982
9983 SWIGINTERN PyObject *_wrap_VectorEdges_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9984   PyObject *resultobj = 0;
9985   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
9986   void *argp1 = 0 ;
9987   int res1 = 0 ;
9988   PyObject * obj0 = 0 ;
9989   std::vector< Hex::Edge * >::size_type result;
9990
9991   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_size",&obj0)) SWIG_fail;
9992   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
9993   if (!SWIG_IsOK(res1)) {
9994     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_size" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
9995   }
9996   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
9997   result = ((std::vector< Hex::Edge * > const *)arg1)->size();
9998   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9999   return resultobj;
10000 fail:
10001   return NULL;
10002 }
10003
10004
10005 SWIGINTERN PyObject *_wrap_VectorEdges_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10006   PyObject *resultobj = 0;
10007   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10008   void *argp1 = 0 ;
10009   int res1 = 0 ;
10010   PyObject * obj0 = 0 ;
10011
10012   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_clear",&obj0)) SWIG_fail;
10013   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10014   if (!SWIG_IsOK(res1)) {
10015     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_clear" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10016   }
10017   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10018   (arg1)->clear();
10019   resultobj = SWIG_Py_Void();
10020   return resultobj;
10021 fail:
10022   return NULL;
10023 }
10024
10025
10026 SWIGINTERN PyObject *_wrap_VectorEdges_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10027   PyObject *resultobj = 0;
10028   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10029   std::vector< Hex::Edge * > *arg2 = 0 ;
10030   void *argp1 = 0 ;
10031   int res1 = 0 ;
10032   void *argp2 = 0 ;
10033   int res2 = 0 ;
10034   PyObject * obj0 = 0 ;
10035   PyObject * obj1 = 0 ;
10036
10037   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_swap",&obj0,&obj1)) SWIG_fail;
10038   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10039   if (!SWIG_IsOK(res1)) {
10040     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_swap" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10041   }
10042   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10043   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t,  0 );
10044   if (!SWIG_IsOK(res2)) {
10045     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector< Hex::Edge * > &""'");
10046   }
10047   if (!argp2) {
10048     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector< Hex::Edge * > &""'");
10049   }
10050   arg2 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp2);
10051   (arg1)->swap(*arg2);
10052   resultobj = SWIG_Py_Void();
10053   return resultobj;
10054 fail:
10055   return NULL;
10056 }
10057
10058
10059 SWIGINTERN PyObject *_wrap_VectorEdges_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10060   PyObject *resultobj = 0;
10061   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10062   void *argp1 = 0 ;
10063   int res1 = 0 ;
10064   PyObject * obj0 = 0 ;
10065   SwigValueWrapper< std::allocator< Hex::Edge * > > result;
10066
10067   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_get_allocator",&obj0)) SWIG_fail;
10068   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10069   if (!SWIG_IsOK(res1)) {
10070     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10071   }
10072   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10073   result = ((std::vector< Hex::Edge * > const *)arg1)->get_allocator();
10074   resultobj = SWIG_NewPointerObj((new std::vector< Hex::Edge * >::allocator_type(static_cast< const std::vector< Hex::Edge * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
10075   return resultobj;
10076 fail:
10077   return NULL;
10078 }
10079
10080
10081 SWIGINTERN PyObject *_wrap_VectorEdges_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10082   PyObject *resultobj = 0;
10083   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10084   void *argp1 = 0 ;
10085   int res1 = 0 ;
10086   PyObject * obj0 = 0 ;
10087   std::vector< Hex::Edge * >::const_iterator result;
10088
10089   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_begin",&obj0)) SWIG_fail;
10090   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10091   if (!SWIG_IsOK(res1)) {
10092     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_begin" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10093   }
10094   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10095   result = ((std::vector< Hex::Edge * > const *)arg1)->begin();
10096   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::const_iterator & >(result)),
10097     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
10098   return resultobj;
10099 fail:
10100   return NULL;
10101 }
10102
10103
10104 SWIGINTERN PyObject *_wrap_VectorEdges_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10105   PyObject *resultobj = 0;
10106   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10107   void *argp1 = 0 ;
10108   int res1 = 0 ;
10109   PyObject * obj0 = 0 ;
10110   std::vector< Hex::Edge * >::const_iterator result;
10111
10112   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_end",&obj0)) SWIG_fail;
10113   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10114   if (!SWIG_IsOK(res1)) {
10115     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_end" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10116   }
10117   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10118   result = ((std::vector< Hex::Edge * > const *)arg1)->end();
10119   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::const_iterator & >(result)),
10120     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
10121   return resultobj;
10122 fail:
10123   return NULL;
10124 }
10125
10126
10127 SWIGINTERN PyObject *_wrap_VectorEdges_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10128   PyObject *resultobj = 0;
10129   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10130   void *argp1 = 0 ;
10131   int res1 = 0 ;
10132   PyObject * obj0 = 0 ;
10133   std::vector< Hex::Edge * >::const_reverse_iterator result;
10134
10135   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rbegin",&obj0)) SWIG_fail;
10136   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10137   if (!SWIG_IsOK(res1)) {
10138     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10139   }
10140   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10141   result = ((std::vector< Hex::Edge * > const *)arg1)->rbegin();
10142   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::const_reverse_iterator & >(result)),
10143     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
10144   return resultobj;
10145 fail:
10146   return NULL;
10147 }
10148
10149
10150 SWIGINTERN PyObject *_wrap_VectorEdges_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10151   PyObject *resultobj = 0;
10152   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10153   void *argp1 = 0 ;
10154   int res1 = 0 ;
10155   PyObject * obj0 = 0 ;
10156   std::vector< Hex::Edge * >::const_reverse_iterator result;
10157
10158   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rend",&obj0)) SWIG_fail;
10159   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10160   if (!SWIG_IsOK(res1)) {
10161     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rend" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10162   }
10163   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10164   result = ((std::vector< Hex::Edge * > const *)arg1)->rend();
10165   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::const_reverse_iterator & >(result)),
10166     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
10167   return resultobj;
10168 fail:
10169   return NULL;
10170 }
10171
10172
10173 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10174   PyObject *resultobj = 0;
10175   std::vector< Hex::Edge * >::size_type arg1 ;
10176   size_t val1 ;
10177   int ecode1 = 0 ;
10178   PyObject * obj0 = 0 ;
10179   std::vector< Hex::Edge * > *result = 0 ;
10180
10181   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
10182   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10183   if (!SWIG_IsOK(ecode1)) {
10184     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * >::size_type""'");
10185   }
10186   arg1 = static_cast< std::vector< Hex::Edge * >::size_type >(val1);
10187   result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >(arg1);
10188   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
10189   return resultobj;
10190 fail:
10191   return NULL;
10192 }
10193
10194
10195 SWIGINTERN PyObject *_wrap_VectorEdges_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10196   PyObject *resultobj = 0;
10197   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10198   void *argp1 = 0 ;
10199   int res1 = 0 ;
10200   PyObject * obj0 = 0 ;
10201
10202   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop_back",&obj0)) SWIG_fail;
10203   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10204   if (!SWIG_IsOK(res1)) {
10205     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10206   }
10207   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10208   (arg1)->pop_back();
10209   resultobj = SWIG_Py_Void();
10210   return resultobj;
10211 fail:
10212   return NULL;
10213 }
10214
10215
10216 SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10217   PyObject *resultobj = 0;
10218   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10219   std::vector< Hex::Edge * >::size_type arg2 ;
10220   void *argp1 = 0 ;
10221   int res1 = 0 ;
10222   size_t val2 ;
10223   int ecode2 = 0 ;
10224   PyObject * obj0 = 0 ;
10225   PyObject * obj1 = 0 ;
10226
10227   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_resize",&obj0,&obj1)) SWIG_fail;
10228   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10229   if (!SWIG_IsOK(res1)) {
10230     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10231   }
10232   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10233   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10234   if (!SWIG_IsOK(ecode2)) {
10235     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
10236   }
10237   arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
10238   (arg1)->resize(arg2);
10239   resultobj = SWIG_Py_Void();
10240   return resultobj;
10241 fail:
10242   return NULL;
10243 }
10244
10245
10246 SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10247   PyObject *resultobj = 0;
10248   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10249   std::vector< Hex::Edge * >::iterator arg2 ;
10250   void *argp1 = 0 ;
10251   int res1 = 0 ;
10252   swig::SwigPyIterator *iter2 = 0 ;
10253   int res2 ;
10254   PyObject * obj0 = 0 ;
10255   PyObject * obj1 = 0 ;
10256   std::vector< Hex::Edge * >::iterator result;
10257
10258   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_erase",&obj0,&obj1)) SWIG_fail;
10259   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10260   if (!SWIG_IsOK(res1)) {
10261     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10262   }
10263   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10264   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
10265   if (!SWIG_IsOK(res2) || !iter2) {
10266     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
10267   } else {
10268     swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
10269     if (iter_t) {
10270       arg2 = iter_t->get_current();
10271     } else {
10272       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
10273     }
10274   }
10275   result = (arg1)->erase(arg2);
10276   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
10277     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
10278   return resultobj;
10279 fail:
10280   return NULL;
10281 }
10282
10283
10284 SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10285   PyObject *resultobj = 0;
10286   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10287   std::vector< Hex::Edge * >::iterator arg2 ;
10288   std::vector< Hex::Edge * >::iterator arg3 ;
10289   void *argp1 = 0 ;
10290   int res1 = 0 ;
10291   swig::SwigPyIterator *iter2 = 0 ;
10292   int res2 ;
10293   swig::SwigPyIterator *iter3 = 0 ;
10294   int res3 ;
10295   PyObject * obj0 = 0 ;
10296   PyObject * obj1 = 0 ;
10297   PyObject * obj2 = 0 ;
10298   std::vector< Hex::Edge * >::iterator result;
10299
10300   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_erase",&obj0,&obj1,&obj2)) SWIG_fail;
10301   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10302   if (!SWIG_IsOK(res1)) {
10303     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10304   }
10305   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10306   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
10307   if (!SWIG_IsOK(res2) || !iter2) {
10308     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
10309   } else {
10310     swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
10311     if (iter_t) {
10312       arg2 = iter_t->get_current();
10313     } else {
10314       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
10315     }
10316   }
10317   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
10318   if (!SWIG_IsOK(res3) || !iter3) {
10319     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::iterator""'");
10320   } else {
10321     swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter3);
10322     if (iter_t) {
10323       arg3 = iter_t->get_current();
10324     } else {
10325       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::iterator""'");
10326     }
10327   }
10328   result = (arg1)->erase(arg2,arg3);
10329   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
10330     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
10331   return resultobj;
10332 fail:
10333   return NULL;
10334 }
10335
10336
10337 SWIGINTERN PyObject *_wrap_VectorEdges_erase(PyObject *self, PyObject *args) {
10338   int argc;
10339   PyObject *argv[4];
10340   int ii;
10341
10342   if (!PyTuple_Check(args)) SWIG_fail;
10343   argc = (int)PyObject_Length(args);
10344   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
10345     argv[ii] = PyTuple_GET_ITEM(args,ii);
10346   }
10347   if (argc == 2) {
10348     int _v;
10349     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10350     _v = SWIG_CheckState(res);
10351     if (_v) {
10352       swig::SwigPyIterator *iter = 0;
10353       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
10354       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
10355       if (_v) {
10356         return _wrap_VectorEdges_erase__SWIG_0(self, args);
10357       }
10358     }
10359   }
10360   if (argc == 3) {
10361     int _v;
10362     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10363     _v = SWIG_CheckState(res);
10364     if (_v) {
10365       swig::SwigPyIterator *iter = 0;
10366       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
10367       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
10368       if (_v) {
10369         swig::SwigPyIterator *iter = 0;
10370         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
10371         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
10372         if (_v) {
10373           return _wrap_VectorEdges_erase__SWIG_1(self, args);
10374         }
10375       }
10376     }
10377   }
10378
10379 fail:
10380   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_erase'.\n"
10381     "  Possible C/C++ prototypes are:\n"
10382     "    erase(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::iterator)\n"
10383     "    erase(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::iterator)\n");
10384   return NULL;
10385 }
10386
10387
10388 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10389   PyObject *resultobj = 0;
10390   std::vector< Hex::Edge * >::size_type arg1 ;
10391   std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
10392   size_t val1 ;
10393   int ecode1 = 0 ;
10394   void *argp2 = 0 ;
10395   int res2 = 0 ;
10396   PyObject * obj0 = 0 ;
10397   PyObject * obj1 = 0 ;
10398   std::vector< Hex::Edge * > *result = 0 ;
10399
10400   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorEdges",&obj0,&obj1)) SWIG_fail;
10401   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10402   if (!SWIG_IsOK(ecode1)) {
10403     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * >::size_type""'");
10404   }
10405   arg1 = static_cast< std::vector< Hex::Edge * >::size_type >(val1);
10406   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
10407   if (!SWIG_IsOK(res2)) {
10408     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorEdges" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
10409   }
10410   arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
10411   result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >(arg1,arg2);
10412   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
10413   return resultobj;
10414 fail:
10415   return NULL;
10416 }
10417
10418
10419 SWIGINTERN PyObject *_wrap_new_VectorEdges(PyObject *self, PyObject *args) {
10420   int argc;
10421   PyObject *argv[3];
10422   int ii;
10423
10424   if (!PyTuple_Check(args)) SWIG_fail;
10425   argc = (int)PyObject_Length(args);
10426   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10427     argv[ii] = PyTuple_GET_ITEM(args,ii);
10428   }
10429   if (argc == 0) {
10430     return _wrap_new_VectorEdges__SWIG_0(self, args);
10431   }
10432   if (argc == 1) {
10433     int _v;
10434     {
10435       int res = SWIG_AsVal_size_t(argv[0], NULL);
10436       _v = SWIG_CheckState(res);
10437     }
10438     if (_v) {
10439       return _wrap_new_VectorEdges__SWIG_2(self, args);
10440     }
10441   }
10442   if (argc == 1) {
10443     int _v;
10444     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10445     _v = SWIG_CheckState(res);
10446     if (_v) {
10447       return _wrap_new_VectorEdges__SWIG_1(self, args);
10448     }
10449   }
10450   if (argc == 2) {
10451     int _v;
10452     {
10453       int res = SWIG_AsVal_size_t(argv[0], NULL);
10454       _v = SWIG_CheckState(res);
10455     }
10456     if (_v) {
10457       void *vptr = 0;
10458       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0);
10459       _v = SWIG_CheckState(res);
10460       if (_v) {
10461         return _wrap_new_VectorEdges__SWIG_3(self, args);
10462       }
10463     }
10464   }
10465
10466 fail:
10467   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorEdges'.\n"
10468     "  Possible C/C++ prototypes are:\n"
10469     "    std::vector< Hex::Edge * >()\n"
10470     "    std::vector< Hex::Edge * >(std::vector< Hex::Edge * > const &)\n"
10471     "    std::vector< Hex::Edge * >(std::vector< Hex::Edge * >::size_type)\n"
10472     "    std::vector< Hex::Edge * >(std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
10473   return NULL;
10474 }
10475
10476
10477 SWIGINTERN PyObject *_wrap_VectorEdges_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10478   PyObject *resultobj = 0;
10479   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10480   std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
10481   void *argp1 = 0 ;
10482   int res1 = 0 ;
10483   void *argp2 = 0 ;
10484   int res2 = 0 ;
10485   PyObject * obj0 = 0 ;
10486   PyObject * obj1 = 0 ;
10487
10488   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_push_back",&obj0,&obj1)) SWIG_fail;
10489   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10490   if (!SWIG_IsOK(res1)) {
10491     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_push_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10492   }
10493   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10494   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
10495   if (!SWIG_IsOK(res2)) {
10496     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_push_back" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
10497   }
10498   arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
10499   (arg1)->push_back(arg2);
10500   resultobj = SWIG_Py_Void();
10501   return resultobj;
10502 fail:
10503   return NULL;
10504 }
10505
10506
10507 SWIGINTERN PyObject *_wrap_VectorEdges_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10508   PyObject *resultobj = 0;
10509   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10510   void *argp1 = 0 ;
10511   int res1 = 0 ;
10512   PyObject * obj0 = 0 ;
10513   std::vector< Hex::Edge * >::value_type result;
10514
10515   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_front",&obj0)) SWIG_fail;
10516   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10517   if (!SWIG_IsOK(res1)) {
10518     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_front" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10519   }
10520   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10521   result = (std::vector< Hex::Edge * >::value_type)((std::vector< Hex::Edge * > const *)arg1)->front();
10522   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
10523   return resultobj;
10524 fail:
10525   return NULL;
10526 }
10527
10528
10529 SWIGINTERN PyObject *_wrap_VectorEdges_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10530   PyObject *resultobj = 0;
10531   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10532   void *argp1 = 0 ;
10533   int res1 = 0 ;
10534   PyObject * obj0 = 0 ;
10535   std::vector< Hex::Edge * >::value_type result;
10536
10537   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_back",&obj0)) SWIG_fail;
10538   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10539   if (!SWIG_IsOK(res1)) {
10540     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10541   }
10542   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10543   result = (std::vector< Hex::Edge * >::value_type)((std::vector< Hex::Edge * > const *)arg1)->back();
10544   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
10545   return resultobj;
10546 fail:
10547   return NULL;
10548 }
10549
10550
10551 SWIGINTERN PyObject *_wrap_VectorEdges_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10552   PyObject *resultobj = 0;
10553   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10554   std::vector< Hex::Edge * >::size_type arg2 ;
10555   std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
10556   void *argp1 = 0 ;
10557   int res1 = 0 ;
10558   size_t val2 ;
10559   int ecode2 = 0 ;
10560   void *argp3 = 0 ;
10561   int res3 = 0 ;
10562   PyObject * obj0 = 0 ;
10563   PyObject * obj1 = 0 ;
10564   PyObject * obj2 = 0 ;
10565
10566   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_assign",&obj0,&obj1,&obj2)) SWIG_fail;
10567   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10568   if (!SWIG_IsOK(res1)) {
10569     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_assign" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10570   }
10571   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10572   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10573   if (!SWIG_IsOK(ecode2)) {
10574     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_assign" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
10575   }
10576   arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
10577   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
10578   if (!SWIG_IsOK(res3)) {
10579     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_assign" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
10580   }
10581   arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
10582   (arg1)->assign(arg2,arg3);
10583   resultobj = SWIG_Py_Void();
10584   return resultobj;
10585 fail:
10586   return NULL;
10587 }
10588
10589
10590 SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10591   PyObject *resultobj = 0;
10592   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10593   std::vector< Hex::Edge * >::size_type arg2 ;
10594   std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
10595   void *argp1 = 0 ;
10596   int res1 = 0 ;
10597   size_t val2 ;
10598   int ecode2 = 0 ;
10599   void *argp3 = 0 ;
10600   int res3 = 0 ;
10601   PyObject * obj0 = 0 ;
10602   PyObject * obj1 = 0 ;
10603   PyObject * obj2 = 0 ;
10604
10605   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_resize",&obj0,&obj1,&obj2)) SWIG_fail;
10606   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10607   if (!SWIG_IsOK(res1)) {
10608     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10609   }
10610   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10611   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10612   if (!SWIG_IsOK(ecode2)) {
10613     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
10614   }
10615   arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
10616   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
10617   if (!SWIG_IsOK(res3)) {
10618     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_resize" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
10619   }
10620   arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
10621   (arg1)->resize(arg2,arg3);
10622   resultobj = SWIG_Py_Void();
10623   return resultobj;
10624 fail:
10625   return NULL;
10626 }
10627
10628
10629 SWIGINTERN PyObject *_wrap_VectorEdges_resize(PyObject *self, PyObject *args) {
10630   int argc;
10631   PyObject *argv[4];
10632   int ii;
10633
10634   if (!PyTuple_Check(args)) SWIG_fail;
10635   argc = (int)PyObject_Length(args);
10636   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
10637     argv[ii] = PyTuple_GET_ITEM(args,ii);
10638   }
10639   if (argc == 2) {
10640     int _v;
10641     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10642     _v = SWIG_CheckState(res);
10643     if (_v) {
10644       {
10645         int res = SWIG_AsVal_size_t(argv[1], NULL);
10646         _v = SWIG_CheckState(res);
10647       }
10648       if (_v) {
10649         return _wrap_VectorEdges_resize__SWIG_0(self, args);
10650       }
10651     }
10652   }
10653   if (argc == 3) {
10654     int _v;
10655     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10656     _v = SWIG_CheckState(res);
10657     if (_v) {
10658       {
10659         int res = SWIG_AsVal_size_t(argv[1], NULL);
10660         _v = SWIG_CheckState(res);
10661       }
10662       if (_v) {
10663         void *vptr = 0;
10664         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0);
10665         _v = SWIG_CheckState(res);
10666         if (_v) {
10667           return _wrap_VectorEdges_resize__SWIG_1(self, args);
10668         }
10669       }
10670     }
10671   }
10672
10673 fail:
10674   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_resize'.\n"
10675     "  Possible C/C++ prototypes are:\n"
10676     "    resize(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::size_type)\n"
10677     "    resize(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
10678   return NULL;
10679 }
10680
10681
10682 SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10683   PyObject *resultobj = 0;
10684   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10685   std::vector< Hex::Edge * >::iterator arg2 ;
10686   std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
10687   void *argp1 = 0 ;
10688   int res1 = 0 ;
10689   swig::SwigPyIterator *iter2 = 0 ;
10690   int res2 ;
10691   void *argp3 = 0 ;
10692   int res3 = 0 ;
10693   PyObject * obj0 = 0 ;
10694   PyObject * obj1 = 0 ;
10695   PyObject * obj2 = 0 ;
10696   std::vector< Hex::Edge * >::iterator result;
10697
10698   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_insert",&obj0,&obj1,&obj2)) SWIG_fail;
10699   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10700   if (!SWIG_IsOK(res1)) {
10701     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10702   }
10703   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10704   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
10705   if (!SWIG_IsOK(res2) || !iter2) {
10706     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
10707   } else {
10708     swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
10709     if (iter_t) {
10710       arg2 = iter_t->get_current();
10711     } else {
10712       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
10713     }
10714   }
10715   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
10716   if (!SWIG_IsOK(res3)) {
10717     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
10718   }
10719   arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
10720   result = (arg1)->insert(arg2,arg3);
10721   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
10722     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
10723   return resultobj;
10724 fail:
10725   return NULL;
10726 }
10727
10728
10729 SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10730   PyObject *resultobj = 0;
10731   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10732   std::vector< Hex::Edge * >::iterator arg2 ;
10733   std::vector< Hex::Edge * >::size_type arg3 ;
10734   std::vector< Hex::Edge * >::value_type arg4 = (std::vector< Hex::Edge * >::value_type) 0 ;
10735   void *argp1 = 0 ;
10736   int res1 = 0 ;
10737   swig::SwigPyIterator *iter2 = 0 ;
10738   int res2 ;
10739   size_t val3 ;
10740   int ecode3 = 0 ;
10741   void *argp4 = 0 ;
10742   int res4 = 0 ;
10743   PyObject * obj0 = 0 ;
10744   PyObject * obj1 = 0 ;
10745   PyObject * obj2 = 0 ;
10746   PyObject * obj3 = 0 ;
10747
10748   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10749   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10750   if (!SWIG_IsOK(res1)) {
10751     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10752   }
10753   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10754   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
10755   if (!SWIG_IsOK(res2) || !iter2) {
10756     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
10757   } else {
10758     swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
10759     if (iter_t) {
10760       arg2 = iter_t->get_current();
10761     } else {
10762       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
10763     }
10764   }
10765   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
10766   if (!SWIG_IsOK(ecode3)) {
10767     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::size_type""'");
10768   }
10769   arg3 = static_cast< std::vector< Hex::Edge * >::size_type >(val3);
10770   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0 |  0 );
10771   if (!SWIG_IsOK(res4)) {
10772     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges_insert" "', argument " "4"" of type '" "std::vector< Hex::Edge * >::value_type""'");
10773   }
10774   arg4 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp4);
10775   (arg1)->insert(arg2,arg3,arg4);
10776   resultobj = SWIG_Py_Void();
10777   return resultobj;
10778 fail:
10779   return NULL;
10780 }
10781
10782
10783 SWIGINTERN PyObject *_wrap_VectorEdges_insert(PyObject *self, PyObject *args) {
10784   int argc;
10785   PyObject *argv[5];
10786   int ii;
10787
10788   if (!PyTuple_Check(args)) SWIG_fail;
10789   argc = (int)PyObject_Length(args);
10790   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
10791     argv[ii] = PyTuple_GET_ITEM(args,ii);
10792   }
10793   if (argc == 3) {
10794     int _v;
10795     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10796     _v = SWIG_CheckState(res);
10797     if (_v) {
10798       swig::SwigPyIterator *iter = 0;
10799       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
10800       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
10801       if (_v) {
10802         void *vptr = 0;
10803         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0);
10804         _v = SWIG_CheckState(res);
10805         if (_v) {
10806           return _wrap_VectorEdges_insert__SWIG_0(self, args);
10807         }
10808       }
10809     }
10810   }
10811   if (argc == 4) {
10812     int _v;
10813     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10814     _v = SWIG_CheckState(res);
10815     if (_v) {
10816       swig::SwigPyIterator *iter = 0;
10817       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
10818       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
10819       if (_v) {
10820         {
10821           int res = SWIG_AsVal_size_t(argv[2], NULL);
10822           _v = SWIG_CheckState(res);
10823         }
10824         if (_v) {
10825           void *vptr = 0;
10826           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0);
10827           _v = SWIG_CheckState(res);
10828           if (_v) {
10829             return _wrap_VectorEdges_insert__SWIG_1(self, args);
10830           }
10831         }
10832       }
10833     }
10834   }
10835
10836 fail:
10837   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_insert'.\n"
10838     "  Possible C/C++ prototypes are:\n"
10839     "    insert(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::value_type)\n"
10840     "    insert(std::vector< Hex::Edge * > *,std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
10841   return NULL;
10842 }
10843
10844
10845 SWIGINTERN PyObject *_wrap_VectorEdges_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10846   PyObject *resultobj = 0;
10847   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10848   std::vector< Hex::Edge * >::size_type arg2 ;
10849   void *argp1 = 0 ;
10850   int res1 = 0 ;
10851   size_t val2 ;
10852   int ecode2 = 0 ;
10853   PyObject * obj0 = 0 ;
10854   PyObject * obj1 = 0 ;
10855
10856   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_reserve",&obj0,&obj1)) SWIG_fail;
10857   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10858   if (!SWIG_IsOK(res1)) {
10859     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_reserve" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10860   }
10861   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10862   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10863   if (!SWIG_IsOK(ecode2)) {
10864     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_reserve" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
10865   }
10866   arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
10867   (arg1)->reserve(arg2);
10868   resultobj = SWIG_Py_Void();
10869   return resultobj;
10870 fail:
10871   return NULL;
10872 }
10873
10874
10875 SWIGINTERN PyObject *_wrap_VectorEdges_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10876   PyObject *resultobj = 0;
10877   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10878   void *argp1 = 0 ;
10879   int res1 = 0 ;
10880   PyObject * obj0 = 0 ;
10881   std::vector< Hex::Edge * >::size_type result;
10882
10883   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_capacity",&obj0)) SWIG_fail;
10884   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10885   if (!SWIG_IsOK(res1)) {
10886     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_capacity" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10887   }
10888   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10889   result = ((std::vector< Hex::Edge * > const *)arg1)->capacity();
10890   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10891   return resultobj;
10892 fail:
10893   return NULL;
10894 }
10895
10896
10897 SWIGINTERN PyObject *_wrap_delete_VectorEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10898   PyObject *resultobj = 0;
10899   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10900   void *argp1 = 0 ;
10901   int res1 = 0 ;
10902   PyObject * obj0 = 0 ;
10903
10904   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorEdges",&obj0)) SWIG_fail;
10905   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_DISOWN |  0 );
10906   if (!SWIG_IsOK(res1)) {
10907     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10908   }
10909   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10910   delete arg1;
10911   resultobj = SWIG_Py_Void();
10912   return resultobj;
10913 fail:
10914   return NULL;
10915 }
10916
10917
10918 SWIGINTERN PyObject *VectorEdges_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10919   PyObject *obj;
10920   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
10921   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_NewClientData(obj));
10922   return SWIG_Py_Void();
10923 }
10924
10925 SWIGINTERN PyObject *_wrap_VectorVertices_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10926   PyObject *resultobj = 0;
10927   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
10928   PyObject **arg2 = (PyObject **) 0 ;
10929   void *argp1 = 0 ;
10930   int res1 = 0 ;
10931   PyObject * obj0 = 0 ;
10932   swig::SwigPyIterator *result = 0 ;
10933
10934   arg2 = &obj0;
10935   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_iterator",&obj0)) SWIG_fail;
10936   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
10937   if (!SWIG_IsOK(res1)) {
10938     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_iterator" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
10939   }
10940   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
10941   result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(arg1,arg2);
10942   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
10943   return resultobj;
10944 fail:
10945   return NULL;
10946 }
10947
10948
10949 SWIGINTERN PyObject *_wrap_VectorVertices___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10950   PyObject *resultobj = 0;
10951   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
10952   void *argp1 = 0 ;
10953   int res1 = 0 ;
10954   PyObject * obj0 = 0 ;
10955   bool result;
10956
10957   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___nonzero__",&obj0)) SWIG_fail;
10958   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
10959   if (!SWIG_IsOK(res1)) {
10960     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
10961   }
10962   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
10963   result = (bool)std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__((std::vector< Hex::Vertex * > const *)arg1);
10964   resultobj = SWIG_From_bool(static_cast< bool >(result));
10965   return resultobj;
10966 fail:
10967   return NULL;
10968 }
10969
10970
10971 SWIGINTERN PyObject *_wrap_VectorVertices___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10972   PyObject *resultobj = 0;
10973   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
10974   void *argp1 = 0 ;
10975   int res1 = 0 ;
10976   PyObject * obj0 = 0 ;
10977   bool result;
10978
10979   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___bool__",&obj0)) SWIG_fail;
10980   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
10981   if (!SWIG_IsOK(res1)) {
10982     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___bool__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
10983   }
10984   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
10985   result = (bool)std_vector_Sl_Hex_Vertex_Sm__Sg____bool__((std::vector< Hex::Vertex * > const *)arg1);
10986   resultobj = SWIG_From_bool(static_cast< bool >(result));
10987   return resultobj;
10988 fail:
10989   return NULL;
10990 }
10991
10992
10993 SWIGINTERN PyObject *_wrap_VectorVertices___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10994   PyObject *resultobj = 0;
10995   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
10996   void *argp1 = 0 ;
10997   int res1 = 0 ;
10998   PyObject * obj0 = 0 ;
10999   std::vector< Hex::Vertex * >::size_type result;
11000
11001   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___len__",&obj0)) SWIG_fail;
11002   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11003   if (!SWIG_IsOK(res1)) {
11004     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___len__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
11005   }
11006   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11007   result = std_vector_Sl_Hex_Vertex_Sm__Sg____len__((std::vector< Hex::Vertex * > const *)arg1);
11008   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11009   return resultobj;
11010 fail:
11011   return NULL;
11012 }
11013
11014
11015 SWIGINTERN PyObject *_wrap_VectorVertices_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11016   PyObject *resultobj = 0;
11017   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11018   void *argp1 = 0 ;
11019   int res1 = 0 ;
11020   PyObject * obj0 = 0 ;
11021   std::vector< Hex::Vertex * >::value_type result;
11022
11023   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop",&obj0)) SWIG_fail;
11024   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11025   if (!SWIG_IsOK(res1)) {
11026     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11027   }
11028   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11029   try {
11030     result = (std::vector< Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg__pop(arg1);
11031   }
11032   catch(std::out_of_range &_e) {
11033     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11034   }
11035
11036   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
11037   return resultobj;
11038 fail:
11039   return NULL;
11040 }
11041
11042
11043 SWIGINTERN PyObject *_wrap_VectorVertices___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11044   PyObject *resultobj = 0;
11045   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11046   std::vector< Hex::Vertex * >::difference_type arg2 ;
11047   std::vector< Hex::Vertex * >::difference_type arg3 ;
11048   void *argp1 = 0 ;
11049   int res1 = 0 ;
11050   ptrdiff_t val2 ;
11051   int ecode2 = 0 ;
11052   ptrdiff_t val3 ;
11053   int ecode3 = 0 ;
11054   PyObject * obj0 = 0 ;
11055   PyObject * obj1 = 0 ;
11056   PyObject * obj2 = 0 ;
11057   std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *result = 0 ;
11058
11059   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
11060   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11061   if (!SWIG_IsOK(res1)) {
11062     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11063   }
11064   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11065   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11066   if (!SWIG_IsOK(ecode2)) {
11067     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
11068   }
11069   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
11070   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
11071   if (!SWIG_IsOK(ecode3)) {
11072     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
11073   }
11074   arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
11075   try {
11076     result = (std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *)std_vector_Sl_Hex_Vertex_Sm__Sg____getslice__(arg1,arg2,arg3);
11077   }
11078   catch(std::out_of_range &_e) {
11079     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11080   }
11081
11082   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_OWN |  0 );
11083   return resultobj;
11084 fail:
11085   return NULL;
11086 }
11087
11088
11089 SWIGINTERN PyObject *_wrap_VectorVertices___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11090   PyObject *resultobj = 0;
11091   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11092   std::vector< Hex::Vertex * >::difference_type arg2 ;
11093   std::vector< Hex::Vertex * >::difference_type arg3 ;
11094   std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *arg4 = 0 ;
11095   void *argp1 = 0 ;
11096   int res1 = 0 ;
11097   ptrdiff_t val2 ;
11098   int ecode2 = 0 ;
11099   ptrdiff_t val3 ;
11100   int ecode3 = 0 ;
11101   int res4 = SWIG_OLDOBJ ;
11102   PyObject * obj0 = 0 ;
11103   PyObject * obj1 = 0 ;
11104   PyObject * obj2 = 0 ;
11105   PyObject * obj3 = 0 ;
11106
11107   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11108   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11109   if (!SWIG_IsOK(res1)) {
11110     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11111   }
11112   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11113   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11114   if (!SWIG_IsOK(ecode2)) {
11115     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
11116   }
11117   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
11118   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
11119   if (!SWIG_IsOK(ecode3)) {
11120     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
11121   }
11122   arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
11123   {
11124     std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
11125     res4 = swig::asptr(obj3, &ptr);
11126     if (!SWIG_IsOK(res4)) {
11127       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
11128     }
11129     if (!ptr) {
11130       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
11131     }
11132     arg4 = ptr;
11133   }
11134   try {
11135     std_vector_Sl_Hex_Vertex_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)*arg4);
11136   }
11137   catch(std::out_of_range &_e) {
11138     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11139   }
11140   catch(std::invalid_argument &_e) {
11141     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
11142   }
11143
11144   resultobj = SWIG_Py_Void();
11145   if (SWIG_IsNewObj(res4)) delete arg4;
11146   return resultobj;
11147 fail:
11148   if (SWIG_IsNewObj(res4)) delete arg4;
11149   return NULL;
11150 }
11151
11152
11153 SWIGINTERN PyObject *_wrap_VectorVertices___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11154   PyObject *resultobj = 0;
11155   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11156   std::vector< Hex::Vertex * >::difference_type arg2 ;
11157   std::vector< Hex::Vertex * >::difference_type arg3 ;
11158   void *argp1 = 0 ;
11159   int res1 = 0 ;
11160   ptrdiff_t val2 ;
11161   int ecode2 = 0 ;
11162   ptrdiff_t val3 ;
11163   int ecode3 = 0 ;
11164   PyObject * obj0 = 0 ;
11165   PyObject * obj1 = 0 ;
11166   PyObject * obj2 = 0 ;
11167
11168   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
11169   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11170   if (!SWIG_IsOK(res1)) {
11171     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11172   }
11173   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11174   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11175   if (!SWIG_IsOK(ecode2)) {
11176     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
11177   }
11178   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
11179   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
11180   if (!SWIG_IsOK(ecode3)) {
11181     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
11182   }
11183   arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
11184   try {
11185     std_vector_Sl_Hex_Vertex_Sm__Sg____delslice__(arg1,arg2,arg3);
11186   }
11187   catch(std::out_of_range &_e) {
11188     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11189   }
11190
11191   resultobj = SWIG_Py_Void();
11192   return resultobj;
11193 fail:
11194   return NULL;
11195 }
11196
11197
11198 SWIGINTERN PyObject *_wrap_VectorVertices___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11199   PyObject *resultobj = 0;
11200   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11201   std::vector< Hex::Vertex * >::difference_type arg2 ;
11202   void *argp1 = 0 ;
11203   int res1 = 0 ;
11204   ptrdiff_t val2 ;
11205   int ecode2 = 0 ;
11206   PyObject * obj0 = 0 ;
11207   PyObject * obj1 = 0 ;
11208
11209   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___delitem__",&obj0,&obj1)) SWIG_fail;
11210   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11211   if (!SWIG_IsOK(res1)) {
11212     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11213   }
11214   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11215   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11216   if (!SWIG_IsOK(ecode2)) {
11217     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
11218   }
11219   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
11220   try {
11221     std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_0(arg1,arg2);
11222   }
11223   catch(std::out_of_range &_e) {
11224     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11225   }
11226
11227   resultobj = SWIG_Py_Void();
11228   return resultobj;
11229 fail:
11230   return NULL;
11231 }
11232
11233
11234 SWIGINTERN PyObject *_wrap_VectorVertices___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11235   PyObject *resultobj = 0;
11236   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11237   PySliceObject *arg2 = (PySliceObject *) 0 ;
11238   void *argp1 = 0 ;
11239   int res1 = 0 ;
11240   PyObject * obj0 = 0 ;
11241   PyObject * obj1 = 0 ;
11242   std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *result = 0 ;
11243
11244   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___getitem__",&obj0,&obj1)) SWIG_fail;
11245   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11246   if (!SWIG_IsOK(res1)) {
11247     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11248   }
11249   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11250   {
11251     arg2 = (PySliceObject *) obj1;
11252   }
11253   try {
11254     result = (std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *)std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_0(arg1,arg2);
11255   }
11256   catch(std::out_of_range &_e) {
11257     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11258   }
11259
11260   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11261   return resultobj;
11262 fail:
11263   return NULL;
11264 }
11265
11266
11267 SWIGINTERN PyObject *_wrap_VectorVertices___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11268   PyObject *resultobj = 0;
11269   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11270   PySliceObject *arg2 = (PySliceObject *) 0 ;
11271   std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *arg3 = 0 ;
11272   void *argp1 = 0 ;
11273   int res1 = 0 ;
11274   int res3 = SWIG_OLDOBJ ;
11275   PyObject * obj0 = 0 ;
11276   PyObject * obj1 = 0 ;
11277   PyObject * obj2 = 0 ;
11278
11279   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
11280   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11281   if (!SWIG_IsOK(res1)) {
11282     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11283   }
11284   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11285   {
11286     arg2 = (PySliceObject *) obj1;
11287   }
11288   {
11289     std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
11290     res3 = swig::asptr(obj2, &ptr);
11291     if (!SWIG_IsOK(res3)) {
11292       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
11293     }
11294     if (!ptr) {
11295       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
11296     }
11297     arg3 = ptr;
11298   }
11299   try {
11300     std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)*arg3);
11301   }
11302   catch(std::out_of_range &_e) {
11303     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11304   }
11305   catch(std::invalid_argument &_e) {
11306     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
11307   }
11308
11309   resultobj = SWIG_Py_Void();
11310   if (SWIG_IsNewObj(res3)) delete arg3;
11311   return resultobj;
11312 fail:
11313   if (SWIG_IsNewObj(res3)) delete arg3;
11314   return NULL;
11315 }
11316
11317
11318 SWIGINTERN PyObject *_wrap_VectorVertices___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11319   PyObject *resultobj = 0;
11320   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11321   PySliceObject *arg2 = (PySliceObject *) 0 ;
11322   void *argp1 = 0 ;
11323   int res1 = 0 ;
11324   PyObject * obj0 = 0 ;
11325   PyObject * obj1 = 0 ;
11326
11327   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___delitem__",&obj0,&obj1)) SWIG_fail;
11328   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11329   if (!SWIG_IsOK(res1)) {
11330     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11331   }
11332   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11333   {
11334     arg2 = (PySliceObject *) obj1;
11335   }
11336   try {
11337     std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_1(arg1,arg2);
11338   }
11339   catch(std::out_of_range &_e) {
11340     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11341   }
11342
11343   resultobj = SWIG_Py_Void();
11344   return resultobj;
11345 fail:
11346   return NULL;
11347 }
11348
11349
11350 SWIGINTERN PyObject *_wrap_VectorVertices___delitem__(PyObject *self, PyObject *args) {
11351   int argc;
11352   PyObject *argv[3];
11353   int ii;
11354
11355   if (!PyTuple_Check(args)) SWIG_fail;
11356   argc = (int)PyObject_Length(args);
11357   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
11358     argv[ii] = PyTuple_GET_ITEM(args,ii);
11359   }
11360   if (argc == 2) {
11361     int _v;
11362     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
11363     _v = SWIG_CheckState(res);
11364     if (_v) {
11365       {
11366         _v = PySlice_Check(argv[1]);
11367       }
11368       if (_v) {
11369         return _wrap_VectorVertices___delitem____SWIG_1(self, args);
11370       }
11371     }
11372   }
11373   if (argc == 2) {
11374     int _v;
11375     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
11376     _v = SWIG_CheckState(res);
11377     if (_v) {
11378       {
11379         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
11380         _v = SWIG_CheckState(res);
11381       }
11382       if (_v) {
11383         return _wrap_VectorVertices___delitem____SWIG_0(self, args);
11384       }
11385     }
11386   }
11387
11388 fail:
11389   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices___delitem__'.\n"
11390     "  Possible C/C++ prototypes are:\n"
11391     "    __delitem__(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::difference_type)\n"
11392     "    __delitem__(std::vector< Hex::Vertex * > *,PySliceObject *)\n");
11393   return NULL;
11394 }
11395
11396
11397 SWIGINTERN PyObject *_wrap_VectorVertices___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11398   PyObject *resultobj = 0;
11399   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11400   std::vector< Hex::Vertex * >::difference_type arg2 ;
11401   void *argp1 = 0 ;
11402   int res1 = 0 ;
11403   ptrdiff_t val2 ;
11404   int ecode2 = 0 ;
11405   PyObject * obj0 = 0 ;
11406   PyObject * obj1 = 0 ;
11407   std::vector< Hex::Vertex * >::value_type result;
11408
11409   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___getitem__",&obj0,&obj1)) SWIG_fail;
11410   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11411   if (!SWIG_IsOK(res1)) {
11412     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11413   }
11414   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11415   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11416   if (!SWIG_IsOK(ecode2)) {
11417     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
11418   }
11419   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
11420   try {
11421     result = (std::vector< Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_1(arg1,arg2);
11422   }
11423   catch(std::out_of_range &_e) {
11424     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11425   }
11426
11427   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
11428   return resultobj;
11429 fail:
11430   return NULL;
11431 }
11432
11433
11434 SWIGINTERN PyObject *_wrap_VectorVertices___getitem__(PyObject *self, PyObject *args) {
11435   int argc;
11436   PyObject *argv[3];
11437   int ii;
11438
11439   if (!PyTuple_Check(args)) SWIG_fail;
11440   argc = (int)PyObject_Length(args);
11441   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
11442     argv[ii] = PyTuple_GET_ITEM(args,ii);
11443   }
11444   if (argc == 2) {
11445     int _v;
11446     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
11447     _v = SWIG_CheckState(res);
11448     if (_v) {
11449       {
11450         _v = PySlice_Check(argv[1]);
11451       }
11452       if (_v) {
11453         return _wrap_VectorVertices___getitem____SWIG_0(self, args);
11454       }
11455     }
11456   }
11457   if (argc == 2) {
11458     int _v;
11459     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
11460     _v = SWIG_CheckState(res);
11461     if (_v) {
11462       {
11463         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
11464         _v = SWIG_CheckState(res);
11465       }
11466       if (_v) {
11467         return _wrap_VectorVertices___getitem____SWIG_1(self, args);
11468       }
11469     }
11470   }
11471
11472 fail:
11473   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices___getitem__'.\n"
11474     "  Possible C/C++ prototypes are:\n"
11475     "    __getitem__(std::vector< Hex::Vertex * > *,PySliceObject *)\n"
11476     "    __getitem__(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::difference_type)\n");
11477   return NULL;
11478 }
11479
11480
11481 SWIGINTERN PyObject *_wrap_VectorVertices___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11482   PyObject *resultobj = 0;
11483   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11484   std::vector< Hex::Vertex * >::difference_type arg2 ;
11485   std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
11486   void *argp1 = 0 ;
11487   int res1 = 0 ;
11488   ptrdiff_t val2 ;
11489   int ecode2 = 0 ;
11490   void *argp3 = 0 ;
11491   int res3 = 0 ;
11492   PyObject * obj0 = 0 ;
11493   PyObject * obj1 = 0 ;
11494   PyObject * obj2 = 0 ;
11495
11496   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
11497   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11498   if (!SWIG_IsOK(res1)) {
11499     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11500   }
11501   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11502   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11503   if (!SWIG_IsOK(ecode2)) {
11504     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
11505   }
11506   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
11507   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
11508   if (!SWIG_IsOK(res3)) {
11509     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
11510   }
11511   arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
11512   try {
11513     std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_1(arg1,arg2,arg3);
11514   }
11515   catch(std::out_of_range &_e) {
11516     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11517   }
11518
11519   resultobj = SWIG_Py_Void();
11520   return resultobj;
11521 fail:
11522   return NULL;
11523 }
11524
11525
11526 SWIGINTERN PyObject *_wrap_VectorVertices___setitem__(PyObject *self, PyObject *args) {
11527   int argc;
11528   PyObject *argv[4];
11529   int ii;
11530
11531   if (!PyTuple_Check(args)) SWIG_fail;
11532   argc = (int)PyObject_Length(args);
11533   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11534     argv[ii] = PyTuple_GET_ITEM(args,ii);
11535   }
11536   if (argc == 3) {
11537     int _v;
11538     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
11539     _v = SWIG_CheckState(res);
11540     if (_v) {
11541       {
11542         _v = PySlice_Check(argv[1]);
11543       }
11544       if (_v) {
11545         int res = swig::asptr(argv[2], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
11546         _v = SWIG_CheckState(res);
11547         if (_v) {
11548           return _wrap_VectorVertices___setitem____SWIG_0(self, args);
11549         }
11550       }
11551     }
11552   }
11553   if (argc == 3) {
11554     int _v;
11555     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
11556     _v = SWIG_CheckState(res);
11557     if (_v) {
11558       {
11559         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
11560         _v = SWIG_CheckState(res);
11561       }
11562       if (_v) {
11563         void *vptr = 0;
11564         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0);
11565         _v = SWIG_CheckState(res);
11566         if (_v) {
11567           return _wrap_VectorVertices___setitem____SWIG_1(self, args);
11568         }
11569       }
11570     }
11571   }
11572
11573 fail:
11574   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices___setitem__'.\n"
11575     "  Possible C/C++ prototypes are:\n"
11576     "    __setitem__(std::vector< Hex::Vertex * > *,PySliceObject *,std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)\n"
11577     "    __setitem__(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::difference_type,std::vector< Hex::Vertex * >::value_type)\n");
11578   return NULL;
11579 }
11580
11581
11582 SWIGINTERN PyObject *_wrap_VectorVertices_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11583   PyObject *resultobj = 0;
11584   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11585   std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
11586   void *argp1 = 0 ;
11587   int res1 = 0 ;
11588   void *argp2 = 0 ;
11589   int res2 = 0 ;
11590   PyObject * obj0 = 0 ;
11591   PyObject * obj1 = 0 ;
11592
11593   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_append",&obj0,&obj1)) SWIG_fail;
11594   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11595   if (!SWIG_IsOK(res1)) {
11596     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_append" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11597   }
11598   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11599   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
11600   if (!SWIG_IsOK(res2)) {
11601     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_append" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
11602   }
11603   arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
11604   std_vector_Sl_Hex_Vertex_Sm__Sg__append(arg1,arg2);
11605   resultobj = SWIG_Py_Void();
11606   return resultobj;
11607 fail:
11608   return NULL;
11609 }
11610
11611
11612 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11613   PyObject *resultobj = 0;
11614   std::vector< Hex::Vertex * > *result = 0 ;
11615
11616   if (!PyArg_ParseTuple(args,(char *)":new_VectorVertices")) SWIG_fail;
11617   result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >();
11618   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
11619   return resultobj;
11620 fail:
11621   return NULL;
11622 }
11623
11624
11625 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11626   PyObject *resultobj = 0;
11627   std::vector< Hex::Vertex * > *arg1 = 0 ;
11628   int res1 = SWIG_OLDOBJ ;
11629   PyObject * obj0 = 0 ;
11630   std::vector< Hex::Vertex * > *result = 0 ;
11631
11632   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
11633   {
11634     std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
11635     res1 = swig::asptr(obj0, &ptr);
11636     if (!SWIG_IsOK(res1)) {
11637       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const &""'");
11638     }
11639     if (!ptr) {
11640       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const &""'");
11641     }
11642     arg1 = ptr;
11643   }
11644   result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >((std::vector< Hex::Vertex * > const &)*arg1);
11645   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
11646   if (SWIG_IsNewObj(res1)) delete arg1;
11647   return resultobj;
11648 fail:
11649   if (SWIG_IsNewObj(res1)) delete arg1;
11650   return NULL;
11651 }
11652
11653
11654 SWIGINTERN PyObject *_wrap_VectorVertices_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11655   PyObject *resultobj = 0;
11656   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11657   void *argp1 = 0 ;
11658   int res1 = 0 ;
11659   PyObject * obj0 = 0 ;
11660   bool result;
11661
11662   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_empty",&obj0)) SWIG_fail;
11663   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11664   if (!SWIG_IsOK(res1)) {
11665     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_empty" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
11666   }
11667   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11668   result = (bool)((std::vector< Hex::Vertex * > const *)arg1)->empty();
11669   resultobj = SWIG_From_bool(static_cast< bool >(result));
11670   return resultobj;
11671 fail:
11672   return NULL;
11673 }
11674
11675
11676 SWIGINTERN PyObject *_wrap_VectorVertices_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11677   PyObject *resultobj = 0;
11678   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11679   void *argp1 = 0 ;
11680   int res1 = 0 ;
11681   PyObject * obj0 = 0 ;
11682   std::vector< Hex::Vertex * >::size_type result;
11683
11684   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_size",&obj0)) SWIG_fail;
11685   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11686   if (!SWIG_IsOK(res1)) {
11687     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_size" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
11688   }
11689   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11690   result = ((std::vector< Hex::Vertex * > const *)arg1)->size();
11691   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11692   return resultobj;
11693 fail:
11694   return NULL;
11695 }
11696
11697
11698 SWIGINTERN PyObject *_wrap_VectorVertices_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11699   PyObject *resultobj = 0;
11700   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11701   void *argp1 = 0 ;
11702   int res1 = 0 ;
11703   PyObject * obj0 = 0 ;
11704
11705   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_clear",&obj0)) SWIG_fail;
11706   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11707   if (!SWIG_IsOK(res1)) {
11708     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_clear" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11709   }
11710   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11711   (arg1)->clear();
11712   resultobj = SWIG_Py_Void();
11713   return resultobj;
11714 fail:
11715   return NULL;
11716 }
11717
11718
11719 SWIGINTERN PyObject *_wrap_VectorVertices_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11720   PyObject *resultobj = 0;
11721   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11722   std::vector< Hex::Vertex * > *arg2 = 0 ;
11723   void *argp1 = 0 ;
11724   int res1 = 0 ;
11725   void *argp2 = 0 ;
11726   int res2 = 0 ;
11727   PyObject * obj0 = 0 ;
11728   PyObject * obj1 = 0 ;
11729
11730   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_swap",&obj0,&obj1)) SWIG_fail;
11731   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11732   if (!SWIG_IsOK(res1)) {
11733     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_swap" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11734   }
11735   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11736   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t,  0 );
11737   if (!SWIG_IsOK(res2)) {
11738     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector< Hex::Vertex * > &""'");
11739   }
11740   if (!argp2) {
11741     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector< Hex::Vertex * > &""'");
11742   }
11743   arg2 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp2);
11744   (arg1)->swap(*arg2);
11745   resultobj = SWIG_Py_Void();
11746   return resultobj;
11747 fail:
11748   return NULL;
11749 }
11750
11751
11752 SWIGINTERN PyObject *_wrap_VectorVertices_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11753   PyObject *resultobj = 0;
11754   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11755   void *argp1 = 0 ;
11756   int res1 = 0 ;
11757   PyObject * obj0 = 0 ;
11758   SwigValueWrapper< std::allocator< Hex::Vertex * > > result;
11759
11760   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_get_allocator",&obj0)) SWIG_fail;
11761   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11762   if (!SWIG_IsOK(res1)) {
11763     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
11764   }
11765   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11766   result = ((std::vector< Hex::Vertex * > const *)arg1)->get_allocator();
11767   resultobj = SWIG_NewPointerObj((new std::vector< Hex::Vertex * >::allocator_type(static_cast< const std::vector< Hex::Vertex * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
11768   return resultobj;
11769 fail:
11770   return NULL;
11771 }
11772
11773
11774 SWIGINTERN PyObject *_wrap_VectorVertices_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11775   PyObject *resultobj = 0;
11776   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11777   void *argp1 = 0 ;
11778   int res1 = 0 ;
11779   PyObject * obj0 = 0 ;
11780   std::vector< Hex::Vertex * >::const_iterator result;
11781
11782   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_begin",&obj0)) SWIG_fail;
11783   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11784   if (!SWIG_IsOK(res1)) {
11785     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_begin" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
11786   }
11787   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11788   result = ((std::vector< Hex::Vertex * > const *)arg1)->begin();
11789   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::const_iterator & >(result)),
11790     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11791   return resultobj;
11792 fail:
11793   return NULL;
11794 }
11795
11796
11797 SWIGINTERN PyObject *_wrap_VectorVertices_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11798   PyObject *resultobj = 0;
11799   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11800   void *argp1 = 0 ;
11801   int res1 = 0 ;
11802   PyObject * obj0 = 0 ;
11803   std::vector< Hex::Vertex * >::const_iterator result;
11804
11805   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_end",&obj0)) SWIG_fail;
11806   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11807   if (!SWIG_IsOK(res1)) {
11808     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_end" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
11809   }
11810   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11811   result = ((std::vector< Hex::Vertex * > const *)arg1)->end();
11812   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::const_iterator & >(result)),
11813     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11814   return resultobj;
11815 fail:
11816   return NULL;
11817 }
11818
11819
11820 SWIGINTERN PyObject *_wrap_VectorVertices_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11821   PyObject *resultobj = 0;
11822   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11823   void *argp1 = 0 ;
11824   int res1 = 0 ;
11825   PyObject * obj0 = 0 ;
11826   std::vector< Hex::Vertex * >::const_reverse_iterator result;
11827
11828   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rbegin",&obj0)) SWIG_fail;
11829   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11830   if (!SWIG_IsOK(res1)) {
11831     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
11832   }
11833   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11834   result = ((std::vector< Hex::Vertex * > const *)arg1)->rbegin();
11835   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::const_reverse_iterator & >(result)),
11836     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11837   return resultobj;
11838 fail:
11839   return NULL;
11840 }
11841
11842
11843 SWIGINTERN PyObject *_wrap_VectorVertices_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11844   PyObject *resultobj = 0;
11845   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11846   void *argp1 = 0 ;
11847   int res1 = 0 ;
11848   PyObject * obj0 = 0 ;
11849   std::vector< Hex::Vertex * >::const_reverse_iterator result;
11850
11851   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rend",&obj0)) SWIG_fail;
11852   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11853   if (!SWIG_IsOK(res1)) {
11854     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rend" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
11855   }
11856   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11857   result = ((std::vector< Hex::Vertex * > const *)arg1)->rend();
11858   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::const_reverse_iterator & >(result)),
11859     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11860   return resultobj;
11861 fail:
11862   return NULL;
11863 }
11864
11865
11866 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11867   PyObject *resultobj = 0;
11868   std::vector< Hex::Vertex * >::size_type arg1 ;
11869   size_t val1 ;
11870   int ecode1 = 0 ;
11871   PyObject * obj0 = 0 ;
11872   std::vector< Hex::Vertex * > *result = 0 ;
11873
11874   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
11875   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11876   if (!SWIG_IsOK(ecode1)) {
11877     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
11878   }
11879   arg1 = static_cast< std::vector< Hex::Vertex * >::size_type >(val1);
11880   result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >(arg1);
11881   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
11882   return resultobj;
11883 fail:
11884   return NULL;
11885 }
11886
11887
11888 SWIGINTERN PyObject *_wrap_VectorVertices_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11889   PyObject *resultobj = 0;
11890   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11891   void *argp1 = 0 ;
11892   int res1 = 0 ;
11893   PyObject * obj0 = 0 ;
11894
11895   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop_back",&obj0)) SWIG_fail;
11896   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11897   if (!SWIG_IsOK(res1)) {
11898     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11899   }
11900   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11901   (arg1)->pop_back();
11902   resultobj = SWIG_Py_Void();
11903   return resultobj;
11904 fail:
11905   return NULL;
11906 }
11907
11908
11909 SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11910   PyObject *resultobj = 0;
11911   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11912   std::vector< Hex::Vertex * >::size_type arg2 ;
11913   void *argp1 = 0 ;
11914   int res1 = 0 ;
11915   size_t val2 ;
11916   int ecode2 = 0 ;
11917   PyObject * obj0 = 0 ;
11918   PyObject * obj1 = 0 ;
11919
11920   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_resize",&obj0,&obj1)) SWIG_fail;
11921   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11922   if (!SWIG_IsOK(res1)) {
11923     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11924   }
11925   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11926   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11927   if (!SWIG_IsOK(ecode2)) {
11928     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
11929   }
11930   arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
11931   (arg1)->resize(arg2);
11932   resultobj = SWIG_Py_Void();
11933   return resultobj;
11934 fail:
11935   return NULL;
11936 }
11937
11938
11939 SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11940   PyObject *resultobj = 0;
11941   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11942   std::vector< Hex::Vertex * >::iterator arg2 ;
11943   void *argp1 = 0 ;
11944   int res1 = 0 ;
11945   swig::SwigPyIterator *iter2 = 0 ;
11946   int res2 ;
11947   PyObject * obj0 = 0 ;
11948   PyObject * obj1 = 0 ;
11949   std::vector< Hex::Vertex * >::iterator result;
11950
11951   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_erase",&obj0,&obj1)) SWIG_fail;
11952   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11953   if (!SWIG_IsOK(res1)) {
11954     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11955   }
11956   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11957   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
11958   if (!SWIG_IsOK(res2) || !iter2) {
11959     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
11960   } else {
11961     swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
11962     if (iter_t) {
11963       arg2 = iter_t->get_current();
11964     } else {
11965       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
11966     }
11967   }
11968   result = (arg1)->erase(arg2);
11969   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
11970     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11971   return resultobj;
11972 fail:
11973   return NULL;
11974 }
11975
11976
11977 SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11978   PyObject *resultobj = 0;
11979   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
11980   std::vector< Hex::Vertex * >::iterator arg2 ;
11981   std::vector< Hex::Vertex * >::iterator arg3 ;
11982   void *argp1 = 0 ;
11983   int res1 = 0 ;
11984   swig::SwigPyIterator *iter2 = 0 ;
11985   int res2 ;
11986   swig::SwigPyIterator *iter3 = 0 ;
11987   int res3 ;
11988   PyObject * obj0 = 0 ;
11989   PyObject * obj1 = 0 ;
11990   PyObject * obj2 = 0 ;
11991   std::vector< Hex::Vertex * >::iterator result;
11992
11993   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_erase",&obj0,&obj1,&obj2)) SWIG_fail;
11994   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
11995   if (!SWIG_IsOK(res1)) {
11996     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
11997   }
11998   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
11999   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
12000   if (!SWIG_IsOK(res2) || !iter2) {
12001     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
12002   } else {
12003     swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
12004     if (iter_t) {
12005       arg2 = iter_t->get_current();
12006     } else {
12007       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
12008     }
12009   }
12010   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
12011   if (!SWIG_IsOK(res3) || !iter3) {
12012     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
12013   } else {
12014     swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter3);
12015     if (iter_t) {
12016       arg3 = iter_t->get_current();
12017     } else {
12018       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
12019     }
12020   }
12021   result = (arg1)->erase(arg2,arg3);
12022   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
12023     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
12024   return resultobj;
12025 fail:
12026   return NULL;
12027 }
12028
12029
12030 SWIGINTERN PyObject *_wrap_VectorVertices_erase(PyObject *self, PyObject *args) {
12031   int argc;
12032   PyObject *argv[4];
12033   int ii;
12034
12035   if (!PyTuple_Check(args)) SWIG_fail;
12036   argc = (int)PyObject_Length(args);
12037   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12038     argv[ii] = PyTuple_GET_ITEM(args,ii);
12039   }
12040   if (argc == 2) {
12041     int _v;
12042     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12043     _v = SWIG_CheckState(res);
12044     if (_v) {
12045       swig::SwigPyIterator *iter = 0;
12046       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
12047       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
12048       if (_v) {
12049         return _wrap_VectorVertices_erase__SWIG_0(self, args);
12050       }
12051     }
12052   }
12053   if (argc == 3) {
12054     int _v;
12055     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12056     _v = SWIG_CheckState(res);
12057     if (_v) {
12058       swig::SwigPyIterator *iter = 0;
12059       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
12060       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
12061       if (_v) {
12062         swig::SwigPyIterator *iter = 0;
12063         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
12064         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
12065         if (_v) {
12066           return _wrap_VectorVertices_erase__SWIG_1(self, args);
12067         }
12068       }
12069     }
12070   }
12071
12072 fail:
12073   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_erase'.\n"
12074     "  Possible C/C++ prototypes are:\n"
12075     "    erase(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::iterator)\n"
12076     "    erase(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::iterator)\n");
12077   return NULL;
12078 }
12079
12080
12081 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12082   PyObject *resultobj = 0;
12083   std::vector< Hex::Vertex * >::size_type arg1 ;
12084   std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
12085   size_t val1 ;
12086   int ecode1 = 0 ;
12087   void *argp2 = 0 ;
12088   int res2 = 0 ;
12089   PyObject * obj0 = 0 ;
12090   PyObject * obj1 = 0 ;
12091   std::vector< Hex::Vertex * > *result = 0 ;
12092
12093   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorVertices",&obj0,&obj1)) SWIG_fail;
12094   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
12095   if (!SWIG_IsOK(ecode1)) {
12096     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
12097   }
12098   arg1 = static_cast< std::vector< Hex::Vertex * >::size_type >(val1);
12099   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
12100   if (!SWIG_IsOK(res2)) {
12101     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorVertices" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
12102   }
12103   arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
12104   result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >(arg1,arg2);
12105   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
12106   return resultobj;
12107 fail:
12108   return NULL;
12109 }
12110
12111
12112 SWIGINTERN PyObject *_wrap_new_VectorVertices(PyObject *self, PyObject *args) {
12113   int argc;
12114   PyObject *argv[3];
12115   int ii;
12116
12117   if (!PyTuple_Check(args)) SWIG_fail;
12118   argc = (int)PyObject_Length(args);
12119   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
12120     argv[ii] = PyTuple_GET_ITEM(args,ii);
12121   }
12122   if (argc == 0) {
12123     return _wrap_new_VectorVertices__SWIG_0(self, args);
12124   }
12125   if (argc == 1) {
12126     int _v;
12127     {
12128       int res = SWIG_AsVal_size_t(argv[0], NULL);
12129       _v = SWIG_CheckState(res);
12130     }
12131     if (_v) {
12132       return _wrap_new_VectorVertices__SWIG_2(self, args);
12133     }
12134   }
12135   if (argc == 1) {
12136     int _v;
12137     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12138     _v = SWIG_CheckState(res);
12139     if (_v) {
12140       return _wrap_new_VectorVertices__SWIG_1(self, args);
12141     }
12142   }
12143   if (argc == 2) {
12144     int _v;
12145     {
12146       int res = SWIG_AsVal_size_t(argv[0], NULL);
12147       _v = SWIG_CheckState(res);
12148     }
12149     if (_v) {
12150       void *vptr = 0;
12151       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0);
12152       _v = SWIG_CheckState(res);
12153       if (_v) {
12154         return _wrap_new_VectorVertices__SWIG_3(self, args);
12155       }
12156     }
12157   }
12158
12159 fail:
12160   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorVertices'.\n"
12161     "  Possible C/C++ prototypes are:\n"
12162     "    std::vector< Hex::Vertex * >()\n"
12163     "    std::vector< Hex::Vertex * >(std::vector< Hex::Vertex * > const &)\n"
12164     "    std::vector< Hex::Vertex * >(std::vector< Hex::Vertex * >::size_type)\n"
12165     "    std::vector< Hex::Vertex * >(std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
12166   return NULL;
12167 }
12168
12169
12170 SWIGINTERN PyObject *_wrap_VectorVertices_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12171   PyObject *resultobj = 0;
12172   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12173   std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
12174   void *argp1 = 0 ;
12175   int res1 = 0 ;
12176   void *argp2 = 0 ;
12177   int res2 = 0 ;
12178   PyObject * obj0 = 0 ;
12179   PyObject * obj1 = 0 ;
12180
12181   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_push_back",&obj0,&obj1)) SWIG_fail;
12182   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12183   if (!SWIG_IsOK(res1)) {
12184     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_push_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12185   }
12186   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12187   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
12188   if (!SWIG_IsOK(res2)) {
12189     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_push_back" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
12190   }
12191   arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
12192   (arg1)->push_back(arg2);
12193   resultobj = SWIG_Py_Void();
12194   return resultobj;
12195 fail:
12196   return NULL;
12197 }
12198
12199
12200 SWIGINTERN PyObject *_wrap_VectorVertices_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12201   PyObject *resultobj = 0;
12202   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12203   void *argp1 = 0 ;
12204   int res1 = 0 ;
12205   PyObject * obj0 = 0 ;
12206   std::vector< Hex::Vertex * >::value_type result;
12207
12208   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_front",&obj0)) SWIG_fail;
12209   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12210   if (!SWIG_IsOK(res1)) {
12211     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_front" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
12212   }
12213   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12214   result = (std::vector< Hex::Vertex * >::value_type)((std::vector< Hex::Vertex * > const *)arg1)->front();
12215   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
12216   return resultobj;
12217 fail:
12218   return NULL;
12219 }
12220
12221
12222 SWIGINTERN PyObject *_wrap_VectorVertices_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12223   PyObject *resultobj = 0;
12224   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12225   void *argp1 = 0 ;
12226   int res1 = 0 ;
12227   PyObject * obj0 = 0 ;
12228   std::vector< Hex::Vertex * >::value_type result;
12229
12230   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_back",&obj0)) SWIG_fail;
12231   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12232   if (!SWIG_IsOK(res1)) {
12233     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
12234   }
12235   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12236   result = (std::vector< Hex::Vertex * >::value_type)((std::vector< Hex::Vertex * > const *)arg1)->back();
12237   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
12238   return resultobj;
12239 fail:
12240   return NULL;
12241 }
12242
12243
12244 SWIGINTERN PyObject *_wrap_VectorVertices_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12245   PyObject *resultobj = 0;
12246   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12247   std::vector< Hex::Vertex * >::size_type arg2 ;
12248   std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
12249   void *argp1 = 0 ;
12250   int res1 = 0 ;
12251   size_t val2 ;
12252   int ecode2 = 0 ;
12253   void *argp3 = 0 ;
12254   int res3 = 0 ;
12255   PyObject * obj0 = 0 ;
12256   PyObject * obj1 = 0 ;
12257   PyObject * obj2 = 0 ;
12258
12259   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_assign",&obj0,&obj1,&obj2)) SWIG_fail;
12260   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12261   if (!SWIG_IsOK(res1)) {
12262     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_assign" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12263   }
12264   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12265   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12266   if (!SWIG_IsOK(ecode2)) {
12267     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_assign" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
12268   }
12269   arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
12270   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
12271   if (!SWIG_IsOK(res3)) {
12272     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_assign" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
12273   }
12274   arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
12275   (arg1)->assign(arg2,arg3);
12276   resultobj = SWIG_Py_Void();
12277   return resultobj;
12278 fail:
12279   return NULL;
12280 }
12281
12282
12283 SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12284   PyObject *resultobj = 0;
12285   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12286   std::vector< Hex::Vertex * >::size_type arg2 ;
12287   std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
12288   void *argp1 = 0 ;
12289   int res1 = 0 ;
12290   size_t val2 ;
12291   int ecode2 = 0 ;
12292   void *argp3 = 0 ;
12293   int res3 = 0 ;
12294   PyObject * obj0 = 0 ;
12295   PyObject * obj1 = 0 ;
12296   PyObject * obj2 = 0 ;
12297
12298   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_resize",&obj0,&obj1,&obj2)) SWIG_fail;
12299   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12300   if (!SWIG_IsOK(res1)) {
12301     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12302   }
12303   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12304   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12305   if (!SWIG_IsOK(ecode2)) {
12306     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
12307   }
12308   arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
12309   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
12310   if (!SWIG_IsOK(res3)) {
12311     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_resize" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
12312   }
12313   arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
12314   (arg1)->resize(arg2,arg3);
12315   resultobj = SWIG_Py_Void();
12316   return resultobj;
12317 fail:
12318   return NULL;
12319 }
12320
12321
12322 SWIGINTERN PyObject *_wrap_VectorVertices_resize(PyObject *self, PyObject *args) {
12323   int argc;
12324   PyObject *argv[4];
12325   int ii;
12326
12327   if (!PyTuple_Check(args)) SWIG_fail;
12328   argc = (int)PyObject_Length(args);
12329   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12330     argv[ii] = PyTuple_GET_ITEM(args,ii);
12331   }
12332   if (argc == 2) {
12333     int _v;
12334     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12335     _v = SWIG_CheckState(res);
12336     if (_v) {
12337       {
12338         int res = SWIG_AsVal_size_t(argv[1], NULL);
12339         _v = SWIG_CheckState(res);
12340       }
12341       if (_v) {
12342         return _wrap_VectorVertices_resize__SWIG_0(self, args);
12343       }
12344     }
12345   }
12346   if (argc == 3) {
12347     int _v;
12348     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12349     _v = SWIG_CheckState(res);
12350     if (_v) {
12351       {
12352         int res = SWIG_AsVal_size_t(argv[1], NULL);
12353         _v = SWIG_CheckState(res);
12354       }
12355       if (_v) {
12356         void *vptr = 0;
12357         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0);
12358         _v = SWIG_CheckState(res);
12359         if (_v) {
12360           return _wrap_VectorVertices_resize__SWIG_1(self, args);
12361         }
12362       }
12363     }
12364   }
12365
12366 fail:
12367   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_resize'.\n"
12368     "  Possible C/C++ prototypes are:\n"
12369     "    resize(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::size_type)\n"
12370     "    resize(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
12371   return NULL;
12372 }
12373
12374
12375 SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12376   PyObject *resultobj = 0;
12377   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12378   std::vector< Hex::Vertex * >::iterator arg2 ;
12379   std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
12380   void *argp1 = 0 ;
12381   int res1 = 0 ;
12382   swig::SwigPyIterator *iter2 = 0 ;
12383   int res2 ;
12384   void *argp3 = 0 ;
12385   int res3 = 0 ;
12386   PyObject * obj0 = 0 ;
12387   PyObject * obj1 = 0 ;
12388   PyObject * obj2 = 0 ;
12389   std::vector< Hex::Vertex * >::iterator result;
12390
12391   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_insert",&obj0,&obj1,&obj2)) SWIG_fail;
12392   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12393   if (!SWIG_IsOK(res1)) {
12394     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12395   }
12396   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12397   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
12398   if (!SWIG_IsOK(res2) || !iter2) {
12399     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
12400   } else {
12401     swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
12402     if (iter_t) {
12403       arg2 = iter_t->get_current();
12404     } else {
12405       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
12406     }
12407   }
12408   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
12409   if (!SWIG_IsOK(res3)) {
12410     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
12411   }
12412   arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
12413   result = (arg1)->insert(arg2,arg3);
12414   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
12415     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
12416   return resultobj;
12417 fail:
12418   return NULL;
12419 }
12420
12421
12422 SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12423   PyObject *resultobj = 0;
12424   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12425   std::vector< Hex::Vertex * >::iterator arg2 ;
12426   std::vector< Hex::Vertex * >::size_type arg3 ;
12427   std::vector< Hex::Vertex * >::value_type arg4 = (std::vector< Hex::Vertex * >::value_type) 0 ;
12428   void *argp1 = 0 ;
12429   int res1 = 0 ;
12430   swig::SwigPyIterator *iter2 = 0 ;
12431   int res2 ;
12432   size_t val3 ;
12433   int ecode3 = 0 ;
12434   void *argp4 = 0 ;
12435   int res4 = 0 ;
12436   PyObject * obj0 = 0 ;
12437   PyObject * obj1 = 0 ;
12438   PyObject * obj2 = 0 ;
12439   PyObject * obj3 = 0 ;
12440
12441   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12442   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12443   if (!SWIG_IsOK(res1)) {
12444     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12445   }
12446   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12447   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
12448   if (!SWIG_IsOK(res2) || !iter2) {
12449     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
12450   } else {
12451     swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
12452     if (iter_t) {
12453       arg2 = iter_t->get_current();
12454     } else {
12455       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
12456     }
12457   }
12458   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
12459   if (!SWIG_IsOK(ecode3)) {
12460     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
12461   }
12462   arg3 = static_cast< std::vector< Hex::Vertex * >::size_type >(val3);
12463   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0 |  0 );
12464   if (!SWIG_IsOK(res4)) {
12465     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices_insert" "', argument " "4"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
12466   }
12467   arg4 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp4);
12468   (arg1)->insert(arg2,arg3,arg4);
12469   resultobj = SWIG_Py_Void();
12470   return resultobj;
12471 fail:
12472   return NULL;
12473 }
12474
12475
12476 SWIGINTERN PyObject *_wrap_VectorVertices_insert(PyObject *self, PyObject *args) {
12477   int argc;
12478   PyObject *argv[5];
12479   int ii;
12480
12481   if (!PyTuple_Check(args)) SWIG_fail;
12482   argc = (int)PyObject_Length(args);
12483   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
12484     argv[ii] = PyTuple_GET_ITEM(args,ii);
12485   }
12486   if (argc == 3) {
12487     int _v;
12488     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12489     _v = SWIG_CheckState(res);
12490     if (_v) {
12491       swig::SwigPyIterator *iter = 0;
12492       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
12493       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
12494       if (_v) {
12495         void *vptr = 0;
12496         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0);
12497         _v = SWIG_CheckState(res);
12498         if (_v) {
12499           return _wrap_VectorVertices_insert__SWIG_0(self, args);
12500         }
12501       }
12502     }
12503   }
12504   if (argc == 4) {
12505     int _v;
12506     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12507     _v = SWIG_CheckState(res);
12508     if (_v) {
12509       swig::SwigPyIterator *iter = 0;
12510       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
12511       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
12512       if (_v) {
12513         {
12514           int res = SWIG_AsVal_size_t(argv[2], NULL);
12515           _v = SWIG_CheckState(res);
12516         }
12517         if (_v) {
12518           void *vptr = 0;
12519           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0);
12520           _v = SWIG_CheckState(res);
12521           if (_v) {
12522             return _wrap_VectorVertices_insert__SWIG_1(self, args);
12523           }
12524         }
12525       }
12526     }
12527   }
12528
12529 fail:
12530   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_insert'.\n"
12531     "  Possible C/C++ prototypes are:\n"
12532     "    insert(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::value_type)\n"
12533     "    insert(std::vector< Hex::Vertex * > *,std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
12534   return NULL;
12535 }
12536
12537
12538 SWIGINTERN PyObject *_wrap_VectorVertices_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12539   PyObject *resultobj = 0;
12540   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12541   std::vector< Hex::Vertex * >::size_type arg2 ;
12542   void *argp1 = 0 ;
12543   int res1 = 0 ;
12544   size_t val2 ;
12545   int ecode2 = 0 ;
12546   PyObject * obj0 = 0 ;
12547   PyObject * obj1 = 0 ;
12548
12549   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_reserve",&obj0,&obj1)) SWIG_fail;
12550   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12551   if (!SWIG_IsOK(res1)) {
12552     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_reserve" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12553   }
12554   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12555   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12556   if (!SWIG_IsOK(ecode2)) {
12557     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_reserve" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
12558   }
12559   arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
12560   (arg1)->reserve(arg2);
12561   resultobj = SWIG_Py_Void();
12562   return resultobj;
12563 fail:
12564   return NULL;
12565 }
12566
12567
12568 SWIGINTERN PyObject *_wrap_VectorVertices_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12569   PyObject *resultobj = 0;
12570   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12571   void *argp1 = 0 ;
12572   int res1 = 0 ;
12573   PyObject * obj0 = 0 ;
12574   std::vector< Hex::Vertex * >::size_type result;
12575
12576   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_capacity",&obj0)) SWIG_fail;
12577   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12578   if (!SWIG_IsOK(res1)) {
12579     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_capacity" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
12580   }
12581   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12582   result = ((std::vector< Hex::Vertex * > const *)arg1)->capacity();
12583   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12584   return resultobj;
12585 fail:
12586   return NULL;
12587 }
12588
12589
12590 SWIGINTERN PyObject *_wrap_delete_VectorVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12591   PyObject *resultobj = 0;
12592   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12593   void *argp1 = 0 ;
12594   int res1 = 0 ;
12595   PyObject * obj0 = 0 ;
12596
12597   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorVertices",&obj0)) SWIG_fail;
12598   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_DISOWN |  0 );
12599   if (!SWIG_IsOK(res1)) {
12600     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12601   }
12602   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12603   delete arg1;
12604   resultobj = SWIG_Py_Void();
12605   return resultobj;
12606 fail:
12607   return NULL;
12608 }
12609
12610
12611 SWIGINTERN PyObject *VectorVertices_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12612   PyObject *obj;
12613   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
12614   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_NewClientData(obj));
12615   return SWIG_Py_Void();
12616 }
12617
12618 SWIGINTERN PyObject *_wrap_VectorShapes_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12619   PyObject *resultobj = 0;
12620   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
12621   PyObject **arg2 = (PyObject **) 0 ;
12622   void *argp1 = 0 ;
12623   int res1 = 0 ;
12624   PyObject * obj0 = 0 ;
12625   swig::SwigPyIterator *result = 0 ;
12626
12627   arg2 = &obj0;
12628   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_iterator",&obj0)) SWIG_fail;
12629   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12630   if (!SWIG_IsOK(res1)) {
12631     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_iterator" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
12632   }
12633   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
12634   result = (swig::SwigPyIterator *)std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(arg1,arg2);
12635   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
12636   return resultobj;
12637 fail:
12638   return NULL;
12639 }
12640
12641
12642 SWIGINTERN PyObject *_wrap_VectorShapes___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12643   PyObject *resultobj = 0;
12644   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
12645   void *argp1 = 0 ;
12646   int res1 = 0 ;
12647   PyObject * obj0 = 0 ;
12648   bool result;
12649
12650   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___nonzero__",&obj0)) SWIG_fail;
12651   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12652   if (!SWIG_IsOK(res1)) {
12653     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
12654   }
12655   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
12656   result = (bool)std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__((std::vector< Hex::NewShape * > const *)arg1);
12657   resultobj = SWIG_From_bool(static_cast< bool >(result));
12658   return resultobj;
12659 fail:
12660   return NULL;
12661 }
12662
12663
12664 SWIGINTERN PyObject *_wrap_VectorShapes___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12665   PyObject *resultobj = 0;
12666   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
12667   void *argp1 = 0 ;
12668   int res1 = 0 ;
12669   PyObject * obj0 = 0 ;
12670   bool result;
12671
12672   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___bool__",&obj0)) SWIG_fail;
12673   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12674   if (!SWIG_IsOK(res1)) {
12675     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___bool__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
12676   }
12677   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
12678   result = (bool)std_vector_Sl_Hex_NewShape_Sm__Sg____bool__((std::vector< Hex::NewShape * > const *)arg1);
12679   resultobj = SWIG_From_bool(static_cast< bool >(result));
12680   return resultobj;
12681 fail:
12682   return NULL;
12683 }
12684
12685
12686 SWIGINTERN PyObject *_wrap_VectorShapes___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12687   PyObject *resultobj = 0;
12688   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
12689   void *argp1 = 0 ;
12690   int res1 = 0 ;
12691   PyObject * obj0 = 0 ;
12692   std::vector< Hex::NewShape * >::size_type result;
12693
12694   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___len__",&obj0)) SWIG_fail;
12695   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12696   if (!SWIG_IsOK(res1)) {
12697     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___len__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
12698   }
12699   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
12700   result = std_vector_Sl_Hex_NewShape_Sm__Sg____len__((std::vector< Hex::NewShape * > const *)arg1);
12701   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12702   return resultobj;
12703 fail:
12704   return NULL;
12705 }
12706
12707
12708 SWIGINTERN PyObject *_wrap_VectorShapes_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12709   PyObject *resultobj = 0;
12710   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
12711   void *argp1 = 0 ;
12712   int res1 = 0 ;
12713   PyObject * obj0 = 0 ;
12714   std::vector< Hex::NewShape * >::value_type result;
12715
12716   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop",&obj0)) SWIG_fail;
12717   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12718   if (!SWIG_IsOK(res1)) {
12719     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
12720   }
12721   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
12722   try {
12723     result = (std::vector< Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg__pop(arg1);
12724   }
12725   catch(std::out_of_range &_e) {
12726     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12727   }
12728
12729   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
12730   return resultobj;
12731 fail:
12732   return NULL;
12733 }
12734
12735
12736 SWIGINTERN PyObject *_wrap_VectorShapes___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12737   PyObject *resultobj = 0;
12738   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
12739   std::vector< Hex::NewShape * >::difference_type arg2 ;
12740   std::vector< Hex::NewShape * >::difference_type arg3 ;
12741   void *argp1 = 0 ;
12742   int res1 = 0 ;
12743   ptrdiff_t val2 ;
12744   int ecode2 = 0 ;
12745   ptrdiff_t val3 ;
12746   int ecode3 = 0 ;
12747   PyObject * obj0 = 0 ;
12748   PyObject * obj1 = 0 ;
12749   PyObject * obj2 = 0 ;
12750   std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *result = 0 ;
12751
12752   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
12753   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12754   if (!SWIG_IsOK(res1)) {
12755     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
12756   }
12757   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
12758   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12759   if (!SWIG_IsOK(ecode2)) {
12760     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
12761   }
12762   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
12763   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12764   if (!SWIG_IsOK(ecode3)) {
12765     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___getslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
12766   }
12767   arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
12768   try {
12769     result = (std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *)std_vector_Sl_Hex_NewShape_Sm__Sg____getslice__(arg1,arg2,arg3);
12770   }
12771   catch(std::out_of_range &_e) {
12772     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12773   }
12774
12775   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_OWN |  0 );
12776   return resultobj;
12777 fail:
12778   return NULL;
12779 }
12780
12781
12782 SWIGINTERN PyObject *_wrap_VectorShapes___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12783   PyObject *resultobj = 0;
12784   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
12785   std::vector< Hex::NewShape * >::difference_type arg2 ;
12786   std::vector< Hex::NewShape * >::difference_type arg3 ;
12787   std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *arg4 = 0 ;
12788   void *argp1 = 0 ;
12789   int res1 = 0 ;
12790   ptrdiff_t val2 ;
12791   int ecode2 = 0 ;
12792   ptrdiff_t val3 ;
12793   int ecode3 = 0 ;
12794   int res4 = SWIG_OLDOBJ ;
12795   PyObject * obj0 = 0 ;
12796   PyObject * obj1 = 0 ;
12797   PyObject * obj2 = 0 ;
12798   PyObject * obj3 = 0 ;
12799
12800   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12801   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12802   if (!SWIG_IsOK(res1)) {
12803     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
12804   }
12805   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
12806   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12807   if (!SWIG_IsOK(ecode2)) {
12808     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
12809   }
12810   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
12811   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12812   if (!SWIG_IsOK(ecode3)) {
12813     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___setslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
12814   }
12815   arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
12816   {
12817     std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
12818     res4 = swig::asptr(obj3, &ptr);
12819     if (!SWIG_IsOK(res4)) {
12820       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes___setslice__" "', argument " "4"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
12821     }
12822     if (!ptr) {
12823       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes___setslice__" "', argument " "4"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
12824     }
12825     arg4 = ptr;
12826   }
12827   try {
12828     std_vector_Sl_Hex_NewShape_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)*arg4);
12829   }
12830   catch(std::out_of_range &_e) {
12831     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12832   }
12833   catch(std::invalid_argument &_e) {
12834     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12835   }
12836
12837   resultobj = SWIG_Py_Void();
12838   if (SWIG_IsNewObj(res4)) delete arg4;
12839   return resultobj;
12840 fail:
12841   if (SWIG_IsNewObj(res4)) delete arg4;
12842   return NULL;
12843 }
12844
12845
12846 SWIGINTERN PyObject *_wrap_VectorShapes___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12847   PyObject *resultobj = 0;
12848   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
12849   std::vector< Hex::NewShape * >::difference_type arg2 ;
12850   std::vector< Hex::NewShape * >::difference_type arg3 ;
12851   void *argp1 = 0 ;
12852   int res1 = 0 ;
12853   ptrdiff_t val2 ;
12854   int ecode2 = 0 ;
12855   ptrdiff_t val3 ;
12856   int ecode3 = 0 ;
12857   PyObject * obj0 = 0 ;
12858   PyObject * obj1 = 0 ;
12859   PyObject * obj2 = 0 ;
12860
12861   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
12862   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12863   if (!SWIG_IsOK(res1)) {
12864     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
12865   }
12866   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
12867   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12868   if (!SWIG_IsOK(ecode2)) {
12869     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
12870   }
12871   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
12872   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12873   if (!SWIG_IsOK(ecode3)) {
12874     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___delslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
12875   }
12876   arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
12877   try {
12878     std_vector_Sl_Hex_NewShape_Sm__Sg____delslice__(arg1,arg2,arg3);
12879   }
12880   catch(std::out_of_range &_e) {
12881     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12882   }
12883
12884   resultobj = SWIG_Py_Void();
12885   return resultobj;
12886 fail:
12887   return NULL;
12888 }
12889
12890
12891 SWIGINTERN PyObject *_wrap_VectorShapes___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12892   PyObject *resultobj = 0;
12893   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
12894   std::vector< Hex::NewShape * >::difference_type arg2 ;
12895   void *argp1 = 0 ;
12896   int res1 = 0 ;
12897   ptrdiff_t val2 ;
12898   int ecode2 = 0 ;
12899   PyObject * obj0 = 0 ;
12900   PyObject * obj1 = 0 ;
12901
12902   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___delitem__",&obj0,&obj1)) SWIG_fail;
12903   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12904   if (!SWIG_IsOK(res1)) {
12905     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
12906   }
12907   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
12908   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12909   if (!SWIG_IsOK(ecode2)) {
12910     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
12911   }
12912   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
12913   try {
12914     std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_0(arg1,arg2);
12915   }
12916   catch(std::out_of_range &_e) {
12917     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12918   }
12919
12920   resultobj = SWIG_Py_Void();
12921   return resultobj;
12922 fail:
12923   return NULL;
12924 }
12925
12926
12927 SWIGINTERN PyObject *_wrap_VectorShapes___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12928   PyObject *resultobj = 0;
12929   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
12930   PySliceObject *arg2 = (PySliceObject *) 0 ;
12931   void *argp1 = 0 ;
12932   int res1 = 0 ;
12933   PyObject * obj0 = 0 ;
12934   PyObject * obj1 = 0 ;
12935   std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *result = 0 ;
12936
12937   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___getitem__",&obj0,&obj1)) SWIG_fail;
12938   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12939   if (!SWIG_IsOK(res1)) {
12940     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
12941   }
12942   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
12943   {
12944     arg2 = (PySliceObject *) obj1;
12945   }
12946   try {
12947     result = (std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *)std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_0(arg1,arg2);
12948   }
12949   catch(std::out_of_range &_e) {
12950     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12951   }
12952
12953   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12954   return resultobj;
12955 fail:
12956   return NULL;
12957 }
12958
12959
12960 SWIGINTERN PyObject *_wrap_VectorShapes___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961   PyObject *resultobj = 0;
12962   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
12963   PySliceObject *arg2 = (PySliceObject *) 0 ;
12964   std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *arg3 = 0 ;
12965   void *argp1 = 0 ;
12966   int res1 = 0 ;
12967   int res3 = SWIG_OLDOBJ ;
12968   PyObject * obj0 = 0 ;
12969   PyObject * obj1 = 0 ;
12970   PyObject * obj2 = 0 ;
12971
12972   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
12973   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
12974   if (!SWIG_IsOK(res1)) {
12975     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
12976   }
12977   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
12978   {
12979     arg2 = (PySliceObject *) obj1;
12980   }
12981   {
12982     std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
12983     res3 = swig::asptr(obj2, &ptr);
12984     if (!SWIG_IsOK(res3)) {
12985       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
12986     }
12987     if (!ptr) {
12988       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
12989     }
12990     arg3 = ptr;
12991   }
12992   try {
12993     std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)*arg3);
12994   }
12995   catch(std::out_of_range &_e) {
12996     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12997   }
12998   catch(std::invalid_argument &_e) {
12999     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
13000   }
13001
13002   resultobj = SWIG_Py_Void();
13003   if (SWIG_IsNewObj(res3)) delete arg3;
13004   return resultobj;
13005 fail:
13006   if (SWIG_IsNewObj(res3)) delete arg3;
13007   return NULL;
13008 }
13009
13010
13011 SWIGINTERN PyObject *_wrap_VectorShapes___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13012   PyObject *resultobj = 0;
13013   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13014   PySliceObject *arg2 = (PySliceObject *) 0 ;
13015   void *argp1 = 0 ;
13016   int res1 = 0 ;
13017   PyObject * obj0 = 0 ;
13018   PyObject * obj1 = 0 ;
13019
13020   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___delitem__",&obj0,&obj1)) SWIG_fail;
13021   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13022   if (!SWIG_IsOK(res1)) {
13023     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13024   }
13025   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13026   {
13027     arg2 = (PySliceObject *) obj1;
13028   }
13029   try {
13030     std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_1(arg1,arg2);
13031   }
13032   catch(std::out_of_range &_e) {
13033     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13034   }
13035
13036   resultobj = SWIG_Py_Void();
13037   return resultobj;
13038 fail:
13039   return NULL;
13040 }
13041
13042
13043 SWIGINTERN PyObject *_wrap_VectorShapes___delitem__(PyObject *self, PyObject *args) {
13044   int argc;
13045   PyObject *argv[3];
13046   int ii;
13047
13048   if (!PyTuple_Check(args)) SWIG_fail;
13049   argc = (int)PyObject_Length(args);
13050   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
13051     argv[ii] = PyTuple_GET_ITEM(args,ii);
13052   }
13053   if (argc == 2) {
13054     int _v;
13055     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
13056     _v = SWIG_CheckState(res);
13057     if (_v) {
13058       {
13059         _v = PySlice_Check(argv[1]);
13060       }
13061       if (_v) {
13062         return _wrap_VectorShapes___delitem____SWIG_1(self, args);
13063       }
13064     }
13065   }
13066   if (argc == 2) {
13067     int _v;
13068     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
13069     _v = SWIG_CheckState(res);
13070     if (_v) {
13071       {
13072         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
13073         _v = SWIG_CheckState(res);
13074       }
13075       if (_v) {
13076         return _wrap_VectorShapes___delitem____SWIG_0(self, args);
13077       }
13078     }
13079   }
13080
13081 fail:
13082   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes___delitem__'.\n"
13083     "  Possible C/C++ prototypes are:\n"
13084     "    __delitem__(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::difference_type)\n"
13085     "    __delitem__(std::vector< Hex::NewShape * > *,PySliceObject *)\n");
13086   return NULL;
13087 }
13088
13089
13090 SWIGINTERN PyObject *_wrap_VectorShapes___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13091   PyObject *resultobj = 0;
13092   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13093   std::vector< Hex::NewShape * >::difference_type arg2 ;
13094   void *argp1 = 0 ;
13095   int res1 = 0 ;
13096   ptrdiff_t val2 ;
13097   int ecode2 = 0 ;
13098   PyObject * obj0 = 0 ;
13099   PyObject * obj1 = 0 ;
13100   std::vector< Hex::NewShape * >::value_type result;
13101
13102   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___getitem__",&obj0,&obj1)) SWIG_fail;
13103   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13104   if (!SWIG_IsOK(res1)) {
13105     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13106   }
13107   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13108   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13109   if (!SWIG_IsOK(ecode2)) {
13110     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
13111   }
13112   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
13113   try {
13114     result = (std::vector< Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_1(arg1,arg2);
13115   }
13116   catch(std::out_of_range &_e) {
13117     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13118   }
13119
13120   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
13121   return resultobj;
13122 fail:
13123   return NULL;
13124 }
13125
13126
13127 SWIGINTERN PyObject *_wrap_VectorShapes___getitem__(PyObject *self, PyObject *args) {
13128   int argc;
13129   PyObject *argv[3];
13130   int ii;
13131
13132   if (!PyTuple_Check(args)) SWIG_fail;
13133   argc = (int)PyObject_Length(args);
13134   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
13135     argv[ii] = PyTuple_GET_ITEM(args,ii);
13136   }
13137   if (argc == 2) {
13138     int _v;
13139     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
13140     _v = SWIG_CheckState(res);
13141     if (_v) {
13142       {
13143         _v = PySlice_Check(argv[1]);
13144       }
13145       if (_v) {
13146         return _wrap_VectorShapes___getitem____SWIG_0(self, args);
13147       }
13148     }
13149   }
13150   if (argc == 2) {
13151     int _v;
13152     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
13153     _v = SWIG_CheckState(res);
13154     if (_v) {
13155       {
13156         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
13157         _v = SWIG_CheckState(res);
13158       }
13159       if (_v) {
13160         return _wrap_VectorShapes___getitem____SWIG_1(self, args);
13161       }
13162     }
13163   }
13164
13165 fail:
13166   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes___getitem__'.\n"
13167     "  Possible C/C++ prototypes are:\n"
13168     "    __getitem__(std::vector< Hex::NewShape * > *,PySliceObject *)\n"
13169     "    __getitem__(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::difference_type)\n");
13170   return NULL;
13171 }
13172
13173
13174 SWIGINTERN PyObject *_wrap_VectorShapes___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13175   PyObject *resultobj = 0;
13176   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13177   std::vector< Hex::NewShape * >::difference_type arg2 ;
13178   std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
13179   void *argp1 = 0 ;
13180   int res1 = 0 ;
13181   ptrdiff_t val2 ;
13182   int ecode2 = 0 ;
13183   void *argp3 = 0 ;
13184   int res3 = 0 ;
13185   PyObject * obj0 = 0 ;
13186   PyObject * obj1 = 0 ;
13187   PyObject * obj2 = 0 ;
13188
13189   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
13190   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13191   if (!SWIG_IsOK(res1)) {
13192     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13193   }
13194   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13195   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13196   if (!SWIG_IsOK(ecode2)) {
13197     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
13198   }
13199   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
13200   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
13201   if (!SWIG_IsOK(res3)) {
13202     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
13203   }
13204   arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
13205   try {
13206     std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_1(arg1,arg2,arg3);
13207   }
13208   catch(std::out_of_range &_e) {
13209     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13210   }
13211
13212   resultobj = SWIG_Py_Void();
13213   return resultobj;
13214 fail:
13215   return NULL;
13216 }
13217
13218
13219 SWIGINTERN PyObject *_wrap_VectorShapes___setitem__(PyObject *self, PyObject *args) {
13220   int argc;
13221   PyObject *argv[4];
13222   int ii;
13223
13224   if (!PyTuple_Check(args)) SWIG_fail;
13225   argc = (int)PyObject_Length(args);
13226   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
13227     argv[ii] = PyTuple_GET_ITEM(args,ii);
13228   }
13229   if (argc == 3) {
13230     int _v;
13231     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
13232     _v = SWIG_CheckState(res);
13233     if (_v) {
13234       {
13235         _v = PySlice_Check(argv[1]);
13236       }
13237       if (_v) {
13238         int res = swig::asptr(argv[2], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
13239         _v = SWIG_CheckState(res);
13240         if (_v) {
13241           return _wrap_VectorShapes___setitem____SWIG_0(self, args);
13242         }
13243       }
13244     }
13245   }
13246   if (argc == 3) {
13247     int _v;
13248     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
13249     _v = SWIG_CheckState(res);
13250     if (_v) {
13251       {
13252         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
13253         _v = SWIG_CheckState(res);
13254       }
13255       if (_v) {
13256         void *vptr = 0;
13257         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0);
13258         _v = SWIG_CheckState(res);
13259         if (_v) {
13260           return _wrap_VectorShapes___setitem____SWIG_1(self, args);
13261         }
13262       }
13263     }
13264   }
13265
13266 fail:
13267   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes___setitem__'.\n"
13268     "  Possible C/C++ prototypes are:\n"
13269     "    __setitem__(std::vector< Hex::NewShape * > *,PySliceObject *,std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)\n"
13270     "    __setitem__(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::difference_type,std::vector< Hex::NewShape * >::value_type)\n");
13271   return NULL;
13272 }
13273
13274
13275 SWIGINTERN PyObject *_wrap_VectorShapes_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13276   PyObject *resultobj = 0;
13277   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13278   std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
13279   void *argp1 = 0 ;
13280   int res1 = 0 ;
13281   void *argp2 = 0 ;
13282   int res2 = 0 ;
13283   PyObject * obj0 = 0 ;
13284   PyObject * obj1 = 0 ;
13285
13286   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_append",&obj0,&obj1)) SWIG_fail;
13287   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13288   if (!SWIG_IsOK(res1)) {
13289     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_append" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13290   }
13291   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13292   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
13293   if (!SWIG_IsOK(res2)) {
13294     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_append" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
13295   }
13296   arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
13297   std_vector_Sl_Hex_NewShape_Sm__Sg__append(arg1,arg2);
13298   resultobj = SWIG_Py_Void();
13299   return resultobj;
13300 fail:
13301   return NULL;
13302 }
13303
13304
13305 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13306   PyObject *resultobj = 0;
13307   std::vector< Hex::NewShape * > *result = 0 ;
13308
13309   if (!PyArg_ParseTuple(args,(char *)":new_VectorShapes")) SWIG_fail;
13310   result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >();
13311   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
13312   return resultobj;
13313 fail:
13314   return NULL;
13315 }
13316
13317
13318 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13319   PyObject *resultobj = 0;
13320   std::vector< Hex::NewShape * > *arg1 = 0 ;
13321   int res1 = SWIG_OLDOBJ ;
13322   PyObject * obj0 = 0 ;
13323   std::vector< Hex::NewShape * > *result = 0 ;
13324
13325   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
13326   {
13327     std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
13328     res1 = swig::asptr(obj0, &ptr);
13329     if (!SWIG_IsOK(res1)) {
13330       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const &""'");
13331     }
13332     if (!ptr) {
13333       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const &""'");
13334     }
13335     arg1 = ptr;
13336   }
13337   result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >((std::vector< Hex::NewShape * > const &)*arg1);
13338   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
13339   if (SWIG_IsNewObj(res1)) delete arg1;
13340   return resultobj;
13341 fail:
13342   if (SWIG_IsNewObj(res1)) delete arg1;
13343   return NULL;
13344 }
13345
13346
13347 SWIGINTERN PyObject *_wrap_VectorShapes_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13348   PyObject *resultobj = 0;
13349   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13350   void *argp1 = 0 ;
13351   int res1 = 0 ;
13352   PyObject * obj0 = 0 ;
13353   bool result;
13354
13355   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_empty",&obj0)) SWIG_fail;
13356   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13357   if (!SWIG_IsOK(res1)) {
13358     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_empty" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
13359   }
13360   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13361   result = (bool)((std::vector< Hex::NewShape * > const *)arg1)->empty();
13362   resultobj = SWIG_From_bool(static_cast< bool >(result));
13363   return resultobj;
13364 fail:
13365   return NULL;
13366 }
13367
13368
13369 SWIGINTERN PyObject *_wrap_VectorShapes_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13370   PyObject *resultobj = 0;
13371   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13372   void *argp1 = 0 ;
13373   int res1 = 0 ;
13374   PyObject * obj0 = 0 ;
13375   std::vector< Hex::NewShape * >::size_type result;
13376
13377   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_size",&obj0)) SWIG_fail;
13378   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13379   if (!SWIG_IsOK(res1)) {
13380     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_size" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
13381   }
13382   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13383   result = ((std::vector< Hex::NewShape * > const *)arg1)->size();
13384   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
13385   return resultobj;
13386 fail:
13387   return NULL;
13388 }
13389
13390
13391 SWIGINTERN PyObject *_wrap_VectorShapes_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13392   PyObject *resultobj = 0;
13393   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13394   void *argp1 = 0 ;
13395   int res1 = 0 ;
13396   PyObject * obj0 = 0 ;
13397
13398   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_clear",&obj0)) SWIG_fail;
13399   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13400   if (!SWIG_IsOK(res1)) {
13401     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_clear" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13402   }
13403   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13404   (arg1)->clear();
13405   resultobj = SWIG_Py_Void();
13406   return resultobj;
13407 fail:
13408   return NULL;
13409 }
13410
13411
13412 SWIGINTERN PyObject *_wrap_VectorShapes_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13413   PyObject *resultobj = 0;
13414   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13415   std::vector< Hex::NewShape * > *arg2 = 0 ;
13416   void *argp1 = 0 ;
13417   int res1 = 0 ;
13418   void *argp2 = 0 ;
13419   int res2 = 0 ;
13420   PyObject * obj0 = 0 ;
13421   PyObject * obj1 = 0 ;
13422
13423   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_swap",&obj0,&obj1)) SWIG_fail;
13424   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13425   if (!SWIG_IsOK(res1)) {
13426     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_swap" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13427   }
13428   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13429   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t,  0 );
13430   if (!SWIG_IsOK(res2)) {
13431     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector< Hex::NewShape * > &""'");
13432   }
13433   if (!argp2) {
13434     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector< Hex::NewShape * > &""'");
13435   }
13436   arg2 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp2);
13437   (arg1)->swap(*arg2);
13438   resultobj = SWIG_Py_Void();
13439   return resultobj;
13440 fail:
13441   return NULL;
13442 }
13443
13444
13445 SWIGINTERN PyObject *_wrap_VectorShapes_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13446   PyObject *resultobj = 0;
13447   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13448   void *argp1 = 0 ;
13449   int res1 = 0 ;
13450   PyObject * obj0 = 0 ;
13451   SwigValueWrapper< std::allocator< Hex::NewShape * > > result;
13452
13453   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_get_allocator",&obj0)) SWIG_fail;
13454   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13455   if (!SWIG_IsOK(res1)) {
13456     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
13457   }
13458   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13459   result = ((std::vector< Hex::NewShape * > const *)arg1)->get_allocator();
13460   resultobj = SWIG_NewPointerObj((new std::vector< Hex::NewShape * >::allocator_type(static_cast< const std::vector< Hex::NewShape * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
13461   return resultobj;
13462 fail:
13463   return NULL;
13464 }
13465
13466
13467 SWIGINTERN PyObject *_wrap_VectorShapes_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13468   PyObject *resultobj = 0;
13469   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13470   void *argp1 = 0 ;
13471   int res1 = 0 ;
13472   PyObject * obj0 = 0 ;
13473   std::vector< Hex::NewShape * >::const_iterator result;
13474
13475   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_begin",&obj0)) SWIG_fail;
13476   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13477   if (!SWIG_IsOK(res1)) {
13478     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_begin" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
13479   }
13480   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13481   result = ((std::vector< Hex::NewShape * > const *)arg1)->begin();
13482   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::const_iterator & >(result)),
13483     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13484   return resultobj;
13485 fail:
13486   return NULL;
13487 }
13488
13489
13490 SWIGINTERN PyObject *_wrap_VectorShapes_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13491   PyObject *resultobj = 0;
13492   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13493   void *argp1 = 0 ;
13494   int res1 = 0 ;
13495   PyObject * obj0 = 0 ;
13496   std::vector< Hex::NewShape * >::const_iterator result;
13497
13498   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_end",&obj0)) SWIG_fail;
13499   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13500   if (!SWIG_IsOK(res1)) {
13501     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_end" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
13502   }
13503   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13504   result = ((std::vector< Hex::NewShape * > const *)arg1)->end();
13505   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::const_iterator & >(result)),
13506     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13507   return resultobj;
13508 fail:
13509   return NULL;
13510 }
13511
13512
13513 SWIGINTERN PyObject *_wrap_VectorShapes_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13514   PyObject *resultobj = 0;
13515   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13516   void *argp1 = 0 ;
13517   int res1 = 0 ;
13518   PyObject * obj0 = 0 ;
13519   std::vector< Hex::NewShape * >::const_reverse_iterator result;
13520
13521   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rbegin",&obj0)) SWIG_fail;
13522   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13523   if (!SWIG_IsOK(res1)) {
13524     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rbegin" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
13525   }
13526   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13527   result = ((std::vector< Hex::NewShape * > const *)arg1)->rbegin();
13528   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::const_reverse_iterator & >(result)),
13529     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13530   return resultobj;
13531 fail:
13532   return NULL;
13533 }
13534
13535
13536 SWIGINTERN PyObject *_wrap_VectorShapes_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13537   PyObject *resultobj = 0;
13538   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13539   void *argp1 = 0 ;
13540   int res1 = 0 ;
13541   PyObject * obj0 = 0 ;
13542   std::vector< Hex::NewShape * >::const_reverse_iterator result;
13543
13544   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rend",&obj0)) SWIG_fail;
13545   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13546   if (!SWIG_IsOK(res1)) {
13547     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rend" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
13548   }
13549   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13550   result = ((std::vector< Hex::NewShape * > const *)arg1)->rend();
13551   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::const_reverse_iterator & >(result)),
13552     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13553   return resultobj;
13554 fail:
13555   return NULL;
13556 }
13557
13558
13559 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13560   PyObject *resultobj = 0;
13561   std::vector< Hex::NewShape * >::size_type arg1 ;
13562   size_t val1 ;
13563   int ecode1 = 0 ;
13564   PyObject * obj0 = 0 ;
13565   std::vector< Hex::NewShape * > *result = 0 ;
13566
13567   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
13568   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
13569   if (!SWIG_IsOK(ecode1)) {
13570     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
13571   }
13572   arg1 = static_cast< std::vector< Hex::NewShape * >::size_type >(val1);
13573   result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >(arg1);
13574   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
13575   return resultobj;
13576 fail:
13577   return NULL;
13578 }
13579
13580
13581 SWIGINTERN PyObject *_wrap_VectorShapes_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13582   PyObject *resultobj = 0;
13583   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13584   void *argp1 = 0 ;
13585   int res1 = 0 ;
13586   PyObject * obj0 = 0 ;
13587
13588   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop_back",&obj0)) SWIG_fail;
13589   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13590   if (!SWIG_IsOK(res1)) {
13591     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13592   }
13593   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13594   (arg1)->pop_back();
13595   resultobj = SWIG_Py_Void();
13596   return resultobj;
13597 fail:
13598   return NULL;
13599 }
13600
13601
13602 SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13603   PyObject *resultobj = 0;
13604   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13605   std::vector< Hex::NewShape * >::size_type arg2 ;
13606   void *argp1 = 0 ;
13607   int res1 = 0 ;
13608   size_t val2 ;
13609   int ecode2 = 0 ;
13610   PyObject * obj0 = 0 ;
13611   PyObject * obj1 = 0 ;
13612
13613   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_resize",&obj0,&obj1)) SWIG_fail;
13614   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13615   if (!SWIG_IsOK(res1)) {
13616     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13617   }
13618   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13619   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13620   if (!SWIG_IsOK(ecode2)) {
13621     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
13622   }
13623   arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
13624   (arg1)->resize(arg2);
13625   resultobj = SWIG_Py_Void();
13626   return resultobj;
13627 fail:
13628   return NULL;
13629 }
13630
13631
13632 SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13633   PyObject *resultobj = 0;
13634   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13635   std::vector< Hex::NewShape * >::iterator arg2 ;
13636   void *argp1 = 0 ;
13637   int res1 = 0 ;
13638   swig::SwigPyIterator *iter2 = 0 ;
13639   int res2 ;
13640   PyObject * obj0 = 0 ;
13641   PyObject * obj1 = 0 ;
13642   std::vector< Hex::NewShape * >::iterator result;
13643
13644   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_erase",&obj0,&obj1)) SWIG_fail;
13645   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13646   if (!SWIG_IsOK(res1)) {
13647     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13648   }
13649   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13650   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
13651   if (!SWIG_IsOK(res2) || !iter2) {
13652     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
13653   } else {
13654     swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
13655     if (iter_t) {
13656       arg2 = iter_t->get_current();
13657     } else {
13658       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
13659     }
13660   }
13661   result = (arg1)->erase(arg2);
13662   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
13663     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13664   return resultobj;
13665 fail:
13666   return NULL;
13667 }
13668
13669
13670 SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13671   PyObject *resultobj = 0;
13672   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13673   std::vector< Hex::NewShape * >::iterator arg2 ;
13674   std::vector< Hex::NewShape * >::iterator arg3 ;
13675   void *argp1 = 0 ;
13676   int res1 = 0 ;
13677   swig::SwigPyIterator *iter2 = 0 ;
13678   int res2 ;
13679   swig::SwigPyIterator *iter3 = 0 ;
13680   int res3 ;
13681   PyObject * obj0 = 0 ;
13682   PyObject * obj1 = 0 ;
13683   PyObject * obj2 = 0 ;
13684   std::vector< Hex::NewShape * >::iterator result;
13685
13686   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_erase",&obj0,&obj1,&obj2)) SWIG_fail;
13687   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13688   if (!SWIG_IsOK(res1)) {
13689     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13690   }
13691   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13692   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
13693   if (!SWIG_IsOK(res2) || !iter2) {
13694     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
13695   } else {
13696     swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
13697     if (iter_t) {
13698       arg2 = iter_t->get_current();
13699     } else {
13700       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
13701     }
13702   }
13703   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
13704   if (!SWIG_IsOK(res3) || !iter3) {
13705     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
13706   } else {
13707     swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter3);
13708     if (iter_t) {
13709       arg3 = iter_t->get_current();
13710     } else {
13711       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
13712     }
13713   }
13714   result = (arg1)->erase(arg2,arg3);
13715   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
13716     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13717   return resultobj;
13718 fail:
13719   return NULL;
13720 }
13721
13722
13723 SWIGINTERN PyObject *_wrap_VectorShapes_erase(PyObject *self, PyObject *args) {
13724   int argc;
13725   PyObject *argv[4];
13726   int ii;
13727
13728   if (!PyTuple_Check(args)) SWIG_fail;
13729   argc = (int)PyObject_Length(args);
13730   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
13731     argv[ii] = PyTuple_GET_ITEM(args,ii);
13732   }
13733   if (argc == 2) {
13734     int _v;
13735     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
13736     _v = SWIG_CheckState(res);
13737     if (_v) {
13738       swig::SwigPyIterator *iter = 0;
13739       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
13740       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
13741       if (_v) {
13742         return _wrap_VectorShapes_erase__SWIG_0(self, args);
13743       }
13744     }
13745   }
13746   if (argc == 3) {
13747     int _v;
13748     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
13749     _v = SWIG_CheckState(res);
13750     if (_v) {
13751       swig::SwigPyIterator *iter = 0;
13752       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
13753       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
13754       if (_v) {
13755         swig::SwigPyIterator *iter = 0;
13756         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
13757         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
13758         if (_v) {
13759           return _wrap_VectorShapes_erase__SWIG_1(self, args);
13760         }
13761       }
13762     }
13763   }
13764
13765 fail:
13766   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_erase'.\n"
13767     "  Possible C/C++ prototypes are:\n"
13768     "    erase(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::iterator)\n"
13769     "    erase(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::iterator)\n");
13770   return NULL;
13771 }
13772
13773
13774 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13775   PyObject *resultobj = 0;
13776   std::vector< Hex::NewShape * >::size_type arg1 ;
13777   std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
13778   size_t val1 ;
13779   int ecode1 = 0 ;
13780   void *argp2 = 0 ;
13781   int res2 = 0 ;
13782   PyObject * obj0 = 0 ;
13783   PyObject * obj1 = 0 ;
13784   std::vector< Hex::NewShape * > *result = 0 ;
13785
13786   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorShapes",&obj0,&obj1)) SWIG_fail;
13787   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
13788   if (!SWIG_IsOK(ecode1)) {
13789     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
13790   }
13791   arg1 = static_cast< std::vector< Hex::NewShape * >::size_type >(val1);
13792   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
13793   if (!SWIG_IsOK(res2)) {
13794     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorShapes" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
13795   }
13796   arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
13797   result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >(arg1,arg2);
13798   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
13799   return resultobj;
13800 fail:
13801   return NULL;
13802 }
13803
13804
13805 SWIGINTERN PyObject *_wrap_new_VectorShapes(PyObject *self, PyObject *args) {
13806   int argc;
13807   PyObject *argv[3];
13808   int ii;
13809
13810   if (!PyTuple_Check(args)) SWIG_fail;
13811   argc = (int)PyObject_Length(args);
13812   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
13813     argv[ii] = PyTuple_GET_ITEM(args,ii);
13814   }
13815   if (argc == 0) {
13816     return _wrap_new_VectorShapes__SWIG_0(self, args);
13817   }
13818   if (argc == 1) {
13819     int _v;
13820     {
13821       int res = SWIG_AsVal_size_t(argv[0], NULL);
13822       _v = SWIG_CheckState(res);
13823     }
13824     if (_v) {
13825       return _wrap_new_VectorShapes__SWIG_2(self, args);
13826     }
13827   }
13828   if (argc == 1) {
13829     int _v;
13830     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
13831     _v = SWIG_CheckState(res);
13832     if (_v) {
13833       return _wrap_new_VectorShapes__SWIG_1(self, args);
13834     }
13835   }
13836   if (argc == 2) {
13837     int _v;
13838     {
13839       int res = SWIG_AsVal_size_t(argv[0], NULL);
13840       _v = SWIG_CheckState(res);
13841     }
13842     if (_v) {
13843       void *vptr = 0;
13844       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0);
13845       _v = SWIG_CheckState(res);
13846       if (_v) {
13847         return _wrap_new_VectorShapes__SWIG_3(self, args);
13848       }
13849     }
13850   }
13851
13852 fail:
13853   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorShapes'.\n"
13854     "  Possible C/C++ prototypes are:\n"
13855     "    std::vector< Hex::NewShape * >()\n"
13856     "    std::vector< Hex::NewShape * >(std::vector< Hex::NewShape * > const &)\n"
13857     "    std::vector< Hex::NewShape * >(std::vector< Hex::NewShape * >::size_type)\n"
13858     "    std::vector< Hex::NewShape * >(std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
13859   return NULL;
13860 }
13861
13862
13863 SWIGINTERN PyObject *_wrap_VectorShapes_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13864   PyObject *resultobj = 0;
13865   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13866   std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
13867   void *argp1 = 0 ;
13868   int res1 = 0 ;
13869   void *argp2 = 0 ;
13870   int res2 = 0 ;
13871   PyObject * obj0 = 0 ;
13872   PyObject * obj1 = 0 ;
13873
13874   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_push_back",&obj0,&obj1)) SWIG_fail;
13875   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13876   if (!SWIG_IsOK(res1)) {
13877     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_push_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13878   }
13879   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13880   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
13881   if (!SWIG_IsOK(res2)) {
13882     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_push_back" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
13883   }
13884   arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
13885   (arg1)->push_back(arg2);
13886   resultobj = SWIG_Py_Void();
13887   return resultobj;
13888 fail:
13889   return NULL;
13890 }
13891
13892
13893 SWIGINTERN PyObject *_wrap_VectorShapes_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13894   PyObject *resultobj = 0;
13895   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13896   void *argp1 = 0 ;
13897   int res1 = 0 ;
13898   PyObject * obj0 = 0 ;
13899   std::vector< Hex::NewShape * >::value_type result;
13900
13901   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_front",&obj0)) SWIG_fail;
13902   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13903   if (!SWIG_IsOK(res1)) {
13904     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_front" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
13905   }
13906   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13907   result = (std::vector< Hex::NewShape * >::value_type)((std::vector< Hex::NewShape * > const *)arg1)->front();
13908   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
13909   return resultobj;
13910 fail:
13911   return NULL;
13912 }
13913
13914
13915 SWIGINTERN PyObject *_wrap_VectorShapes_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13916   PyObject *resultobj = 0;
13917   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13918   void *argp1 = 0 ;
13919   int res1 = 0 ;
13920   PyObject * obj0 = 0 ;
13921   std::vector< Hex::NewShape * >::value_type result;
13922
13923   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_back",&obj0)) SWIG_fail;
13924   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13925   if (!SWIG_IsOK(res1)) {
13926     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
13927   }
13928   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13929   result = (std::vector< Hex::NewShape * >::value_type)((std::vector< Hex::NewShape * > const *)arg1)->back();
13930   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
13931   return resultobj;
13932 fail:
13933   return NULL;
13934 }
13935
13936
13937 SWIGINTERN PyObject *_wrap_VectorShapes_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13938   PyObject *resultobj = 0;
13939   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13940   std::vector< Hex::NewShape * >::size_type arg2 ;
13941   std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
13942   void *argp1 = 0 ;
13943   int res1 = 0 ;
13944   size_t val2 ;
13945   int ecode2 = 0 ;
13946   void *argp3 = 0 ;
13947   int res3 = 0 ;
13948   PyObject * obj0 = 0 ;
13949   PyObject * obj1 = 0 ;
13950   PyObject * obj2 = 0 ;
13951
13952   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_assign",&obj0,&obj1,&obj2)) SWIG_fail;
13953   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13954   if (!SWIG_IsOK(res1)) {
13955     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_assign" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13956   }
13957   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13958   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13959   if (!SWIG_IsOK(ecode2)) {
13960     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_assign" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
13961   }
13962   arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
13963   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
13964   if (!SWIG_IsOK(res3)) {
13965     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_assign" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
13966   }
13967   arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
13968   (arg1)->assign(arg2,arg3);
13969   resultobj = SWIG_Py_Void();
13970   return resultobj;
13971 fail:
13972   return NULL;
13973 }
13974
13975
13976 SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13977   PyObject *resultobj = 0;
13978   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
13979   std::vector< Hex::NewShape * >::size_type arg2 ;
13980   std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
13981   void *argp1 = 0 ;
13982   int res1 = 0 ;
13983   size_t val2 ;
13984   int ecode2 = 0 ;
13985   void *argp3 = 0 ;
13986   int res3 = 0 ;
13987   PyObject * obj0 = 0 ;
13988   PyObject * obj1 = 0 ;
13989   PyObject * obj2 = 0 ;
13990
13991   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_resize",&obj0,&obj1,&obj2)) SWIG_fail;
13992   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
13993   if (!SWIG_IsOK(res1)) {
13994     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
13995   }
13996   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
13997   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13998   if (!SWIG_IsOK(ecode2)) {
13999     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
14000   }
14001   arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
14002   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
14003   if (!SWIG_IsOK(res3)) {
14004     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_resize" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
14005   }
14006   arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
14007   (arg1)->resize(arg2,arg3);
14008   resultobj = SWIG_Py_Void();
14009   return resultobj;
14010 fail:
14011   return NULL;
14012 }
14013
14014
14015 SWIGINTERN PyObject *_wrap_VectorShapes_resize(PyObject *self, PyObject *args) {
14016   int argc;
14017   PyObject *argv[4];
14018   int ii;
14019
14020   if (!PyTuple_Check(args)) SWIG_fail;
14021   argc = (int)PyObject_Length(args);
14022   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
14023     argv[ii] = PyTuple_GET_ITEM(args,ii);
14024   }
14025   if (argc == 2) {
14026     int _v;
14027     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14028     _v = SWIG_CheckState(res);
14029     if (_v) {
14030       {
14031         int res = SWIG_AsVal_size_t(argv[1], NULL);
14032         _v = SWIG_CheckState(res);
14033       }
14034       if (_v) {
14035         return _wrap_VectorShapes_resize__SWIG_0(self, args);
14036       }
14037     }
14038   }
14039   if (argc == 3) {
14040     int _v;
14041     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14042     _v = SWIG_CheckState(res);
14043     if (_v) {
14044       {
14045         int res = SWIG_AsVal_size_t(argv[1], NULL);
14046         _v = SWIG_CheckState(res);
14047       }
14048       if (_v) {
14049         void *vptr = 0;
14050         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0);
14051         _v = SWIG_CheckState(res);
14052         if (_v) {
14053           return _wrap_VectorShapes_resize__SWIG_1(self, args);
14054         }
14055       }
14056     }
14057   }
14058
14059 fail:
14060   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_resize'.\n"
14061     "  Possible C/C++ prototypes are:\n"
14062     "    resize(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::size_type)\n"
14063     "    resize(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
14064   return NULL;
14065 }
14066
14067
14068 SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14069   PyObject *resultobj = 0;
14070   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14071   std::vector< Hex::NewShape * >::iterator arg2 ;
14072   std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
14073   void *argp1 = 0 ;
14074   int res1 = 0 ;
14075   swig::SwigPyIterator *iter2 = 0 ;
14076   int res2 ;
14077   void *argp3 = 0 ;
14078   int res3 = 0 ;
14079   PyObject * obj0 = 0 ;
14080   PyObject * obj1 = 0 ;
14081   PyObject * obj2 = 0 ;
14082   std::vector< Hex::NewShape * >::iterator result;
14083
14084   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_insert",&obj0,&obj1,&obj2)) SWIG_fail;
14085   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14086   if (!SWIG_IsOK(res1)) {
14087     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14088   }
14089   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14090   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
14091   if (!SWIG_IsOK(res2) || !iter2) {
14092     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
14093   } else {
14094     swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
14095     if (iter_t) {
14096       arg2 = iter_t->get_current();
14097     } else {
14098       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
14099     }
14100   }
14101   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
14102   if (!SWIG_IsOK(res3)) {
14103     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
14104   }
14105   arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
14106   result = (arg1)->insert(arg2,arg3);
14107   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
14108     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
14109   return resultobj;
14110 fail:
14111   return NULL;
14112 }
14113
14114
14115 SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14116   PyObject *resultobj = 0;
14117   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14118   std::vector< Hex::NewShape * >::iterator arg2 ;
14119   std::vector< Hex::NewShape * >::size_type arg3 ;
14120   std::vector< Hex::NewShape * >::value_type arg4 = (std::vector< Hex::NewShape * >::value_type) 0 ;
14121   void *argp1 = 0 ;
14122   int res1 = 0 ;
14123   swig::SwigPyIterator *iter2 = 0 ;
14124   int res2 ;
14125   size_t val3 ;
14126   int ecode3 = 0 ;
14127   void *argp4 = 0 ;
14128   int res4 = 0 ;
14129   PyObject * obj0 = 0 ;
14130   PyObject * obj1 = 0 ;
14131   PyObject * obj2 = 0 ;
14132   PyObject * obj3 = 0 ;
14133
14134   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14135   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14136   if (!SWIG_IsOK(res1)) {
14137     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14138   }
14139   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14140   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
14141   if (!SWIG_IsOK(res2) || !iter2) {
14142     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
14143   } else {
14144     swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
14145     if (iter_t) {
14146       arg2 = iter_t->get_current();
14147     } else {
14148       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
14149     }
14150   }
14151   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14152   if (!SWIG_IsOK(ecode3)) {
14153     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
14154   }
14155   arg3 = static_cast< std::vector< Hex::NewShape * >::size_type >(val3);
14156   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0 |  0 );
14157   if (!SWIG_IsOK(res4)) {
14158     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes_insert" "', argument " "4"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
14159   }
14160   arg4 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp4);
14161   (arg1)->insert(arg2,arg3,arg4);
14162   resultobj = SWIG_Py_Void();
14163   return resultobj;
14164 fail:
14165   return NULL;
14166 }
14167
14168
14169 SWIGINTERN PyObject *_wrap_VectorShapes_insert(PyObject *self, PyObject *args) {
14170   int argc;
14171   PyObject *argv[5];
14172   int ii;
14173
14174   if (!PyTuple_Check(args)) SWIG_fail;
14175   argc = (int)PyObject_Length(args);
14176   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
14177     argv[ii] = PyTuple_GET_ITEM(args,ii);
14178   }
14179   if (argc == 3) {
14180     int _v;
14181     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14182     _v = SWIG_CheckState(res);
14183     if (_v) {
14184       swig::SwigPyIterator *iter = 0;
14185       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
14186       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
14187       if (_v) {
14188         void *vptr = 0;
14189         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0);
14190         _v = SWIG_CheckState(res);
14191         if (_v) {
14192           return _wrap_VectorShapes_insert__SWIG_0(self, args);
14193         }
14194       }
14195     }
14196   }
14197   if (argc == 4) {
14198     int _v;
14199     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14200     _v = SWIG_CheckState(res);
14201     if (_v) {
14202       swig::SwigPyIterator *iter = 0;
14203       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
14204       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
14205       if (_v) {
14206         {
14207           int res = SWIG_AsVal_size_t(argv[2], NULL);
14208           _v = SWIG_CheckState(res);
14209         }
14210         if (_v) {
14211           void *vptr = 0;
14212           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0);
14213           _v = SWIG_CheckState(res);
14214           if (_v) {
14215             return _wrap_VectorShapes_insert__SWIG_1(self, args);
14216           }
14217         }
14218       }
14219     }
14220   }
14221
14222 fail:
14223   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_insert'.\n"
14224     "  Possible C/C++ prototypes are:\n"
14225     "    insert(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::value_type)\n"
14226     "    insert(std::vector< Hex::NewShape * > *,std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
14227   return NULL;
14228 }
14229
14230
14231 SWIGINTERN PyObject *_wrap_VectorShapes_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14232   PyObject *resultobj = 0;
14233   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14234   std::vector< Hex::NewShape * >::size_type arg2 ;
14235   void *argp1 = 0 ;
14236   int res1 = 0 ;
14237   size_t val2 ;
14238   int ecode2 = 0 ;
14239   PyObject * obj0 = 0 ;
14240   PyObject * obj1 = 0 ;
14241
14242   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_reserve",&obj0,&obj1)) SWIG_fail;
14243   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14244   if (!SWIG_IsOK(res1)) {
14245     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_reserve" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14246   }
14247   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14248   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
14249   if (!SWIG_IsOK(ecode2)) {
14250     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_reserve" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
14251   }
14252   arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
14253   (arg1)->reserve(arg2);
14254   resultobj = SWIG_Py_Void();
14255   return resultobj;
14256 fail:
14257   return NULL;
14258 }
14259
14260
14261 SWIGINTERN PyObject *_wrap_VectorShapes_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14262   PyObject *resultobj = 0;
14263   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14264   void *argp1 = 0 ;
14265   int res1 = 0 ;
14266   PyObject * obj0 = 0 ;
14267   std::vector< Hex::NewShape * >::size_type result;
14268
14269   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_capacity",&obj0)) SWIG_fail;
14270   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14271   if (!SWIG_IsOK(res1)) {
14272     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_capacity" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
14273   }
14274   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14275   result = ((std::vector< Hex::NewShape * > const *)arg1)->capacity();
14276   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
14277   return resultobj;
14278 fail:
14279   return NULL;
14280 }
14281
14282
14283 SWIGINTERN PyObject *_wrap_delete_VectorShapes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14284   PyObject *resultobj = 0;
14285   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14286   void *argp1 = 0 ;
14287   int res1 = 0 ;
14288   PyObject * obj0 = 0 ;
14289
14290   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorShapes",&obj0)) SWIG_fail;
14291   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_DISOWN |  0 );
14292   if (!SWIG_IsOK(res1)) {
14293     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14294   }
14295   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14296   delete arg1;
14297   resultobj = SWIG_Py_Void();
14298   return resultobj;
14299 fail:
14300   return NULL;
14301 }
14302
14303
14304 SWIGINTERN PyObject *VectorShapes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14305   PyObject *obj;
14306   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
14307   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_NewClientData(obj));
14308   return SWIG_Py_Void();
14309 }
14310
14311 SWIGINTERN PyObject *_wrap_VectorReal_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14312   PyObject *resultobj = 0;
14313   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14314   PyObject **arg2 = (PyObject **) 0 ;
14315   void *argp1 = 0 ;
14316   int res1 = 0 ;
14317   PyObject * obj0 = 0 ;
14318   swig::SwigPyIterator *result = 0 ;
14319
14320   arg2 = &obj0;
14321   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_iterator",&obj0)) SWIG_fail;
14322   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14323   if (!SWIG_IsOK(res1)) {
14324     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_iterator" "', argument " "1"" of type '" "std::vector< double > *""'");
14325   }
14326   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14327   result = (swig::SwigPyIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
14328   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
14329   return resultobj;
14330 fail:
14331   return NULL;
14332 }
14333
14334
14335 SWIGINTERN PyObject *_wrap_VectorReal___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14336   PyObject *resultobj = 0;
14337   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14338   void *argp1 = 0 ;
14339   int res1 = 0 ;
14340   PyObject * obj0 = 0 ;
14341   bool result;
14342
14343   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___nonzero__",&obj0)) SWIG_fail;
14344   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14345   if (!SWIG_IsOK(res1)) {
14346     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'");
14347   }
14348   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14349   result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
14350   resultobj = SWIG_From_bool(static_cast< bool >(result));
14351   return resultobj;
14352 fail:
14353   return NULL;
14354 }
14355
14356
14357 SWIGINTERN PyObject *_wrap_VectorReal___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14358   PyObject *resultobj = 0;
14359   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14360   void *argp1 = 0 ;
14361   int res1 = 0 ;
14362   PyObject * obj0 = 0 ;
14363   bool result;
14364
14365   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___bool__",&obj0)) SWIG_fail;
14366   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14367   if (!SWIG_IsOK(res1)) {
14368     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___bool__" "', argument " "1"" of type '" "std::vector< double > const *""'");
14369   }
14370   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14371   result = (bool)std_vector_Sl_double_Sg____bool__((std::vector< double > const *)arg1);
14372   resultobj = SWIG_From_bool(static_cast< bool >(result));
14373   return resultobj;
14374 fail:
14375   return NULL;
14376 }
14377
14378
14379 SWIGINTERN PyObject *_wrap_VectorReal___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14380   PyObject *resultobj = 0;
14381   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14382   void *argp1 = 0 ;
14383   int res1 = 0 ;
14384   PyObject * obj0 = 0 ;
14385   std::vector< double >::size_type result;
14386
14387   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___len__",&obj0)) SWIG_fail;
14388   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14389   if (!SWIG_IsOK(res1)) {
14390     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___len__" "', argument " "1"" of type '" "std::vector< double > const *""'");
14391   }
14392   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14393   result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
14394   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
14395   return resultobj;
14396 fail:
14397   return NULL;
14398 }
14399
14400
14401 SWIGINTERN PyObject *_wrap_VectorReal_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14402   PyObject *resultobj = 0;
14403   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14404   void *argp1 = 0 ;
14405   int res1 = 0 ;
14406   PyObject * obj0 = 0 ;
14407   std::vector< double >::value_type result;
14408
14409   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop",&obj0)) SWIG_fail;
14410   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14411   if (!SWIG_IsOK(res1)) {
14412     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop" "', argument " "1"" of type '" "std::vector< double > *""'");
14413   }
14414   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14415   try {
14416     result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
14417   }
14418   catch(std::out_of_range &_e) {
14419     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14420   }
14421
14422   resultobj = SWIG_From_double(static_cast< double >(result));
14423   return resultobj;
14424 fail:
14425   return NULL;
14426 }
14427
14428
14429 SWIGINTERN PyObject *_wrap_VectorReal___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14430   PyObject *resultobj = 0;
14431   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14432   std::vector< double >::difference_type arg2 ;
14433   std::vector< double >::difference_type arg3 ;
14434   void *argp1 = 0 ;
14435   int res1 = 0 ;
14436   ptrdiff_t val2 ;
14437   int ecode2 = 0 ;
14438   ptrdiff_t val3 ;
14439   int ecode3 = 0 ;
14440   PyObject * obj0 = 0 ;
14441   PyObject * obj1 = 0 ;
14442   PyObject * obj2 = 0 ;
14443   std::vector< double,std::allocator< double > > *result = 0 ;
14444
14445   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
14446   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14447   if (!SWIG_IsOK(res1)) {
14448     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
14449   }
14450   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14451   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14452   if (!SWIG_IsOK(ecode2)) {
14453     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
14454   }
14455   arg2 = static_cast< std::vector< double >::difference_type >(val2);
14456   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
14457   if (!SWIG_IsOK(ecode3)) {
14458     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
14459   }
14460   arg3 = static_cast< std::vector< double >::difference_type >(val3);
14461   try {
14462     result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
14463   }
14464   catch(std::out_of_range &_e) {
14465     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14466   }
14467
14468   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
14469   return resultobj;
14470 fail:
14471   return NULL;
14472 }
14473
14474
14475 SWIGINTERN PyObject *_wrap_VectorReal___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14476   PyObject *resultobj = 0;
14477   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14478   std::vector< double >::difference_type arg2 ;
14479   std::vector< double >::difference_type arg3 ;
14480   std::vector< double,std::allocator< double > > *arg4 = 0 ;
14481   void *argp1 = 0 ;
14482   int res1 = 0 ;
14483   ptrdiff_t val2 ;
14484   int ecode2 = 0 ;
14485   ptrdiff_t val3 ;
14486   int ecode3 = 0 ;
14487   int res4 = SWIG_OLDOBJ ;
14488   PyObject * obj0 = 0 ;
14489   PyObject * obj1 = 0 ;
14490   PyObject * obj2 = 0 ;
14491   PyObject * obj3 = 0 ;
14492
14493   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14494   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14495   if (!SWIG_IsOK(res1)) {
14496     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
14497   }
14498   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14499   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14500   if (!SWIG_IsOK(ecode2)) {
14501     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
14502   }
14503   arg2 = static_cast< std::vector< double >::difference_type >(val2);
14504   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
14505   if (!SWIG_IsOK(ecode3)) {
14506     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
14507   }
14508   arg3 = static_cast< std::vector< double >::difference_type >(val3);
14509   {
14510     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
14511     res4 = swig::asptr(obj3, &ptr);
14512     if (!SWIG_IsOK(res4)) {
14513       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
14514     }
14515     if (!ptr) {
14516       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
14517     }
14518     arg4 = ptr;
14519   }
14520   try {
14521     std_vector_Sl_double_Sg____setslice__(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
14522   }
14523   catch(std::out_of_range &_e) {
14524     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14525   }
14526   catch(std::invalid_argument &_e) {
14527     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14528   }
14529
14530   resultobj = SWIG_Py_Void();
14531   if (SWIG_IsNewObj(res4)) delete arg4;
14532   return resultobj;
14533 fail:
14534   if (SWIG_IsNewObj(res4)) delete arg4;
14535   return NULL;
14536 }
14537
14538
14539 SWIGINTERN PyObject *_wrap_VectorReal___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14540   PyObject *resultobj = 0;
14541   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14542   std::vector< double >::difference_type arg2 ;
14543   std::vector< double >::difference_type arg3 ;
14544   void *argp1 = 0 ;
14545   int res1 = 0 ;
14546   ptrdiff_t val2 ;
14547   int ecode2 = 0 ;
14548   ptrdiff_t val3 ;
14549   int ecode3 = 0 ;
14550   PyObject * obj0 = 0 ;
14551   PyObject * obj1 = 0 ;
14552   PyObject * obj2 = 0 ;
14553
14554   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
14555   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14556   if (!SWIG_IsOK(res1)) {
14557     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
14558   }
14559   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14560   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14561   if (!SWIG_IsOK(ecode2)) {
14562     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
14563   }
14564   arg2 = static_cast< std::vector< double >::difference_type >(val2);
14565   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
14566   if (!SWIG_IsOK(ecode3)) {
14567     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
14568   }
14569   arg3 = static_cast< std::vector< double >::difference_type >(val3);
14570   try {
14571     std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
14572   }
14573   catch(std::out_of_range &_e) {
14574     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14575   }
14576
14577   resultobj = SWIG_Py_Void();
14578   return resultobj;
14579 fail:
14580   return NULL;
14581 }
14582
14583
14584 SWIGINTERN PyObject *_wrap_VectorReal___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14585   PyObject *resultobj = 0;
14586   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14587   std::vector< double >::difference_type arg2 ;
14588   void *argp1 = 0 ;
14589   int res1 = 0 ;
14590   ptrdiff_t val2 ;
14591   int ecode2 = 0 ;
14592   PyObject * obj0 = 0 ;
14593   PyObject * obj1 = 0 ;
14594
14595   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___delitem__",&obj0,&obj1)) SWIG_fail;
14596   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14597   if (!SWIG_IsOK(res1)) {
14598     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
14599   }
14600   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14601   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14602   if (!SWIG_IsOK(ecode2)) {
14603     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
14604   }
14605   arg2 = static_cast< std::vector< double >::difference_type >(val2);
14606   try {
14607     std_vector_Sl_double_Sg____delitem____SWIG_0(arg1,arg2);
14608   }
14609   catch(std::out_of_range &_e) {
14610     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14611   }
14612
14613   resultobj = SWIG_Py_Void();
14614   return resultobj;
14615 fail:
14616   return NULL;
14617 }
14618
14619
14620 SWIGINTERN PyObject *_wrap_VectorReal___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14621   PyObject *resultobj = 0;
14622   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14623   PySliceObject *arg2 = (PySliceObject *) 0 ;
14624   void *argp1 = 0 ;
14625   int res1 = 0 ;
14626   PyObject * obj0 = 0 ;
14627   PyObject * obj1 = 0 ;
14628   std::vector< double,std::allocator< double > > *result = 0 ;
14629
14630   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___getitem__",&obj0,&obj1)) SWIG_fail;
14631   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14632   if (!SWIG_IsOK(res1)) {
14633     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
14634   }
14635   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14636   {
14637     arg2 = (PySliceObject *) obj1;
14638   }
14639   try {
14640     result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
14641   }
14642   catch(std::out_of_range &_e) {
14643     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14644   }
14645
14646   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14647   return resultobj;
14648 fail:
14649   return NULL;
14650 }
14651
14652
14653 SWIGINTERN PyObject *_wrap_VectorReal___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14654   PyObject *resultobj = 0;
14655   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14656   PySliceObject *arg2 = (PySliceObject *) 0 ;
14657   std::vector< double,std::allocator< double > > *arg3 = 0 ;
14658   void *argp1 = 0 ;
14659   int res1 = 0 ;
14660   int res3 = SWIG_OLDOBJ ;
14661   PyObject * obj0 = 0 ;
14662   PyObject * obj1 = 0 ;
14663   PyObject * obj2 = 0 ;
14664
14665   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
14666   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14667   if (!SWIG_IsOK(res1)) {
14668     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
14669   }
14670   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14671   {
14672     arg2 = (PySliceObject *) obj1;
14673   }
14674   {
14675     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
14676     res3 = swig::asptr(obj2, &ptr);
14677     if (!SWIG_IsOK(res3)) {
14678       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
14679     }
14680     if (!ptr) {
14681       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
14682     }
14683     arg3 = ptr;
14684   }
14685   try {
14686     std_vector_Sl_double_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
14687   }
14688   catch(std::out_of_range &_e) {
14689     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14690   }
14691   catch(std::invalid_argument &_e) {
14692     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14693   }
14694
14695   resultobj = SWIG_Py_Void();
14696   if (SWIG_IsNewObj(res3)) delete arg3;
14697   return resultobj;
14698 fail:
14699   if (SWIG_IsNewObj(res3)) delete arg3;
14700   return NULL;
14701 }
14702
14703
14704 SWIGINTERN PyObject *_wrap_VectorReal___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14705   PyObject *resultobj = 0;
14706   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14707   PySliceObject *arg2 = (PySliceObject *) 0 ;
14708   void *argp1 = 0 ;
14709   int res1 = 0 ;
14710   PyObject * obj0 = 0 ;
14711   PyObject * obj1 = 0 ;
14712
14713   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___delitem__",&obj0,&obj1)) SWIG_fail;
14714   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14715   if (!SWIG_IsOK(res1)) {
14716     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
14717   }
14718   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14719   {
14720     arg2 = (PySliceObject *) obj1;
14721   }
14722   try {
14723     std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
14724   }
14725   catch(std::out_of_range &_e) {
14726     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14727   }
14728
14729   resultobj = SWIG_Py_Void();
14730   return resultobj;
14731 fail:
14732   return NULL;
14733 }
14734
14735
14736 SWIGINTERN PyObject *_wrap_VectorReal___delitem__(PyObject *self, PyObject *args) {
14737   int argc;
14738   PyObject *argv[3];
14739   int ii;
14740
14741   if (!PyTuple_Check(args)) SWIG_fail;
14742   argc = (int)PyObject_Length(args);
14743   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
14744     argv[ii] = PyTuple_GET_ITEM(args,ii);
14745   }
14746   if (argc == 2) {
14747     int _v;
14748     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
14749     _v = SWIG_CheckState(res);
14750     if (_v) {
14751       {
14752         _v = PySlice_Check(argv[1]);
14753       }
14754       if (_v) {
14755         return _wrap_VectorReal___delitem____SWIG_1(self, args);
14756       }
14757     }
14758   }
14759   if (argc == 2) {
14760     int _v;
14761     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
14762     _v = SWIG_CheckState(res);
14763     if (_v) {
14764       {
14765         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
14766         _v = SWIG_CheckState(res);
14767       }
14768       if (_v) {
14769         return _wrap_VectorReal___delitem____SWIG_0(self, args);
14770       }
14771     }
14772   }
14773
14774 fail:
14775   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal___delitem__'.\n"
14776     "  Possible C/C++ prototypes are:\n"
14777     "    __delitem__(std::vector< double > *,std::vector< double >::difference_type)\n"
14778     "    __delitem__(std::vector< double > *,PySliceObject *)\n");
14779   return NULL;
14780 }
14781
14782
14783 SWIGINTERN PyObject *_wrap_VectorReal___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14784   PyObject *resultobj = 0;
14785   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14786   std::vector< double >::difference_type arg2 ;
14787   void *argp1 = 0 ;
14788   int res1 = 0 ;
14789   ptrdiff_t val2 ;
14790   int ecode2 = 0 ;
14791   PyObject * obj0 = 0 ;
14792   PyObject * obj1 = 0 ;
14793   std::vector< double >::value_type *result = 0 ;
14794
14795   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___getitem__",&obj0,&obj1)) SWIG_fail;
14796   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14797   if (!SWIG_IsOK(res1)) {
14798     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'");
14799   }
14800   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14801   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14802   if (!SWIG_IsOK(ecode2)) {
14803     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
14804   }
14805   arg2 = static_cast< std::vector< double >::difference_type >(val2);
14806   try {
14807     result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg____getitem____SWIG_1((std::vector< double > const *)arg1,arg2);
14808   }
14809   catch(std::out_of_range &_e) {
14810     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14811   }
14812
14813   resultobj = SWIG_From_double(static_cast< double >(*result));
14814   return resultobj;
14815 fail:
14816   return NULL;
14817 }
14818
14819
14820 SWIGINTERN PyObject *_wrap_VectorReal___getitem__(PyObject *self, PyObject *args) {
14821   int argc;
14822   PyObject *argv[3];
14823   int ii;
14824
14825   if (!PyTuple_Check(args)) SWIG_fail;
14826   argc = (int)PyObject_Length(args);
14827   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
14828     argv[ii] = PyTuple_GET_ITEM(args,ii);
14829   }
14830   if (argc == 2) {
14831     int _v;
14832     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
14833     _v = SWIG_CheckState(res);
14834     if (_v) {
14835       {
14836         _v = PySlice_Check(argv[1]);
14837       }
14838       if (_v) {
14839         return _wrap_VectorReal___getitem____SWIG_0(self, args);
14840       }
14841     }
14842   }
14843   if (argc == 2) {
14844     int _v;
14845     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
14846     _v = SWIG_CheckState(res);
14847     if (_v) {
14848       {
14849         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
14850         _v = SWIG_CheckState(res);
14851       }
14852       if (_v) {
14853         return _wrap_VectorReal___getitem____SWIG_1(self, args);
14854       }
14855     }
14856   }
14857
14858 fail:
14859   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal___getitem__'.\n"
14860     "  Possible C/C++ prototypes are:\n"
14861     "    __getitem__(std::vector< double > *,PySliceObject *)\n"
14862     "    __getitem__(std::vector< double > const *,std::vector< double >::difference_type)\n");
14863   return NULL;
14864 }
14865
14866
14867 SWIGINTERN PyObject *_wrap_VectorReal___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14868   PyObject *resultobj = 0;
14869   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14870   std::vector< double >::difference_type arg2 ;
14871   std::vector< double >::value_type *arg3 = 0 ;
14872   void *argp1 = 0 ;
14873   int res1 = 0 ;
14874   ptrdiff_t val2 ;
14875   int ecode2 = 0 ;
14876   std::vector< double >::value_type temp3 ;
14877   double val3 ;
14878   int ecode3 = 0 ;
14879   PyObject * obj0 = 0 ;
14880   PyObject * obj1 = 0 ;
14881   PyObject * obj2 = 0 ;
14882
14883   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
14884   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14885   if (!SWIG_IsOK(res1)) {
14886     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
14887   }
14888   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14889   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14890   if (!SWIG_IsOK(ecode2)) {
14891     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
14892   }
14893   arg2 = static_cast< std::vector< double >::difference_type >(val2);
14894   ecode3 = SWIG_AsVal_double(obj2, &val3);
14895   if (!SWIG_IsOK(ecode3)) {
14896     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
14897   }
14898   temp3 = static_cast< std::vector< double >::value_type >(val3);
14899   arg3 = &temp3;
14900   try {
14901     std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2,(double const &)*arg3);
14902   }
14903   catch(std::out_of_range &_e) {
14904     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14905   }
14906
14907   resultobj = SWIG_Py_Void();
14908   return resultobj;
14909 fail:
14910   return NULL;
14911 }
14912
14913
14914 SWIGINTERN PyObject *_wrap_VectorReal___setitem__(PyObject *self, PyObject *args) {
14915   int argc;
14916   PyObject *argv[4];
14917   int ii;
14918
14919   if (!PyTuple_Check(args)) SWIG_fail;
14920   argc = (int)PyObject_Length(args);
14921   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
14922     argv[ii] = PyTuple_GET_ITEM(args,ii);
14923   }
14924   if (argc == 3) {
14925     int _v;
14926     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
14927     _v = SWIG_CheckState(res);
14928     if (_v) {
14929       {
14930         _v = PySlice_Check(argv[1]);
14931       }
14932       if (_v) {
14933         int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
14934         _v = SWIG_CheckState(res);
14935         if (_v) {
14936           return _wrap_VectorReal___setitem____SWIG_0(self, args);
14937         }
14938       }
14939     }
14940   }
14941   if (argc == 3) {
14942     int _v;
14943     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
14944     _v = SWIG_CheckState(res);
14945     if (_v) {
14946       {
14947         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
14948         _v = SWIG_CheckState(res);
14949       }
14950       if (_v) {
14951         {
14952           int res = SWIG_AsVal_double(argv[2], NULL);
14953           _v = SWIG_CheckState(res);
14954         }
14955         if (_v) {
14956           return _wrap_VectorReal___setitem____SWIG_1(self, args);
14957         }
14958       }
14959     }
14960   }
14961
14962 fail:
14963   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal___setitem__'.\n"
14964     "  Possible C/C++ prototypes are:\n"
14965     "    __setitem__(std::vector< double > *,PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
14966     "    __setitem__(std::vector< double > *,std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
14967   return NULL;
14968 }
14969
14970
14971 SWIGINTERN PyObject *_wrap_VectorReal_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14972   PyObject *resultobj = 0;
14973   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
14974   std::vector< double >::value_type *arg2 = 0 ;
14975   void *argp1 = 0 ;
14976   int res1 = 0 ;
14977   std::vector< double >::value_type temp2 ;
14978   double val2 ;
14979   int ecode2 = 0 ;
14980   PyObject * obj0 = 0 ;
14981   PyObject * obj1 = 0 ;
14982
14983   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_append",&obj0,&obj1)) SWIG_fail;
14984   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
14985   if (!SWIG_IsOK(res1)) {
14986     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_append" "', argument " "1"" of type '" "std::vector< double > *""'");
14987   }
14988   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
14989   ecode2 = SWIG_AsVal_double(obj1, &val2);
14990   if (!SWIG_IsOK(ecode2)) {
14991     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
14992   }
14993   temp2 = static_cast< std::vector< double >::value_type >(val2);
14994   arg2 = &temp2;
14995   std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
14996   resultobj = SWIG_Py_Void();
14997   return resultobj;
14998 fail:
14999   return NULL;
15000 }
15001
15002
15003 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15004   PyObject *resultobj = 0;
15005   std::vector< double > *result = 0 ;
15006
15007   if (!PyArg_ParseTuple(args,(char *)":new_VectorReal")) SWIG_fail;
15008   result = (std::vector< double > *)new std::vector< double >();
15009   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
15010   return resultobj;
15011 fail:
15012   return NULL;
15013 }
15014
15015
15016 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15017   PyObject *resultobj = 0;
15018   std::vector< double > *arg1 = 0 ;
15019   int res1 = SWIG_OLDOBJ ;
15020   PyObject * obj0 = 0 ;
15021   std::vector< double > *result = 0 ;
15022
15023   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
15024   {
15025     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
15026     res1 = swig::asptr(obj0, &ptr);
15027     if (!SWIG_IsOK(res1)) {
15028       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double > const &""'");
15029     }
15030     if (!ptr) {
15031       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double > const &""'");
15032     }
15033     arg1 = ptr;
15034   }
15035   result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
15036   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
15037   if (SWIG_IsNewObj(res1)) delete arg1;
15038   return resultobj;
15039 fail:
15040   if (SWIG_IsNewObj(res1)) delete arg1;
15041   return NULL;
15042 }
15043
15044
15045 SWIGINTERN PyObject *_wrap_VectorReal_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15046   PyObject *resultobj = 0;
15047   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15048   void *argp1 = 0 ;
15049   int res1 = 0 ;
15050   PyObject * obj0 = 0 ;
15051   bool result;
15052
15053   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_empty",&obj0)) SWIG_fail;
15054   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15055   if (!SWIG_IsOK(res1)) {
15056     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_empty" "', argument " "1"" of type '" "std::vector< double > const *""'");
15057   }
15058   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15059   result = (bool)((std::vector< double > const *)arg1)->empty();
15060   resultobj = SWIG_From_bool(static_cast< bool >(result));
15061   return resultobj;
15062 fail:
15063   return NULL;
15064 }
15065
15066
15067 SWIGINTERN PyObject *_wrap_VectorReal_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15068   PyObject *resultobj = 0;
15069   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15070   void *argp1 = 0 ;
15071   int res1 = 0 ;
15072   PyObject * obj0 = 0 ;
15073   std::vector< double >::size_type result;
15074
15075   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_size",&obj0)) SWIG_fail;
15076   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15077   if (!SWIG_IsOK(res1)) {
15078     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_size" "', argument " "1"" of type '" "std::vector< double > const *""'");
15079   }
15080   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15081   result = ((std::vector< double > const *)arg1)->size();
15082   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
15083   return resultobj;
15084 fail:
15085   return NULL;
15086 }
15087
15088
15089 SWIGINTERN PyObject *_wrap_VectorReal_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15090   PyObject *resultobj = 0;
15091   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15092   void *argp1 = 0 ;
15093   int res1 = 0 ;
15094   PyObject * obj0 = 0 ;
15095
15096   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_clear",&obj0)) SWIG_fail;
15097   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15098   if (!SWIG_IsOK(res1)) {
15099     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_clear" "', argument " "1"" of type '" "std::vector< double > *""'");
15100   }
15101   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15102   (arg1)->clear();
15103   resultobj = SWIG_Py_Void();
15104   return resultobj;
15105 fail:
15106   return NULL;
15107 }
15108
15109
15110 SWIGINTERN PyObject *_wrap_VectorReal_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15111   PyObject *resultobj = 0;
15112   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15113   std::vector< double > *arg2 = 0 ;
15114   void *argp1 = 0 ;
15115   int res1 = 0 ;
15116   void *argp2 = 0 ;
15117   int res2 = 0 ;
15118   PyObject * obj0 = 0 ;
15119   PyObject * obj1 = 0 ;
15120
15121   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_swap",&obj0,&obj1)) SWIG_fail;
15122   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15123   if (!SWIG_IsOK(res1)) {
15124     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_swap" "', argument " "1"" of type '" "std::vector< double > *""'");
15125   }
15126   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15127   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
15128   if (!SWIG_IsOK(res2)) {
15129     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
15130   }
15131   if (!argp2) {
15132     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
15133   }
15134   arg2 = reinterpret_cast< std::vector< double > * >(argp2);
15135   (arg1)->swap(*arg2);
15136   resultobj = SWIG_Py_Void();
15137   return resultobj;
15138 fail:
15139   return NULL;
15140 }
15141
15142
15143 SWIGINTERN PyObject *_wrap_VectorReal_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15144   PyObject *resultobj = 0;
15145   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15146   void *argp1 = 0 ;
15147   int res1 = 0 ;
15148   PyObject * obj0 = 0 ;
15149   SwigValueWrapper< std::allocator< double > > result;
15150
15151   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_get_allocator",&obj0)) SWIG_fail;
15152   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15153   if (!SWIG_IsOK(res1)) {
15154     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'");
15155   }
15156   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15157   result = ((std::vector< double > const *)arg1)->get_allocator();
15158   resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
15159   return resultobj;
15160 fail:
15161   return NULL;
15162 }
15163
15164
15165 SWIGINTERN PyObject *_wrap_VectorReal_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15166   PyObject *resultobj = 0;
15167   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15168   void *argp1 = 0 ;
15169   int res1 = 0 ;
15170   PyObject * obj0 = 0 ;
15171   std::vector< double >::const_iterator result;
15172
15173   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_begin",&obj0)) SWIG_fail;
15174   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15175   if (!SWIG_IsOK(res1)) {
15176     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_begin" "', argument " "1"" of type '" "std::vector< double > const *""'");
15177   }
15178   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15179   result = ((std::vector< double > const *)arg1)->begin();
15180   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_iterator & >(result)),
15181     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15182   return resultobj;
15183 fail:
15184   return NULL;
15185 }
15186
15187
15188 SWIGINTERN PyObject *_wrap_VectorReal_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15189   PyObject *resultobj = 0;
15190   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15191   void *argp1 = 0 ;
15192   int res1 = 0 ;
15193   PyObject * obj0 = 0 ;
15194   std::vector< double >::const_iterator result;
15195
15196   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_end",&obj0)) SWIG_fail;
15197   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15198   if (!SWIG_IsOK(res1)) {
15199     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_end" "', argument " "1"" of type '" "std::vector< double > const *""'");
15200   }
15201   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15202   result = ((std::vector< double > const *)arg1)->end();
15203   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_iterator & >(result)),
15204     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15205   return resultobj;
15206 fail:
15207   return NULL;
15208 }
15209
15210
15211 SWIGINTERN PyObject *_wrap_VectorReal_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15212   PyObject *resultobj = 0;
15213   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15214   void *argp1 = 0 ;
15215   int res1 = 0 ;
15216   PyObject * obj0 = 0 ;
15217   std::vector< double >::const_reverse_iterator result;
15218
15219   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rbegin",&obj0)) SWIG_fail;
15220   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15221   if (!SWIG_IsOK(res1)) {
15222     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rbegin" "', argument " "1"" of type '" "std::vector< double > const *""'");
15223   }
15224   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15225   result = ((std::vector< double > const *)arg1)->rbegin();
15226   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_reverse_iterator & >(result)),
15227     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15228   return resultobj;
15229 fail:
15230   return NULL;
15231 }
15232
15233
15234 SWIGINTERN PyObject *_wrap_VectorReal_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15235   PyObject *resultobj = 0;
15236   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15237   void *argp1 = 0 ;
15238   int res1 = 0 ;
15239   PyObject * obj0 = 0 ;
15240   std::vector< double >::const_reverse_iterator result;
15241
15242   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rend",&obj0)) SWIG_fail;
15243   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15244   if (!SWIG_IsOK(res1)) {
15245     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rend" "', argument " "1"" of type '" "std::vector< double > const *""'");
15246   }
15247   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15248   result = ((std::vector< double > const *)arg1)->rend();
15249   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::const_reverse_iterator & >(result)),
15250     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15251   return resultobj;
15252 fail:
15253   return NULL;
15254 }
15255
15256
15257 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15258   PyObject *resultobj = 0;
15259   std::vector< double >::size_type arg1 ;
15260   size_t val1 ;
15261   int ecode1 = 0 ;
15262   PyObject * obj0 = 0 ;
15263   std::vector< double > *result = 0 ;
15264
15265   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
15266   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
15267   if (!SWIG_IsOK(ecode1)) {
15268     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
15269   }
15270   arg1 = static_cast< std::vector< double >::size_type >(val1);
15271   result = (std::vector< double > *)new std::vector< double >(arg1);
15272   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
15273   return resultobj;
15274 fail:
15275   return NULL;
15276 }
15277
15278
15279 SWIGINTERN PyObject *_wrap_VectorReal_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15280   PyObject *resultobj = 0;
15281   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15282   void *argp1 = 0 ;
15283   int res1 = 0 ;
15284   PyObject * obj0 = 0 ;
15285
15286   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop_back",&obj0)) SWIG_fail;
15287   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15288   if (!SWIG_IsOK(res1)) {
15289     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'");
15290   }
15291   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15292   (arg1)->pop_back();
15293   resultobj = SWIG_Py_Void();
15294   return resultobj;
15295 fail:
15296   return NULL;
15297 }
15298
15299
15300 SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15301   PyObject *resultobj = 0;
15302   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15303   std::vector< double >::size_type arg2 ;
15304   void *argp1 = 0 ;
15305   int res1 = 0 ;
15306   size_t val2 ;
15307   int ecode2 = 0 ;
15308   PyObject * obj0 = 0 ;
15309   PyObject * obj1 = 0 ;
15310
15311   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_resize",&obj0,&obj1)) SWIG_fail;
15312   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15313   if (!SWIG_IsOK(res1)) {
15314     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
15315   }
15316   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15317   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15318   if (!SWIG_IsOK(ecode2)) {
15319     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
15320   }
15321   arg2 = static_cast< std::vector< double >::size_type >(val2);
15322   (arg1)->resize(arg2);
15323   resultobj = SWIG_Py_Void();
15324   return resultobj;
15325 fail:
15326   return NULL;
15327 }
15328
15329
15330 SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15331   PyObject *resultobj = 0;
15332   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15333   std::vector< double >::iterator arg2 ;
15334   void *argp1 = 0 ;
15335   int res1 = 0 ;
15336   swig::SwigPyIterator *iter2 = 0 ;
15337   int res2 ;
15338   PyObject * obj0 = 0 ;
15339   PyObject * obj1 = 0 ;
15340   std::vector< double >::iterator result;
15341
15342   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_erase",&obj0,&obj1)) SWIG_fail;
15343   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15344   if (!SWIG_IsOK(res1)) {
15345     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
15346   }
15347   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15348   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
15349   if (!SWIG_IsOK(res2) || !iter2) {
15350     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
15351   } else {
15352     swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
15353     if (iter_t) {
15354       arg2 = iter_t->get_current();
15355     } else {
15356       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
15357     }
15358   }
15359   result = (arg1)->erase(arg2);
15360   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
15361     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15362   return resultobj;
15363 fail:
15364   return NULL;
15365 }
15366
15367
15368 SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15369   PyObject *resultobj = 0;
15370   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15371   std::vector< double >::iterator arg2 ;
15372   std::vector< double >::iterator arg3 ;
15373   void *argp1 = 0 ;
15374   int res1 = 0 ;
15375   swig::SwigPyIterator *iter2 = 0 ;
15376   int res2 ;
15377   swig::SwigPyIterator *iter3 = 0 ;
15378   int res3 ;
15379   PyObject * obj0 = 0 ;
15380   PyObject * obj1 = 0 ;
15381   PyObject * obj2 = 0 ;
15382   std::vector< double >::iterator result;
15383
15384   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_erase",&obj0,&obj1,&obj2)) SWIG_fail;
15385   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15386   if (!SWIG_IsOK(res1)) {
15387     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
15388   }
15389   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15390   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
15391   if (!SWIG_IsOK(res2) || !iter2) {
15392     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
15393   } else {
15394     swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
15395     if (iter_t) {
15396       arg2 = iter_t->get_current();
15397     } else {
15398       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
15399     }
15400   }
15401   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
15402   if (!SWIG_IsOK(res3) || !iter3) {
15403     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
15404   } else {
15405     swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter3);
15406     if (iter_t) {
15407       arg3 = iter_t->get_current();
15408     } else {
15409       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
15410     }
15411   }
15412   result = (arg1)->erase(arg2,arg3);
15413   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
15414     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15415   return resultobj;
15416 fail:
15417   return NULL;
15418 }
15419
15420
15421 SWIGINTERN PyObject *_wrap_VectorReal_erase(PyObject *self, PyObject *args) {
15422   int argc;
15423   PyObject *argv[4];
15424   int ii;
15425
15426   if (!PyTuple_Check(args)) SWIG_fail;
15427   argc = (int)PyObject_Length(args);
15428   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
15429     argv[ii] = PyTuple_GET_ITEM(args,ii);
15430   }
15431   if (argc == 2) {
15432     int _v;
15433     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
15434     _v = SWIG_CheckState(res);
15435     if (_v) {
15436       swig::SwigPyIterator *iter = 0;
15437       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
15438       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
15439       if (_v) {
15440         return _wrap_VectorReal_erase__SWIG_0(self, args);
15441       }
15442     }
15443   }
15444   if (argc == 3) {
15445     int _v;
15446     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
15447     _v = SWIG_CheckState(res);
15448     if (_v) {
15449       swig::SwigPyIterator *iter = 0;
15450       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
15451       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
15452       if (_v) {
15453         swig::SwigPyIterator *iter = 0;
15454         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
15455         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
15456         if (_v) {
15457           return _wrap_VectorReal_erase__SWIG_1(self, args);
15458         }
15459       }
15460     }
15461   }
15462
15463 fail:
15464   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_erase'.\n"
15465     "  Possible C/C++ prototypes are:\n"
15466     "    erase(std::vector< double > *,std::vector< double >::iterator)\n"
15467     "    erase(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::iterator)\n");
15468   return NULL;
15469 }
15470
15471
15472 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15473   PyObject *resultobj = 0;
15474   std::vector< double >::size_type arg1 ;
15475   std::vector< double >::value_type *arg2 = 0 ;
15476   size_t val1 ;
15477   int ecode1 = 0 ;
15478   std::vector< double >::value_type temp2 ;
15479   double val2 ;
15480   int ecode2 = 0 ;
15481   PyObject * obj0 = 0 ;
15482   PyObject * obj1 = 0 ;
15483   std::vector< double > *result = 0 ;
15484
15485   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorReal",&obj0,&obj1)) SWIG_fail;
15486   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
15487   if (!SWIG_IsOK(ecode1)) {
15488     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
15489   }
15490   arg1 = static_cast< std::vector< double >::size_type >(val1);
15491   ecode2 = SWIG_AsVal_double(obj1, &val2);
15492   if (!SWIG_IsOK(ecode2)) {
15493     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorReal" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
15494   }
15495   temp2 = static_cast< std::vector< double >::value_type >(val2);
15496   arg2 = &temp2;
15497   result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2);
15498   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
15499   return resultobj;
15500 fail:
15501   return NULL;
15502 }
15503
15504
15505 SWIGINTERN PyObject *_wrap_new_VectorReal(PyObject *self, PyObject *args) {
15506   int argc;
15507   PyObject *argv[3];
15508   int ii;
15509
15510   if (!PyTuple_Check(args)) SWIG_fail;
15511   argc = (int)PyObject_Length(args);
15512   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
15513     argv[ii] = PyTuple_GET_ITEM(args,ii);
15514   }
15515   if (argc == 0) {
15516     return _wrap_new_VectorReal__SWIG_0(self, args);
15517   }
15518   if (argc == 1) {
15519     int _v;
15520     {
15521       int res = SWIG_AsVal_size_t(argv[0], NULL);
15522       _v = SWIG_CheckState(res);
15523     }
15524     if (_v) {
15525       return _wrap_new_VectorReal__SWIG_2(self, args);
15526     }
15527   }
15528   if (argc == 1) {
15529     int _v;
15530     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
15531     _v = SWIG_CheckState(res);
15532     if (_v) {
15533       return _wrap_new_VectorReal__SWIG_1(self, args);
15534     }
15535   }
15536   if (argc == 2) {
15537     int _v;
15538     {
15539       int res = SWIG_AsVal_size_t(argv[0], NULL);
15540       _v = SWIG_CheckState(res);
15541     }
15542     if (_v) {
15543       {
15544         int res = SWIG_AsVal_double(argv[1], NULL);
15545         _v = SWIG_CheckState(res);
15546       }
15547       if (_v) {
15548         return _wrap_new_VectorReal__SWIG_3(self, args);
15549       }
15550     }
15551   }
15552
15553 fail:
15554   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorReal'.\n"
15555     "  Possible C/C++ prototypes are:\n"
15556     "    std::vector< double >()\n"
15557     "    std::vector< double >(std::vector< double > const &)\n"
15558     "    std::vector< double >(std::vector< double >::size_type)\n"
15559     "    std::vector< double >(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
15560   return NULL;
15561 }
15562
15563
15564 SWIGINTERN PyObject *_wrap_VectorReal_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15565   PyObject *resultobj = 0;
15566   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15567   std::vector< double >::value_type *arg2 = 0 ;
15568   void *argp1 = 0 ;
15569   int res1 = 0 ;
15570   std::vector< double >::value_type temp2 ;
15571   double val2 ;
15572   int ecode2 = 0 ;
15573   PyObject * obj0 = 0 ;
15574   PyObject * obj1 = 0 ;
15575
15576   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_push_back",&obj0,&obj1)) SWIG_fail;
15577   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15578   if (!SWIG_IsOK(res1)) {
15579     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_push_back" "', argument " "1"" of type '" "std::vector< double > *""'");
15580   }
15581   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15582   ecode2 = SWIG_AsVal_double(obj1, &val2);
15583   if (!SWIG_IsOK(ecode2)) {
15584     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
15585   }
15586   temp2 = static_cast< std::vector< double >::value_type >(val2);
15587   arg2 = &temp2;
15588   (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
15589   resultobj = SWIG_Py_Void();
15590   return resultobj;
15591 fail:
15592   return NULL;
15593 }
15594
15595
15596 SWIGINTERN PyObject *_wrap_VectorReal_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15597   PyObject *resultobj = 0;
15598   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15599   void *argp1 = 0 ;
15600   int res1 = 0 ;
15601   PyObject * obj0 = 0 ;
15602   std::vector< double >::value_type *result = 0 ;
15603
15604   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_front",&obj0)) SWIG_fail;
15605   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15606   if (!SWIG_IsOK(res1)) {
15607     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_front" "', argument " "1"" of type '" "std::vector< double > const *""'");
15608   }
15609   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15610   result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->front();
15611   resultobj = SWIG_From_double(static_cast< double >(*result));
15612   return resultobj;
15613 fail:
15614   return NULL;
15615 }
15616
15617
15618 SWIGINTERN PyObject *_wrap_VectorReal_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15619   PyObject *resultobj = 0;
15620   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15621   void *argp1 = 0 ;
15622   int res1 = 0 ;
15623   PyObject * obj0 = 0 ;
15624   std::vector< double >::value_type *result = 0 ;
15625
15626   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_back",&obj0)) SWIG_fail;
15627   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15628   if (!SWIG_IsOK(res1)) {
15629     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_back" "', argument " "1"" of type '" "std::vector< double > const *""'");
15630   }
15631   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15632   result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->back();
15633   resultobj = SWIG_From_double(static_cast< double >(*result));
15634   return resultobj;
15635 fail:
15636   return NULL;
15637 }
15638
15639
15640 SWIGINTERN PyObject *_wrap_VectorReal_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15641   PyObject *resultobj = 0;
15642   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15643   std::vector< double >::size_type arg2 ;
15644   std::vector< double >::value_type *arg3 = 0 ;
15645   void *argp1 = 0 ;
15646   int res1 = 0 ;
15647   size_t val2 ;
15648   int ecode2 = 0 ;
15649   std::vector< double >::value_type temp3 ;
15650   double val3 ;
15651   int ecode3 = 0 ;
15652   PyObject * obj0 = 0 ;
15653   PyObject * obj1 = 0 ;
15654   PyObject * obj2 = 0 ;
15655
15656   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_assign",&obj0,&obj1,&obj2)) SWIG_fail;
15657   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15658   if (!SWIG_IsOK(res1)) {
15659     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_assign" "', argument " "1"" of type '" "std::vector< double > *""'");
15660   }
15661   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15662   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15663   if (!SWIG_IsOK(ecode2)) {
15664     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
15665   }
15666   arg2 = static_cast< std::vector< double >::size_type >(val2);
15667   ecode3 = SWIG_AsVal_double(obj2, &val3);
15668   if (!SWIG_IsOK(ecode3)) {
15669     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
15670   }
15671   temp3 = static_cast< std::vector< double >::value_type >(val3);
15672   arg3 = &temp3;
15673   (arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3);
15674   resultobj = SWIG_Py_Void();
15675   return resultobj;
15676 fail:
15677   return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15682   PyObject *resultobj = 0;
15683   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15684   std::vector< double >::size_type arg2 ;
15685   std::vector< double >::value_type *arg3 = 0 ;
15686   void *argp1 = 0 ;
15687   int res1 = 0 ;
15688   size_t val2 ;
15689   int ecode2 = 0 ;
15690   std::vector< double >::value_type temp3 ;
15691   double val3 ;
15692   int ecode3 = 0 ;
15693   PyObject * obj0 = 0 ;
15694   PyObject * obj1 = 0 ;
15695   PyObject * obj2 = 0 ;
15696
15697   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_resize",&obj0,&obj1,&obj2)) SWIG_fail;
15698   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15699   if (!SWIG_IsOK(res1)) {
15700     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
15701   }
15702   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15703   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15704   if (!SWIG_IsOK(ecode2)) {
15705     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
15706   }
15707   arg2 = static_cast< std::vector< double >::size_type >(val2);
15708   ecode3 = SWIG_AsVal_double(obj2, &val3);
15709   if (!SWIG_IsOK(ecode3)) {
15710     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
15711   }
15712   temp3 = static_cast< std::vector< double >::value_type >(val3);
15713   arg3 = &temp3;
15714   (arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3);
15715   resultobj = SWIG_Py_Void();
15716   return resultobj;
15717 fail:
15718   return NULL;
15719 }
15720
15721
15722 SWIGINTERN PyObject *_wrap_VectorReal_resize(PyObject *self, PyObject *args) {
15723   int argc;
15724   PyObject *argv[4];
15725   int ii;
15726
15727   if (!PyTuple_Check(args)) SWIG_fail;
15728   argc = (int)PyObject_Length(args);
15729   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
15730     argv[ii] = PyTuple_GET_ITEM(args,ii);
15731   }
15732   if (argc == 2) {
15733     int _v;
15734     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
15735     _v = SWIG_CheckState(res);
15736     if (_v) {
15737       {
15738         int res = SWIG_AsVal_size_t(argv[1], NULL);
15739         _v = SWIG_CheckState(res);
15740       }
15741       if (_v) {
15742         return _wrap_VectorReal_resize__SWIG_0(self, args);
15743       }
15744     }
15745   }
15746   if (argc == 3) {
15747     int _v;
15748     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
15749     _v = SWIG_CheckState(res);
15750     if (_v) {
15751       {
15752         int res = SWIG_AsVal_size_t(argv[1], NULL);
15753         _v = SWIG_CheckState(res);
15754       }
15755       if (_v) {
15756         {
15757           int res = SWIG_AsVal_double(argv[2], NULL);
15758           _v = SWIG_CheckState(res);
15759         }
15760         if (_v) {
15761           return _wrap_VectorReal_resize__SWIG_1(self, args);
15762         }
15763       }
15764     }
15765   }
15766
15767 fail:
15768   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_resize'.\n"
15769     "  Possible C/C++ prototypes are:\n"
15770     "    resize(std::vector< double > *,std::vector< double >::size_type)\n"
15771     "    resize(std::vector< double > *,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
15772   return NULL;
15773 }
15774
15775
15776 SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15777   PyObject *resultobj = 0;
15778   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15779   std::vector< double >::iterator arg2 ;
15780   std::vector< double >::value_type *arg3 = 0 ;
15781   void *argp1 = 0 ;
15782   int res1 = 0 ;
15783   swig::SwigPyIterator *iter2 = 0 ;
15784   int res2 ;
15785   std::vector< double >::value_type temp3 ;
15786   double val3 ;
15787   int ecode3 = 0 ;
15788   PyObject * obj0 = 0 ;
15789   PyObject * obj1 = 0 ;
15790   PyObject * obj2 = 0 ;
15791   std::vector< double >::iterator result;
15792
15793   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_insert",&obj0,&obj1,&obj2)) SWIG_fail;
15794   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15795   if (!SWIG_IsOK(res1)) {
15796     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
15797   }
15798   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15799   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
15800   if (!SWIG_IsOK(res2) || !iter2) {
15801     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
15802   } else {
15803     swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
15804     if (iter_t) {
15805       arg2 = iter_t->get_current();
15806     } else {
15807       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
15808     }
15809   }
15810   ecode3 = SWIG_AsVal_double(obj2, &val3);
15811   if (!SWIG_IsOK(ecode3)) {
15812     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
15813   }
15814   temp3 = static_cast< std::vector< double >::value_type >(val3);
15815   arg3 = &temp3;
15816   result = (arg1)->insert(arg2,(std::vector< double >::value_type const &)*arg3);
15817   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
15818     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15819   return resultobj;
15820 fail:
15821   return NULL;
15822 }
15823
15824
15825 SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15826   PyObject *resultobj = 0;
15827   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15828   std::vector< double >::iterator arg2 ;
15829   std::vector< double >::size_type arg3 ;
15830   std::vector< double >::value_type *arg4 = 0 ;
15831   void *argp1 = 0 ;
15832   int res1 = 0 ;
15833   swig::SwigPyIterator *iter2 = 0 ;
15834   int res2 ;
15835   size_t val3 ;
15836   int ecode3 = 0 ;
15837   std::vector< double >::value_type temp4 ;
15838   double val4 ;
15839   int ecode4 = 0 ;
15840   PyObject * obj0 = 0 ;
15841   PyObject * obj1 = 0 ;
15842   PyObject * obj2 = 0 ;
15843   PyObject * obj3 = 0 ;
15844
15845   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15846   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15847   if (!SWIG_IsOK(res1)) {
15848     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
15849   }
15850   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15851   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
15852   if (!SWIG_IsOK(res2) || !iter2) {
15853     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
15854   } else {
15855     swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
15856     if (iter_t) {
15857       arg2 = iter_t->get_current();
15858     } else {
15859       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
15860     }
15861   }
15862   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
15863   if (!SWIG_IsOK(ecode3)) {
15864     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
15865   }
15866   arg3 = static_cast< std::vector< double >::size_type >(val3);
15867   ecode4 = SWIG_AsVal_double(obj3, &val4);
15868   if (!SWIG_IsOK(ecode4)) {
15869     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorReal_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
15870   }
15871   temp4 = static_cast< std::vector< double >::value_type >(val4);
15872   arg4 = &temp4;
15873   (arg1)->insert(arg2,arg3,(std::vector< double >::value_type const &)*arg4);
15874   resultobj = SWIG_Py_Void();
15875   return resultobj;
15876 fail:
15877   return NULL;
15878 }
15879
15880
15881 SWIGINTERN PyObject *_wrap_VectorReal_insert(PyObject *self, PyObject *args) {
15882   int argc;
15883   PyObject *argv[5];
15884   int ii;
15885
15886   if (!PyTuple_Check(args)) SWIG_fail;
15887   argc = (int)PyObject_Length(args);
15888   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
15889     argv[ii] = PyTuple_GET_ITEM(args,ii);
15890   }
15891   if (argc == 3) {
15892     int _v;
15893     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
15894     _v = SWIG_CheckState(res);
15895     if (_v) {
15896       swig::SwigPyIterator *iter = 0;
15897       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
15898       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
15899       if (_v) {
15900         {
15901           int res = SWIG_AsVal_double(argv[2], NULL);
15902           _v = SWIG_CheckState(res);
15903         }
15904         if (_v) {
15905           return _wrap_VectorReal_insert__SWIG_0(self, args);
15906         }
15907       }
15908     }
15909   }
15910   if (argc == 4) {
15911     int _v;
15912     int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
15913     _v = SWIG_CheckState(res);
15914     if (_v) {
15915       swig::SwigPyIterator *iter = 0;
15916       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
15917       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
15918       if (_v) {
15919         {
15920           int res = SWIG_AsVal_size_t(argv[2], NULL);
15921           _v = SWIG_CheckState(res);
15922         }
15923         if (_v) {
15924           {
15925             int res = SWIG_AsVal_double(argv[3], NULL);
15926             _v = SWIG_CheckState(res);
15927           }
15928           if (_v) {
15929             return _wrap_VectorReal_insert__SWIG_1(self, args);
15930           }
15931         }
15932       }
15933     }
15934   }
15935
15936 fail:
15937   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_insert'.\n"
15938     "  Possible C/C++ prototypes are:\n"
15939     "    insert(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
15940     "    insert(std::vector< double > *,std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
15941   return NULL;
15942 }
15943
15944
15945 SWIGINTERN PyObject *_wrap_VectorReal_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15946   PyObject *resultobj = 0;
15947   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15948   std::vector< double >::size_type arg2 ;
15949   void *argp1 = 0 ;
15950   int res1 = 0 ;
15951   size_t val2 ;
15952   int ecode2 = 0 ;
15953   PyObject * obj0 = 0 ;
15954   PyObject * obj1 = 0 ;
15955
15956   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_reserve",&obj0,&obj1)) SWIG_fail;
15957   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15958   if (!SWIG_IsOK(res1)) {
15959     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_reserve" "', argument " "1"" of type '" "std::vector< double > *""'");
15960   }
15961   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15962   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15963   if (!SWIG_IsOK(ecode2)) {
15964     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
15965   }
15966   arg2 = static_cast< std::vector< double >::size_type >(val2);
15967   (arg1)->reserve(arg2);
15968   resultobj = SWIG_Py_Void();
15969   return resultobj;
15970 fail:
15971   return NULL;
15972 }
15973
15974
15975 SWIGINTERN PyObject *_wrap_VectorReal_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15976   PyObject *resultobj = 0;
15977   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
15978   void *argp1 = 0 ;
15979   int res1 = 0 ;
15980   PyObject * obj0 = 0 ;
15981   std::vector< double >::size_type result;
15982
15983   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_capacity",&obj0)) SWIG_fail;
15984   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
15985   if (!SWIG_IsOK(res1)) {
15986     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'");
15987   }
15988   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
15989   result = ((std::vector< double > const *)arg1)->capacity();
15990   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
15991   return resultobj;
15992 fail:
15993   return NULL;
15994 }
15995
15996
15997 SWIGINTERN PyObject *_wrap_delete_VectorReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15998   PyObject *resultobj = 0;
15999   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16000   void *argp1 = 0 ;
16001   int res1 = 0 ;
16002   PyObject * obj0 = 0 ;
16003
16004   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorReal",&obj0)) SWIG_fail;
16005   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN |  0 );
16006   if (!SWIG_IsOK(res1)) {
16007     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorReal" "', argument " "1"" of type '" "std::vector< double > *""'");
16008   }
16009   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16010   delete arg1;
16011   resultobj = SWIG_Py_Void();
16012   return resultobj;
16013 fail:
16014   return NULL;
16015 }
16016
16017
16018 SWIGINTERN PyObject *VectorReal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16019   PyObject *obj;
16020   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
16021   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_NewClientData(obj));
16022   return SWIG_Py_Void();
16023 }
16024
16025 SWIGINTERN PyObject *_wrap_VectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16026   PyObject *resultobj = 0;
16027   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16028   PyObject **arg2 = (PyObject **) 0 ;
16029   void *argp1 = 0 ;
16030   int res1 = 0 ;
16031   PyObject * obj0 = 0 ;
16032   swig::SwigPyIterator *result = 0 ;
16033
16034   arg2 = &obj0;
16035   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_iterator",&obj0)) SWIG_fail;
16036   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16037   if (!SWIG_IsOK(res1)) {
16038     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_iterator" "', argument " "1"" of type '" "std::vector< int > *""'");
16039   }
16040   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16041   result = (swig::SwigPyIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
16042   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
16043   return resultobj;
16044 fail:
16045   return NULL;
16046 }
16047
16048
16049 SWIGINTERN PyObject *_wrap_VectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16050   PyObject *resultobj = 0;
16051   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16052   void *argp1 = 0 ;
16053   int res1 = 0 ;
16054   PyObject * obj0 = 0 ;
16055   bool result;
16056
16057   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___nonzero__",&obj0)) SWIG_fail;
16058   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16059   if (!SWIG_IsOK(res1)) {
16060     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'");
16061   }
16062   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16063   result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1);
16064   resultobj = SWIG_From_bool(static_cast< bool >(result));
16065   return resultobj;
16066 fail:
16067   return NULL;
16068 }
16069
16070
16071 SWIGINTERN PyObject *_wrap_VectorInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16072   PyObject *resultobj = 0;
16073   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16074   void *argp1 = 0 ;
16075   int res1 = 0 ;
16076   PyObject * obj0 = 0 ;
16077   bool result;
16078
16079   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___bool__",&obj0)) SWIG_fail;
16080   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16081   if (!SWIG_IsOK(res1)) {
16082     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'");
16083   }
16084   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16085   result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< int > const *)arg1);
16086   resultobj = SWIG_From_bool(static_cast< bool >(result));
16087   return resultobj;
16088 fail:
16089   return NULL;
16090 }
16091
16092
16093 SWIGINTERN PyObject *_wrap_VectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16094   PyObject *resultobj = 0;
16095   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16096   void *argp1 = 0 ;
16097   int res1 = 0 ;
16098   PyObject * obj0 = 0 ;
16099   std::vector< int >::size_type result;
16100
16101   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___len__",&obj0)) SWIG_fail;
16102   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16103   if (!SWIG_IsOK(res1)) {
16104     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___len__" "', argument " "1"" of type '" "std::vector< int > const *""'");
16105   }
16106   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16107   result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1);
16108   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16109   return resultobj;
16110 fail:
16111   return NULL;
16112 }
16113
16114
16115 SWIGINTERN PyObject *_wrap_VectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16116   PyObject *resultobj = 0;
16117   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16118   void *argp1 = 0 ;
16119   int res1 = 0 ;
16120   PyObject * obj0 = 0 ;
16121   std::vector< int >::value_type result;
16122
16123   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop",&obj0)) SWIG_fail;
16124   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16125   if (!SWIG_IsOK(res1)) {
16126     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop" "', argument " "1"" of type '" "std::vector< int > *""'");
16127   }
16128   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16129   try {
16130     result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
16131   }
16132   catch(std::out_of_range &_e) {
16133     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16134   }
16135
16136   resultobj = SWIG_From_int(static_cast< int >(result));
16137   return resultobj;
16138 fail:
16139   return NULL;
16140 }
16141
16142
16143 SWIGINTERN PyObject *_wrap_VectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16144   PyObject *resultobj = 0;
16145   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16146   std::vector< int >::difference_type arg2 ;
16147   std::vector< int >::difference_type arg3 ;
16148   void *argp1 = 0 ;
16149   int res1 = 0 ;
16150   ptrdiff_t val2 ;
16151   int ecode2 = 0 ;
16152   ptrdiff_t val3 ;
16153   int ecode3 = 0 ;
16154   PyObject * obj0 = 0 ;
16155   PyObject * obj1 = 0 ;
16156   PyObject * obj2 = 0 ;
16157   std::vector< int,std::allocator< int > > *result = 0 ;
16158
16159   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
16160   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16161   if (!SWIG_IsOK(res1)) {
16162     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
16163   }
16164   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16165   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16166   if (!SWIG_IsOK(ecode2)) {
16167     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
16168   }
16169   arg2 = static_cast< std::vector< int >::difference_type >(val2);
16170   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
16171   if (!SWIG_IsOK(ecode3)) {
16172     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
16173   }
16174   arg3 = static_cast< std::vector< int >::difference_type >(val3);
16175   try {
16176     result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
16177   }
16178   catch(std::out_of_range &_e) {
16179     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16180   }
16181
16182   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN |  0 );
16183   return resultobj;
16184 fail:
16185   return NULL;
16186 }
16187
16188
16189 SWIGINTERN PyObject *_wrap_VectorInt___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16190   PyObject *resultobj = 0;
16191   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16192   std::vector< int >::difference_type arg2 ;
16193   std::vector< int >::difference_type arg3 ;
16194   std::vector< int,std::allocator< int > > *arg4 = 0 ;
16195   void *argp1 = 0 ;
16196   int res1 = 0 ;
16197   ptrdiff_t val2 ;
16198   int ecode2 = 0 ;
16199   ptrdiff_t val3 ;
16200   int ecode3 = 0 ;
16201   int res4 = SWIG_OLDOBJ ;
16202   PyObject * obj0 = 0 ;
16203   PyObject * obj1 = 0 ;
16204   PyObject * obj2 = 0 ;
16205   PyObject * obj3 = 0 ;
16206
16207   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16208   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16209   if (!SWIG_IsOK(res1)) {
16210     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
16211   }
16212   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16213   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16214   if (!SWIG_IsOK(ecode2)) {
16215     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
16216   }
16217   arg2 = static_cast< std::vector< int >::difference_type >(val2);
16218   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
16219   if (!SWIG_IsOK(ecode3)) {
16220     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
16221   }
16222   arg3 = static_cast< std::vector< int >::difference_type >(val3);
16223   {
16224     std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
16225     res4 = swig::asptr(obj3, &ptr);
16226     if (!SWIG_IsOK(res4)) {
16227       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
16228     }
16229     if (!ptr) {
16230       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
16231     }
16232     arg4 = ptr;
16233   }
16234   try {
16235     std_vector_Sl_int_Sg____setslice__(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
16236   }
16237   catch(std::out_of_range &_e) {
16238     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16239   }
16240   catch(std::invalid_argument &_e) {
16241     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16242   }
16243
16244   resultobj = SWIG_Py_Void();
16245   if (SWIG_IsNewObj(res4)) delete arg4;
16246   return resultobj;
16247 fail:
16248   if (SWIG_IsNewObj(res4)) delete arg4;
16249   return NULL;
16250 }
16251
16252
16253 SWIGINTERN PyObject *_wrap_VectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16254   PyObject *resultobj = 0;
16255   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16256   std::vector< int >::difference_type arg2 ;
16257   std::vector< int >::difference_type arg3 ;
16258   void *argp1 = 0 ;
16259   int res1 = 0 ;
16260   ptrdiff_t val2 ;
16261   int ecode2 = 0 ;
16262   ptrdiff_t val3 ;
16263   int ecode3 = 0 ;
16264   PyObject * obj0 = 0 ;
16265   PyObject * obj1 = 0 ;
16266   PyObject * obj2 = 0 ;
16267
16268   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
16269   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16270   if (!SWIG_IsOK(res1)) {
16271     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
16272   }
16273   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16274   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16275   if (!SWIG_IsOK(ecode2)) {
16276     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
16277   }
16278   arg2 = static_cast< std::vector< int >::difference_type >(val2);
16279   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
16280   if (!SWIG_IsOK(ecode3)) {
16281     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
16282   }
16283   arg3 = static_cast< std::vector< int >::difference_type >(val3);
16284   try {
16285     std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
16286   }
16287   catch(std::out_of_range &_e) {
16288     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16289   }
16290
16291   resultobj = SWIG_Py_Void();
16292   return resultobj;
16293 fail:
16294   return NULL;
16295 }
16296
16297
16298 SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16299   PyObject *resultobj = 0;
16300   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16301   std::vector< int >::difference_type arg2 ;
16302   void *argp1 = 0 ;
16303   int res1 = 0 ;
16304   ptrdiff_t val2 ;
16305   int ecode2 = 0 ;
16306   PyObject * obj0 = 0 ;
16307   PyObject * obj1 = 0 ;
16308
16309   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
16310   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16311   if (!SWIG_IsOK(res1)) {
16312     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
16313   }
16314   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16315   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16316   if (!SWIG_IsOK(ecode2)) {
16317     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
16318   }
16319   arg2 = static_cast< std::vector< int >::difference_type >(val2);
16320   try {
16321     std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,arg2);
16322   }
16323   catch(std::out_of_range &_e) {
16324     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16325   }
16326
16327   resultobj = SWIG_Py_Void();
16328   return resultobj;
16329 fail:
16330   return NULL;
16331 }
16332
16333
16334 SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16335   PyObject *resultobj = 0;
16336   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16337   PySliceObject *arg2 = (PySliceObject *) 0 ;
16338   void *argp1 = 0 ;
16339   int res1 = 0 ;
16340   PyObject * obj0 = 0 ;
16341   PyObject * obj1 = 0 ;
16342   std::vector< int,std::allocator< int > > *result = 0 ;
16343
16344   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
16345   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16346   if (!SWIG_IsOK(res1)) {
16347     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
16348   }
16349   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16350   {
16351     arg2 = (PySliceObject *) obj1;
16352   }
16353   try {
16354     result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
16355   }
16356   catch(std::out_of_range &_e) {
16357     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16358   }
16359
16360   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16361   return resultobj;
16362 fail:
16363   return NULL;
16364 }
16365
16366
16367 SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16368   PyObject *resultobj = 0;
16369   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16370   PySliceObject *arg2 = (PySliceObject *) 0 ;
16371   std::vector< int,std::allocator< int > > *arg3 = 0 ;
16372   void *argp1 = 0 ;
16373   int res1 = 0 ;
16374   int res3 = SWIG_OLDOBJ ;
16375   PyObject * obj0 = 0 ;
16376   PyObject * obj1 = 0 ;
16377   PyObject * obj2 = 0 ;
16378
16379   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
16380   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16381   if (!SWIG_IsOK(res1)) {
16382     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
16383   }
16384   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16385   {
16386     arg2 = (PySliceObject *) obj1;
16387   }
16388   {
16389     std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
16390     res3 = swig::asptr(obj2, &ptr);
16391     if (!SWIG_IsOK(res3)) {
16392       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'");
16393     }
16394     if (!ptr) {
16395       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'");
16396     }
16397     arg3 = ptr;
16398   }
16399   try {
16400     std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
16401   }
16402   catch(std::out_of_range &_e) {
16403     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16404   }
16405   catch(std::invalid_argument &_e) {
16406     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16407   }
16408
16409   resultobj = SWIG_Py_Void();
16410   if (SWIG_IsNewObj(res3)) delete arg3;
16411   return resultobj;
16412 fail:
16413   if (SWIG_IsNewObj(res3)) delete arg3;
16414   return NULL;
16415 }
16416
16417
16418 SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16419   PyObject *resultobj = 0;
16420   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16421   PySliceObject *arg2 = (PySliceObject *) 0 ;
16422   void *argp1 = 0 ;
16423   int res1 = 0 ;
16424   PyObject * obj0 = 0 ;
16425   PyObject * obj1 = 0 ;
16426
16427   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
16428   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16429   if (!SWIG_IsOK(res1)) {
16430     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
16431   }
16432   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16433   {
16434     arg2 = (PySliceObject *) obj1;
16435   }
16436   try {
16437     std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
16438   }
16439   catch(std::out_of_range &_e) {
16440     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16441   }
16442
16443   resultobj = SWIG_Py_Void();
16444   return resultobj;
16445 fail:
16446   return NULL;
16447 }
16448
16449
16450 SWIGINTERN PyObject *_wrap_VectorInt___delitem__(PyObject *self, PyObject *args) {
16451   int argc;
16452   PyObject *argv[3];
16453   int ii;
16454
16455   if (!PyTuple_Check(args)) SWIG_fail;
16456   argc = (int)PyObject_Length(args);
16457   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
16458     argv[ii] = PyTuple_GET_ITEM(args,ii);
16459   }
16460   if (argc == 2) {
16461     int _v;
16462     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
16463     _v = SWIG_CheckState(res);
16464     if (_v) {
16465       {
16466         _v = PySlice_Check(argv[1]);
16467       }
16468       if (_v) {
16469         return _wrap_VectorInt___delitem____SWIG_1(self, args);
16470       }
16471     }
16472   }
16473   if (argc == 2) {
16474     int _v;
16475     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
16476     _v = SWIG_CheckState(res);
16477     if (_v) {
16478       {
16479         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
16480         _v = SWIG_CheckState(res);
16481       }
16482       if (_v) {
16483         return _wrap_VectorInt___delitem____SWIG_0(self, args);
16484       }
16485     }
16486   }
16487
16488 fail:
16489   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt___delitem__'.\n"
16490     "  Possible C/C++ prototypes are:\n"
16491     "    __delitem__(std::vector< int > *,std::vector< int >::difference_type)\n"
16492     "    __delitem__(std::vector< int > *,PySliceObject *)\n");
16493   return NULL;
16494 }
16495
16496
16497 SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16498   PyObject *resultobj = 0;
16499   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16500   std::vector< int >::difference_type arg2 ;
16501   void *argp1 = 0 ;
16502   int res1 = 0 ;
16503   ptrdiff_t val2 ;
16504   int ecode2 = 0 ;
16505   PyObject * obj0 = 0 ;
16506   PyObject * obj1 = 0 ;
16507   std::vector< int >::value_type *result = 0 ;
16508
16509   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
16510   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16511   if (!SWIG_IsOK(res1)) {
16512     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'");
16513   }
16514   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16515   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16516   if (!SWIG_IsOK(ecode2)) {
16517     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
16518   }
16519   arg2 = static_cast< std::vector< int >::difference_type >(val2);
16520   try {
16521     result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,arg2);
16522   }
16523   catch(std::out_of_range &_e) {
16524     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16525   }
16526
16527   resultobj = SWIG_From_int(static_cast< int >(*result));
16528   return resultobj;
16529 fail:
16530   return NULL;
16531 }
16532
16533
16534 SWIGINTERN PyObject *_wrap_VectorInt___getitem__(PyObject *self, PyObject *args) {
16535   int argc;
16536   PyObject *argv[3];
16537   int ii;
16538
16539   if (!PyTuple_Check(args)) SWIG_fail;
16540   argc = (int)PyObject_Length(args);
16541   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
16542     argv[ii] = PyTuple_GET_ITEM(args,ii);
16543   }
16544   if (argc == 2) {
16545     int _v;
16546     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
16547     _v = SWIG_CheckState(res);
16548     if (_v) {
16549       {
16550         _v = PySlice_Check(argv[1]);
16551       }
16552       if (_v) {
16553         return _wrap_VectorInt___getitem____SWIG_0(self, args);
16554       }
16555     }
16556   }
16557   if (argc == 2) {
16558     int _v;
16559     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
16560     _v = SWIG_CheckState(res);
16561     if (_v) {
16562       {
16563         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
16564         _v = SWIG_CheckState(res);
16565       }
16566       if (_v) {
16567         return _wrap_VectorInt___getitem____SWIG_1(self, args);
16568       }
16569     }
16570   }
16571
16572 fail:
16573   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt___getitem__'.\n"
16574     "  Possible C/C++ prototypes are:\n"
16575     "    __getitem__(std::vector< int > *,PySliceObject *)\n"
16576     "    __getitem__(std::vector< int > const *,std::vector< int >::difference_type)\n");
16577   return NULL;
16578 }
16579
16580
16581 SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16582   PyObject *resultobj = 0;
16583   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16584   std::vector< int >::difference_type arg2 ;
16585   std::vector< int >::value_type *arg3 = 0 ;
16586   void *argp1 = 0 ;
16587   int res1 = 0 ;
16588   ptrdiff_t val2 ;
16589   int ecode2 = 0 ;
16590   std::vector< int >::value_type temp3 ;
16591   int val3 ;
16592   int ecode3 = 0 ;
16593   PyObject * obj0 = 0 ;
16594   PyObject * obj1 = 0 ;
16595   PyObject * obj2 = 0 ;
16596
16597   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
16598   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16599   if (!SWIG_IsOK(res1)) {
16600     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
16601   }
16602   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16603   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16604   if (!SWIG_IsOK(ecode2)) {
16605     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
16606   }
16607   arg2 = static_cast< std::vector< int >::difference_type >(val2);
16608   ecode3 = SWIG_AsVal_int(obj2, &val3);
16609   if (!SWIG_IsOK(ecode3)) {
16610     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
16611   }
16612   temp3 = static_cast< std::vector< int >::value_type >(val3);
16613   arg3 = &temp3;
16614   try {
16615     std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2,(int const &)*arg3);
16616   }
16617   catch(std::out_of_range &_e) {
16618     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16619   }
16620
16621   resultobj = SWIG_Py_Void();
16622   return resultobj;
16623 fail:
16624   return NULL;
16625 }
16626
16627
16628 SWIGINTERN PyObject *_wrap_VectorInt___setitem__(PyObject *self, PyObject *args) {
16629   int argc;
16630   PyObject *argv[4];
16631   int ii;
16632
16633   if (!PyTuple_Check(args)) SWIG_fail;
16634   argc = (int)PyObject_Length(args);
16635   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
16636     argv[ii] = PyTuple_GET_ITEM(args,ii);
16637   }
16638   if (argc == 3) {
16639     int _v;
16640     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
16641     _v = SWIG_CheckState(res);
16642     if (_v) {
16643       {
16644         _v = PySlice_Check(argv[1]);
16645       }
16646       if (_v) {
16647         int res = swig::asptr(argv[2], (std::vector<int,std::allocator< int > >**)(0));
16648         _v = SWIG_CheckState(res);
16649         if (_v) {
16650           return _wrap_VectorInt___setitem____SWIG_0(self, args);
16651         }
16652       }
16653     }
16654   }
16655   if (argc == 3) {
16656     int _v;
16657     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
16658     _v = SWIG_CheckState(res);
16659     if (_v) {
16660       {
16661         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
16662         _v = SWIG_CheckState(res);
16663       }
16664       if (_v) {
16665         {
16666           int res = SWIG_AsVal_int(argv[2], NULL);
16667           _v = SWIG_CheckState(res);
16668         }
16669         if (_v) {
16670           return _wrap_VectorInt___setitem____SWIG_1(self, args);
16671         }
16672       }
16673     }
16674   }
16675
16676 fail:
16677   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt___setitem__'.\n"
16678     "  Possible C/C++ prototypes are:\n"
16679     "    __setitem__(std::vector< int > *,PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
16680     "    __setitem__(std::vector< int > *,std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
16681   return NULL;
16682 }
16683
16684
16685 SWIGINTERN PyObject *_wrap_VectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16686   PyObject *resultobj = 0;
16687   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16688   std::vector< int >::value_type *arg2 = 0 ;
16689   void *argp1 = 0 ;
16690   int res1 = 0 ;
16691   std::vector< int >::value_type temp2 ;
16692   int val2 ;
16693   int ecode2 = 0 ;
16694   PyObject * obj0 = 0 ;
16695   PyObject * obj1 = 0 ;
16696
16697   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_append",&obj0,&obj1)) SWIG_fail;
16698   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16699   if (!SWIG_IsOK(res1)) {
16700     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_append" "', argument " "1"" of type '" "std::vector< int > *""'");
16701   }
16702   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16703   ecode2 = SWIG_AsVal_int(obj1, &val2);
16704   if (!SWIG_IsOK(ecode2)) {
16705     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
16706   }
16707   temp2 = static_cast< std::vector< int >::value_type >(val2);
16708   arg2 = &temp2;
16709   std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
16710   resultobj = SWIG_Py_Void();
16711   return resultobj;
16712 fail:
16713   return NULL;
16714 }
16715
16716
16717 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16718   PyObject *resultobj = 0;
16719   std::vector< int > *result = 0 ;
16720
16721   if (!PyArg_ParseTuple(args,(char *)":new_VectorInt")) SWIG_fail;
16722   result = (std::vector< int > *)new std::vector< int >();
16723   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
16724   return resultobj;
16725 fail:
16726   return NULL;
16727 }
16728
16729
16730 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16731   PyObject *resultobj = 0;
16732   std::vector< int > *arg1 = 0 ;
16733   int res1 = SWIG_OLDOBJ ;
16734   PyObject * obj0 = 0 ;
16735   std::vector< int > *result = 0 ;
16736
16737   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
16738   {
16739     std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
16740     res1 = swig::asptr(obj0, &ptr);
16741     if (!SWIG_IsOK(res1)) {
16742       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'");
16743     }
16744     if (!ptr) {
16745       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'");
16746     }
16747     arg1 = ptr;
16748   }
16749   result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
16750   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
16751   if (SWIG_IsNewObj(res1)) delete arg1;
16752   return resultobj;
16753 fail:
16754   if (SWIG_IsNewObj(res1)) delete arg1;
16755   return NULL;
16756 }
16757
16758
16759 SWIGINTERN PyObject *_wrap_VectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16760   PyObject *resultobj = 0;
16761   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16762   void *argp1 = 0 ;
16763   int res1 = 0 ;
16764   PyObject * obj0 = 0 ;
16765   bool result;
16766
16767   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_empty",&obj0)) SWIG_fail;
16768   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16769   if (!SWIG_IsOK(res1)) {
16770     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_empty" "', argument " "1"" of type '" "std::vector< int > const *""'");
16771   }
16772   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16773   result = (bool)((std::vector< int > const *)arg1)->empty();
16774   resultobj = SWIG_From_bool(static_cast< bool >(result));
16775   return resultobj;
16776 fail:
16777   return NULL;
16778 }
16779
16780
16781 SWIGINTERN PyObject *_wrap_VectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16782   PyObject *resultobj = 0;
16783   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16784   void *argp1 = 0 ;
16785   int res1 = 0 ;
16786   PyObject * obj0 = 0 ;
16787   std::vector< int >::size_type result;
16788
16789   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_size",&obj0)) SWIG_fail;
16790   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16791   if (!SWIG_IsOK(res1)) {
16792     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_size" "', argument " "1"" of type '" "std::vector< int > const *""'");
16793   }
16794   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16795   result = ((std::vector< int > const *)arg1)->size();
16796   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16797   return resultobj;
16798 fail:
16799   return NULL;
16800 }
16801
16802
16803 SWIGINTERN PyObject *_wrap_VectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16804   PyObject *resultobj = 0;
16805   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16806   void *argp1 = 0 ;
16807   int res1 = 0 ;
16808   PyObject * obj0 = 0 ;
16809
16810   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_clear",&obj0)) SWIG_fail;
16811   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16812   if (!SWIG_IsOK(res1)) {
16813     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_clear" "', argument " "1"" of type '" "std::vector< int > *""'");
16814   }
16815   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16816   (arg1)->clear();
16817   resultobj = SWIG_Py_Void();
16818   return resultobj;
16819 fail:
16820   return NULL;
16821 }
16822
16823
16824 SWIGINTERN PyObject *_wrap_VectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16825   PyObject *resultobj = 0;
16826   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16827   std::vector< int > *arg2 = 0 ;
16828   void *argp1 = 0 ;
16829   int res1 = 0 ;
16830   void *argp2 = 0 ;
16831   int res2 = 0 ;
16832   PyObject * obj0 = 0 ;
16833   PyObject * obj1 = 0 ;
16834
16835   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_swap",&obj0,&obj1)) SWIG_fail;
16836   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16837   if (!SWIG_IsOK(res1)) {
16838     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_swap" "', argument " "1"" of type '" "std::vector< int > *""'");
16839   }
16840   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16841   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
16842   if (!SWIG_IsOK(res2)) {
16843     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
16844   }
16845   if (!argp2) {
16846     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
16847   }
16848   arg2 = reinterpret_cast< std::vector< int > * >(argp2);
16849   (arg1)->swap(*arg2);
16850   resultobj = SWIG_Py_Void();
16851   return resultobj;
16852 fail:
16853   return NULL;
16854 }
16855
16856
16857 SWIGINTERN PyObject *_wrap_VectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16858   PyObject *resultobj = 0;
16859   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16860   void *argp1 = 0 ;
16861   int res1 = 0 ;
16862   PyObject * obj0 = 0 ;
16863   SwigValueWrapper< std::allocator< int > > result;
16864
16865   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_get_allocator",&obj0)) SWIG_fail;
16866   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16867   if (!SWIG_IsOK(res1)) {
16868     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'");
16869   }
16870   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16871   result = ((std::vector< int > const *)arg1)->get_allocator();
16872   resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
16873   return resultobj;
16874 fail:
16875   return NULL;
16876 }
16877
16878
16879 SWIGINTERN PyObject *_wrap_VectorInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16880   PyObject *resultobj = 0;
16881   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16882   void *argp1 = 0 ;
16883   int res1 = 0 ;
16884   PyObject * obj0 = 0 ;
16885   std::vector< int >::const_iterator result;
16886
16887   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail;
16888   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16889   if (!SWIG_IsOK(res1)) {
16890     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector< int > const *""'");
16891   }
16892   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16893   result = ((std::vector< int > const *)arg1)->begin();
16894   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)),
16895     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
16896   return resultobj;
16897 fail:
16898   return NULL;
16899 }
16900
16901
16902 SWIGINTERN PyObject *_wrap_VectorInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16903   PyObject *resultobj = 0;
16904   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16905   void *argp1 = 0 ;
16906   int res1 = 0 ;
16907   PyObject * obj0 = 0 ;
16908   std::vector< int >::const_iterator result;
16909
16910   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail;
16911   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16912   if (!SWIG_IsOK(res1)) {
16913     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector< int > const *""'");
16914   }
16915   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16916   result = ((std::vector< int > const *)arg1)->end();
16917   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)),
16918     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
16919   return resultobj;
16920 fail:
16921   return NULL;
16922 }
16923
16924
16925 SWIGINTERN PyObject *_wrap_VectorInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16926   PyObject *resultobj = 0;
16927   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16928   void *argp1 = 0 ;
16929   int res1 = 0 ;
16930   PyObject * obj0 = 0 ;
16931   std::vector< int >::const_reverse_iterator result;
16932
16933   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail;
16934   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16935   if (!SWIG_IsOK(res1)) {
16936     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector< int > const *""'");
16937   }
16938   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16939   result = ((std::vector< int > const *)arg1)->rbegin();
16940   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)),
16941     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
16942   return resultobj;
16943 fail:
16944   return NULL;
16945 }
16946
16947
16948 SWIGINTERN PyObject *_wrap_VectorInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16949   PyObject *resultobj = 0;
16950   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16951   void *argp1 = 0 ;
16952   int res1 = 0 ;
16953   PyObject * obj0 = 0 ;
16954   std::vector< int >::const_reverse_iterator result;
16955
16956   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail;
16957   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
16958   if (!SWIG_IsOK(res1)) {
16959     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector< int > const *""'");
16960   }
16961   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
16962   result = ((std::vector< int > const *)arg1)->rend();
16963   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)),
16964     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
16965   return resultobj;
16966 fail:
16967   return NULL;
16968 }
16969
16970
16971 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16972   PyObject *resultobj = 0;
16973   std::vector< int >::size_type arg1 ;
16974   size_t val1 ;
16975   int ecode1 = 0 ;
16976   PyObject * obj0 = 0 ;
16977   std::vector< int > *result = 0 ;
16978
16979   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
16980   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
16981   if (!SWIG_IsOK(ecode1)) {
16982     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
16983   }
16984   arg1 = static_cast< std::vector< int >::size_type >(val1);
16985   result = (std::vector< int > *)new std::vector< int >(arg1);
16986   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
16987   return resultobj;
16988 fail:
16989   return NULL;
16990 }
16991
16992
16993 SWIGINTERN PyObject *_wrap_VectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16994   PyObject *resultobj = 0;
16995   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
16996   void *argp1 = 0 ;
16997   int res1 = 0 ;
16998   PyObject * obj0 = 0 ;
16999
17000   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop_back",&obj0)) SWIG_fail;
17001   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17002   if (!SWIG_IsOK(res1)) {
17003     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'");
17004   }
17005   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17006   (arg1)->pop_back();
17007   resultobj = SWIG_Py_Void();
17008   return resultobj;
17009 fail:
17010   return NULL;
17011 }
17012
17013
17014 SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17015   PyObject *resultobj = 0;
17016   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17017   std::vector< int >::size_type arg2 ;
17018   void *argp1 = 0 ;
17019   int res1 = 0 ;
17020   size_t val2 ;
17021   int ecode2 = 0 ;
17022   PyObject * obj0 = 0 ;
17023   PyObject * obj1 = 0 ;
17024
17025   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_resize",&obj0,&obj1)) SWIG_fail;
17026   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17027   if (!SWIG_IsOK(res1)) {
17028     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
17029   }
17030   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17031   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17032   if (!SWIG_IsOK(ecode2)) {
17033     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
17034   }
17035   arg2 = static_cast< std::vector< int >::size_type >(val2);
17036   (arg1)->resize(arg2);
17037   resultobj = SWIG_Py_Void();
17038   return resultobj;
17039 fail:
17040   return NULL;
17041 }
17042
17043
17044 SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17045   PyObject *resultobj = 0;
17046   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17047   std::vector< int >::iterator arg2 ;
17048   void *argp1 = 0 ;
17049   int res1 = 0 ;
17050   swig::SwigPyIterator *iter2 = 0 ;
17051   int res2 ;
17052   PyObject * obj0 = 0 ;
17053   PyObject * obj1 = 0 ;
17054   std::vector< int >::iterator result;
17055
17056   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_erase",&obj0,&obj1)) SWIG_fail;
17057   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17058   if (!SWIG_IsOK(res1)) {
17059     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
17060   }
17061   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17062   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17063   if (!SWIG_IsOK(res2) || !iter2) {
17064     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
17065   } else {
17066     swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
17067     if (iter_t) {
17068       arg2 = iter_t->get_current();
17069     } else {
17070       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
17071     }
17072   }
17073   result = (arg1)->erase(arg2);
17074   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
17075     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17076   return resultobj;
17077 fail:
17078   return NULL;
17079 }
17080
17081
17082 SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17083   PyObject *resultobj = 0;
17084   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17085   std::vector< int >::iterator arg2 ;
17086   std::vector< int >::iterator arg3 ;
17087   void *argp1 = 0 ;
17088   int res1 = 0 ;
17089   swig::SwigPyIterator *iter2 = 0 ;
17090   int res2 ;
17091   swig::SwigPyIterator *iter3 = 0 ;
17092   int res3 ;
17093   PyObject * obj0 = 0 ;
17094   PyObject * obj1 = 0 ;
17095   PyObject * obj2 = 0 ;
17096   std::vector< int >::iterator result;
17097
17098   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
17099   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17100   if (!SWIG_IsOK(res1)) {
17101     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
17102   }
17103   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17104   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17105   if (!SWIG_IsOK(res2) || !iter2) {
17106     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
17107   } else {
17108     swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
17109     if (iter_t) {
17110       arg2 = iter_t->get_current();
17111     } else {
17112       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
17113     }
17114   }
17115   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
17116   if (!SWIG_IsOK(res3) || !iter3) {
17117     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
17118   } else {
17119     swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter3);
17120     if (iter_t) {
17121       arg3 = iter_t->get_current();
17122     } else {
17123       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
17124     }
17125   }
17126   result = (arg1)->erase(arg2,arg3);
17127   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
17128     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17129   return resultobj;
17130 fail:
17131   return NULL;
17132 }
17133
17134
17135 SWIGINTERN PyObject *_wrap_VectorInt_erase(PyObject *self, PyObject *args) {
17136   int argc;
17137   PyObject *argv[4];
17138   int ii;
17139
17140   if (!PyTuple_Check(args)) SWIG_fail;
17141   argc = (int)PyObject_Length(args);
17142   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17143     argv[ii] = PyTuple_GET_ITEM(args,ii);
17144   }
17145   if (argc == 2) {
17146     int _v;
17147     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
17148     _v = SWIG_CheckState(res);
17149     if (_v) {
17150       swig::SwigPyIterator *iter = 0;
17151       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17152       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
17153       if (_v) {
17154         return _wrap_VectorInt_erase__SWIG_0(self, args);
17155       }
17156     }
17157   }
17158   if (argc == 3) {
17159     int _v;
17160     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
17161     _v = SWIG_CheckState(res);
17162     if (_v) {
17163       swig::SwigPyIterator *iter = 0;
17164       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17165       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
17166       if (_v) {
17167         swig::SwigPyIterator *iter = 0;
17168         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17169         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
17170         if (_v) {
17171           return _wrap_VectorInt_erase__SWIG_1(self, args);
17172         }
17173       }
17174     }
17175   }
17176
17177 fail:
17178   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_erase'.\n"
17179     "  Possible C/C++ prototypes are:\n"
17180     "    erase(std::vector< int > *,std::vector< int >::iterator)\n"
17181     "    erase(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::iterator)\n");
17182   return NULL;
17183 }
17184
17185
17186 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17187   PyObject *resultobj = 0;
17188   std::vector< int >::size_type arg1 ;
17189   std::vector< int >::value_type *arg2 = 0 ;
17190   size_t val1 ;
17191   int ecode1 = 0 ;
17192   std::vector< int >::value_type temp2 ;
17193   int val2 ;
17194   int ecode2 = 0 ;
17195   PyObject * obj0 = 0 ;
17196   PyObject * obj1 = 0 ;
17197   std::vector< int > *result = 0 ;
17198
17199   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorInt",&obj0,&obj1)) SWIG_fail;
17200   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
17201   if (!SWIG_IsOK(ecode1)) {
17202     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
17203   }
17204   arg1 = static_cast< std::vector< int >::size_type >(val1);
17205   ecode2 = SWIG_AsVal_int(obj1, &val2);
17206   if (!SWIG_IsOK(ecode2)) {
17207     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorInt" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
17208   }
17209   temp2 = static_cast< std::vector< int >::value_type >(val2);
17210   arg2 = &temp2;
17211   result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2);
17212   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
17213   return resultobj;
17214 fail:
17215   return NULL;
17216 }
17217
17218
17219 SWIGINTERN PyObject *_wrap_new_VectorInt(PyObject *self, PyObject *args) {
17220   int argc;
17221   PyObject *argv[3];
17222   int ii;
17223
17224   if (!PyTuple_Check(args)) SWIG_fail;
17225   argc = (int)PyObject_Length(args);
17226   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
17227     argv[ii] = PyTuple_GET_ITEM(args,ii);
17228   }
17229   if (argc == 0) {
17230     return _wrap_new_VectorInt__SWIG_0(self, args);
17231   }
17232   if (argc == 1) {
17233     int _v;
17234     {
17235       int res = SWIG_AsVal_size_t(argv[0], NULL);
17236       _v = SWIG_CheckState(res);
17237     }
17238     if (_v) {
17239       return _wrap_new_VectorInt__SWIG_2(self, args);
17240     }
17241   }
17242   if (argc == 1) {
17243     int _v;
17244     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
17245     _v = SWIG_CheckState(res);
17246     if (_v) {
17247       return _wrap_new_VectorInt__SWIG_1(self, args);
17248     }
17249   }
17250   if (argc == 2) {
17251     int _v;
17252     {
17253       int res = SWIG_AsVal_size_t(argv[0], NULL);
17254       _v = SWIG_CheckState(res);
17255     }
17256     if (_v) {
17257       {
17258         int res = SWIG_AsVal_int(argv[1], NULL);
17259         _v = SWIG_CheckState(res);
17260       }
17261       if (_v) {
17262         return _wrap_new_VectorInt__SWIG_3(self, args);
17263       }
17264     }
17265   }
17266
17267 fail:
17268   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorInt'.\n"
17269     "  Possible C/C++ prototypes are:\n"
17270     "    std::vector< int >()\n"
17271     "    std::vector< int >(std::vector< int > const &)\n"
17272     "    std::vector< int >(std::vector< int >::size_type)\n"
17273     "    std::vector< int >(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
17274   return NULL;
17275 }
17276
17277
17278 SWIGINTERN PyObject *_wrap_VectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17279   PyObject *resultobj = 0;
17280   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17281   std::vector< int >::value_type *arg2 = 0 ;
17282   void *argp1 = 0 ;
17283   int res1 = 0 ;
17284   std::vector< int >::value_type temp2 ;
17285   int val2 ;
17286   int ecode2 = 0 ;
17287   PyObject * obj0 = 0 ;
17288   PyObject * obj1 = 0 ;
17289
17290   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_push_back",&obj0,&obj1)) SWIG_fail;
17291   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17292   if (!SWIG_IsOK(res1)) {
17293     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_push_back" "', argument " "1"" of type '" "std::vector< int > *""'");
17294   }
17295   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17296   ecode2 = SWIG_AsVal_int(obj1, &val2);
17297   if (!SWIG_IsOK(ecode2)) {
17298     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
17299   }
17300   temp2 = static_cast< std::vector< int >::value_type >(val2);
17301   arg2 = &temp2;
17302   (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
17303   resultobj = SWIG_Py_Void();
17304   return resultobj;
17305 fail:
17306   return NULL;
17307 }
17308
17309
17310 SWIGINTERN PyObject *_wrap_VectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17311   PyObject *resultobj = 0;
17312   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17313   void *argp1 = 0 ;
17314   int res1 = 0 ;
17315   PyObject * obj0 = 0 ;
17316   std::vector< int >::value_type *result = 0 ;
17317
17318   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_front",&obj0)) SWIG_fail;
17319   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17320   if (!SWIG_IsOK(res1)) {
17321     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_front" "', argument " "1"" of type '" "std::vector< int > const *""'");
17322   }
17323   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17324   result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front();
17325   resultobj = SWIG_From_int(static_cast< int >(*result));
17326   return resultobj;
17327 fail:
17328   return NULL;
17329 }
17330
17331
17332 SWIGINTERN PyObject *_wrap_VectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17333   PyObject *resultobj = 0;
17334   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17335   void *argp1 = 0 ;
17336   int res1 = 0 ;
17337   PyObject * obj0 = 0 ;
17338   std::vector< int >::value_type *result = 0 ;
17339
17340   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_back",&obj0)) SWIG_fail;
17341   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17342   if (!SWIG_IsOK(res1)) {
17343     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_back" "', argument " "1"" of type '" "std::vector< int > const *""'");
17344   }
17345   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17346   result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->back();
17347   resultobj = SWIG_From_int(static_cast< int >(*result));
17348   return resultobj;
17349 fail:
17350   return NULL;
17351 }
17352
17353
17354 SWIGINTERN PyObject *_wrap_VectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17355   PyObject *resultobj = 0;
17356   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17357   std::vector< int >::size_type arg2 ;
17358   std::vector< int >::value_type *arg3 = 0 ;
17359   void *argp1 = 0 ;
17360   int res1 = 0 ;
17361   size_t val2 ;
17362   int ecode2 = 0 ;
17363   std::vector< int >::value_type temp3 ;
17364   int val3 ;
17365   int ecode3 = 0 ;
17366   PyObject * obj0 = 0 ;
17367   PyObject * obj1 = 0 ;
17368   PyObject * obj2 = 0 ;
17369
17370   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail;
17371   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17372   if (!SWIG_IsOK(res1)) {
17373     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_assign" "', argument " "1"" of type '" "std::vector< int > *""'");
17374   }
17375   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17376   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17377   if (!SWIG_IsOK(ecode2)) {
17378     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
17379   }
17380   arg2 = static_cast< std::vector< int >::size_type >(val2);
17381   ecode3 = SWIG_AsVal_int(obj2, &val3);
17382   if (!SWIG_IsOK(ecode3)) {
17383     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
17384   }
17385   temp3 = static_cast< std::vector< int >::value_type >(val3);
17386   arg3 = &temp3;
17387   (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
17388   resultobj = SWIG_Py_Void();
17389   return resultobj;
17390 fail:
17391   return NULL;
17392 }
17393
17394
17395 SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17396   PyObject *resultobj = 0;
17397   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17398   std::vector< int >::size_type arg2 ;
17399   std::vector< int >::value_type *arg3 = 0 ;
17400   void *argp1 = 0 ;
17401   int res1 = 0 ;
17402   size_t val2 ;
17403   int ecode2 = 0 ;
17404   std::vector< int >::value_type temp3 ;
17405   int val3 ;
17406   int ecode3 = 0 ;
17407   PyObject * obj0 = 0 ;
17408   PyObject * obj1 = 0 ;
17409   PyObject * obj2 = 0 ;
17410
17411   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail;
17412   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17413   if (!SWIG_IsOK(res1)) {
17414     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
17415   }
17416   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17417   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17418   if (!SWIG_IsOK(ecode2)) {
17419     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
17420   }
17421   arg2 = static_cast< std::vector< int >::size_type >(val2);
17422   ecode3 = SWIG_AsVal_int(obj2, &val3);
17423   if (!SWIG_IsOK(ecode3)) {
17424     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
17425   }
17426   temp3 = static_cast< std::vector< int >::value_type >(val3);
17427   arg3 = &temp3;
17428   (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
17429   resultobj = SWIG_Py_Void();
17430   return resultobj;
17431 fail:
17432   return NULL;
17433 }
17434
17435
17436 SWIGINTERN PyObject *_wrap_VectorInt_resize(PyObject *self, PyObject *args) {
17437   int argc;
17438   PyObject *argv[4];
17439   int ii;
17440
17441   if (!PyTuple_Check(args)) SWIG_fail;
17442   argc = (int)PyObject_Length(args);
17443   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17444     argv[ii] = PyTuple_GET_ITEM(args,ii);
17445   }
17446   if (argc == 2) {
17447     int _v;
17448     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
17449     _v = SWIG_CheckState(res);
17450     if (_v) {
17451       {
17452         int res = SWIG_AsVal_size_t(argv[1], NULL);
17453         _v = SWIG_CheckState(res);
17454       }
17455       if (_v) {
17456         return _wrap_VectorInt_resize__SWIG_0(self, args);
17457       }
17458     }
17459   }
17460   if (argc == 3) {
17461     int _v;
17462     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
17463     _v = SWIG_CheckState(res);
17464     if (_v) {
17465       {
17466         int res = SWIG_AsVal_size_t(argv[1], NULL);
17467         _v = SWIG_CheckState(res);
17468       }
17469       if (_v) {
17470         {
17471           int res = SWIG_AsVal_int(argv[2], NULL);
17472           _v = SWIG_CheckState(res);
17473         }
17474         if (_v) {
17475           return _wrap_VectorInt_resize__SWIG_1(self, args);
17476         }
17477       }
17478     }
17479   }
17480
17481 fail:
17482   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_resize'.\n"
17483     "  Possible C/C++ prototypes are:\n"
17484     "    resize(std::vector< int > *,std::vector< int >::size_type)\n"
17485     "    resize(std::vector< int > *,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
17486   return NULL;
17487 }
17488
17489
17490 SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17491   PyObject *resultobj = 0;
17492   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17493   std::vector< int >::iterator arg2 ;
17494   std::vector< int >::value_type *arg3 = 0 ;
17495   void *argp1 = 0 ;
17496   int res1 = 0 ;
17497   swig::SwigPyIterator *iter2 = 0 ;
17498   int res2 ;
17499   std::vector< int >::value_type temp3 ;
17500   int val3 ;
17501   int ecode3 = 0 ;
17502   PyObject * obj0 = 0 ;
17503   PyObject * obj1 = 0 ;
17504   PyObject * obj2 = 0 ;
17505   std::vector< int >::iterator result;
17506
17507   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail;
17508   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17509   if (!SWIG_IsOK(res1)) {
17510     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
17511   }
17512   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17513   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17514   if (!SWIG_IsOK(res2) || !iter2) {
17515     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
17516   } else {
17517     swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
17518     if (iter_t) {
17519       arg2 = iter_t->get_current();
17520     } else {
17521       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
17522     }
17523   }
17524   ecode3 = SWIG_AsVal_int(obj2, &val3);
17525   if (!SWIG_IsOK(ecode3)) {
17526     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
17527   }
17528   temp3 = static_cast< std::vector< int >::value_type >(val3);
17529   arg3 = &temp3;
17530   result = (arg1)->insert(arg2,(std::vector< int >::value_type const &)*arg3);
17531   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
17532     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17533   return resultobj;
17534 fail:
17535   return NULL;
17536 }
17537
17538
17539 SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17540   PyObject *resultobj = 0;
17541   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17542   std::vector< int >::iterator arg2 ;
17543   std::vector< int >::size_type arg3 ;
17544   std::vector< int >::value_type *arg4 = 0 ;
17545   void *argp1 = 0 ;
17546   int res1 = 0 ;
17547   swig::SwigPyIterator *iter2 = 0 ;
17548   int res2 ;
17549   size_t val3 ;
17550   int ecode3 = 0 ;
17551   std::vector< int >::value_type temp4 ;
17552   int val4 ;
17553   int ecode4 = 0 ;
17554   PyObject * obj0 = 0 ;
17555   PyObject * obj1 = 0 ;
17556   PyObject * obj2 = 0 ;
17557   PyObject * obj3 = 0 ;
17558
17559   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17560   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17561   if (!SWIG_IsOK(res1)) {
17562     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
17563   }
17564   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17565   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17566   if (!SWIG_IsOK(res2) || !iter2) {
17567     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
17568   } else {
17569     swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
17570     if (iter_t) {
17571       arg2 = iter_t->get_current();
17572     } else {
17573       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
17574     }
17575   }
17576   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
17577   if (!SWIG_IsOK(ecode3)) {
17578     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
17579   }
17580   arg3 = static_cast< std::vector< int >::size_type >(val3);
17581   ecode4 = SWIG_AsVal_int(obj3, &val4);
17582   if (!SWIG_IsOK(ecode4)) {
17583     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorInt_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
17584   }
17585   temp4 = static_cast< std::vector< int >::value_type >(val4);
17586   arg4 = &temp4;
17587   (arg1)->insert(arg2,arg3,(std::vector< int >::value_type const &)*arg4);
17588   resultobj = SWIG_Py_Void();
17589   return resultobj;
17590 fail:
17591   return NULL;
17592 }
17593
17594
17595 SWIGINTERN PyObject *_wrap_VectorInt_insert(PyObject *self, PyObject *args) {
17596   int argc;
17597   PyObject *argv[5];
17598   int ii;
17599
17600   if (!PyTuple_Check(args)) SWIG_fail;
17601   argc = (int)PyObject_Length(args);
17602   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
17603     argv[ii] = PyTuple_GET_ITEM(args,ii);
17604   }
17605   if (argc == 3) {
17606     int _v;
17607     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
17608     _v = SWIG_CheckState(res);
17609     if (_v) {
17610       swig::SwigPyIterator *iter = 0;
17611       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17612       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
17613       if (_v) {
17614         {
17615           int res = SWIG_AsVal_int(argv[2], NULL);
17616           _v = SWIG_CheckState(res);
17617         }
17618         if (_v) {
17619           return _wrap_VectorInt_insert__SWIG_0(self, args);
17620         }
17621       }
17622     }
17623   }
17624   if (argc == 4) {
17625     int _v;
17626     int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
17627     _v = SWIG_CheckState(res);
17628     if (_v) {
17629       swig::SwigPyIterator *iter = 0;
17630       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17631       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
17632       if (_v) {
17633         {
17634           int res = SWIG_AsVal_size_t(argv[2], NULL);
17635           _v = SWIG_CheckState(res);
17636         }
17637         if (_v) {
17638           {
17639             int res = SWIG_AsVal_int(argv[3], NULL);
17640             _v = SWIG_CheckState(res);
17641           }
17642           if (_v) {
17643             return _wrap_VectorInt_insert__SWIG_1(self, args);
17644           }
17645         }
17646       }
17647     }
17648   }
17649
17650 fail:
17651   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_insert'.\n"
17652     "  Possible C/C++ prototypes are:\n"
17653     "    insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
17654     "    insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
17655   return NULL;
17656 }
17657
17658
17659 SWIGINTERN PyObject *_wrap_VectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17660   PyObject *resultobj = 0;
17661   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17662   std::vector< int >::size_type arg2 ;
17663   void *argp1 = 0 ;
17664   int res1 = 0 ;
17665   size_t val2 ;
17666   int ecode2 = 0 ;
17667   PyObject * obj0 = 0 ;
17668   PyObject * obj1 = 0 ;
17669
17670   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_reserve",&obj0,&obj1)) SWIG_fail;
17671   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17672   if (!SWIG_IsOK(res1)) {
17673     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_reserve" "', argument " "1"" of type '" "std::vector< int > *""'");
17674   }
17675   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17676   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17677   if (!SWIG_IsOK(ecode2)) {
17678     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
17679   }
17680   arg2 = static_cast< std::vector< int >::size_type >(val2);
17681   (arg1)->reserve(arg2);
17682   resultobj = SWIG_Py_Void();
17683   return resultobj;
17684 fail:
17685   return NULL;
17686 }
17687
17688
17689 SWIGINTERN PyObject *_wrap_VectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17690   PyObject *resultobj = 0;
17691   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17692   void *argp1 = 0 ;
17693   int res1 = 0 ;
17694   PyObject * obj0 = 0 ;
17695   std::vector< int >::size_type result;
17696
17697   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_capacity",&obj0)) SWIG_fail;
17698   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
17699   if (!SWIG_IsOK(res1)) {
17700     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'");
17701   }
17702   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17703   result = ((std::vector< int > const *)arg1)->capacity();
17704   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17705   return resultobj;
17706 fail:
17707   return NULL;
17708 }
17709
17710
17711 SWIGINTERN PyObject *_wrap_delete_VectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17712   PyObject *resultobj = 0;
17713   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
17714   void *argp1 = 0 ;
17715   int res1 = 0 ;
17716   PyObject * obj0 = 0 ;
17717
17718   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorInt",&obj0)) SWIG_fail;
17719   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN |  0 );
17720   if (!SWIG_IsOK(res1)) {
17721     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInt" "', argument " "1"" of type '" "std::vector< int > *""'");
17722   }
17723   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
17724   delete arg1;
17725   resultobj = SWIG_Py_Void();
17726   return resultobj;
17727 fail:
17728   return NULL;
17729 }
17730
17731
17732 SWIGINTERN PyObject *VectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17733   PyObject *obj;
17734   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
17735   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj));
17736   return SWIG_Py_Void();
17737 }
17738
17739 SWIGINTERN int Swig_var_ABR_TYPES_set(PyObject *) {
17740   SWIG_Error(SWIG_AttributeError,"Variable ABR_TYPES is read-only.");
17741   return 1;
17742 }
17743
17744
17745 SWIGINTERN PyObject *Swig_var_ABR_TYPES_get(void) {
17746   PyObject *pyobj = 0;
17747
17748   pyobj = SWIG_FromCharPtr(Hex::ABR_TYPES);
17749   return pyobj;
17750 }
17751
17752
17753 SWIGINTERN PyObject *_wrap_get_temp_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17754   PyObject *resultobj = 0;
17755   cpchar arg1 = (cpchar) 0 ;
17756   pchar arg2 = (pchar) 0 ;
17757   int res1 ;
17758   char *buf1 = 0 ;
17759   int alloc1 = 0 ;
17760   int res2 ;
17761   char *buf2 = 0 ;
17762   int alloc2 = 0 ;
17763   PyObject * obj0 = 0 ;
17764   PyObject * obj1 = 0 ;
17765   pchar result;
17766
17767   if (!PyArg_ParseTuple(args,(char *)"OO:get_temp_name",&obj0,&obj1)) SWIG_fail;
17768   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
17769   if (!SWIG_IsOK(res1)) {
17770     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_temp_name" "', argument " "1"" of type '" "cpchar""'");
17771   }
17772   arg1 = reinterpret_cast< cpchar >(buf1);
17773   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17774   if (!SWIG_IsOK(res2)) {
17775     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_temp_name" "', argument " "2"" of type '" "pchar""'");
17776   }
17777   arg2 = reinterpret_cast< pchar >(buf2);
17778   result = (pchar)Hex::get_temp_name((char const *)arg1,arg2);
17779   resultobj = SWIG_FromCharPtr((const char *)result);
17780   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17781   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17782   return resultobj;
17783 fail:
17784   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17785   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17786   return NULL;
17787 }
17788
17789
17790 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17791   PyObject *resultobj = 0;
17792   cpchar arg1 = (cpchar) 0 ;
17793   cpchar arg2 = (cpchar) 0 ;
17794   cpchar arg3 = (cpchar) 0 ;
17795   int res1 ;
17796   char *buf1 = 0 ;
17797   int alloc1 = 0 ;
17798   int res2 ;
17799   char *buf2 = 0 ;
17800   int alloc2 = 0 ;
17801   int res3 ;
17802   char *buf3 = 0 ;
17803   int alloc3 = 0 ;
17804   PyObject * obj0 = 0 ;
17805   PyObject * obj1 = 0 ;
17806   PyObject * obj2 = 0 ;
17807
17808   if (!PyArg_ParseTuple(args,(char *)"OOO:fatal_error",&obj0,&obj1,&obj2)) SWIG_fail;
17809   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
17810   if (!SWIG_IsOK(res1)) {
17811     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
17812   }
17813   arg1 = reinterpret_cast< cpchar >(buf1);
17814   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17815   if (!SWIG_IsOK(res2)) {
17816     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fatal_error" "', argument " "2"" of type '" "cpchar""'");
17817   }
17818   arg2 = reinterpret_cast< cpchar >(buf2);
17819   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
17820   if (!SWIG_IsOK(res3)) {
17821     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fatal_error" "', argument " "3"" of type '" "cpchar""'");
17822   }
17823   arg3 = reinterpret_cast< cpchar >(buf3);
17824   Hex::fatal_error((char const *)arg1,(char const *)arg2,(char const *)arg3);
17825   resultobj = SWIG_Py_Void();
17826   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17827   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17828   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17829   return resultobj;
17830 fail:
17831   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17832   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17833   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17834   return NULL;
17835 }
17836
17837
17838 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17839   PyObject *resultobj = 0;
17840   cpchar arg1 = (cpchar) 0 ;
17841   cpchar arg2 = (cpchar) 0 ;
17842   int res1 ;
17843   char *buf1 = 0 ;
17844   int alloc1 = 0 ;
17845   int res2 ;
17846   char *buf2 = 0 ;
17847   int alloc2 = 0 ;
17848   PyObject * obj0 = 0 ;
17849   PyObject * obj1 = 0 ;
17850
17851   if (!PyArg_ParseTuple(args,(char *)"OO:fatal_error",&obj0,&obj1)) SWIG_fail;
17852   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
17853   if (!SWIG_IsOK(res1)) {
17854     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
17855   }
17856   arg1 = reinterpret_cast< cpchar >(buf1);
17857   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17858   if (!SWIG_IsOK(res2)) {
17859     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fatal_error" "', argument " "2"" of type '" "cpchar""'");
17860   }
17861   arg2 = reinterpret_cast< cpchar >(buf2);
17862   Hex::fatal_error((char const *)arg1,(char const *)arg2);
17863   resultobj = SWIG_Py_Void();
17864   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17865   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17866   return resultobj;
17867 fail:
17868   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17869   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17870   return NULL;
17871 }
17872
17873
17874 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17875   PyObject *resultobj = 0;
17876   cpchar arg1 = (cpchar) 0 ;
17877   int res1 ;
17878   char *buf1 = 0 ;
17879   int alloc1 = 0 ;
17880   PyObject * obj0 = 0 ;
17881
17882   if (!PyArg_ParseTuple(args,(char *)"O:fatal_error",&obj0)) SWIG_fail;
17883   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
17884   if (!SWIG_IsOK(res1)) {
17885     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
17886   }
17887   arg1 = reinterpret_cast< cpchar >(buf1);
17888   Hex::fatal_error((char const *)arg1);
17889   resultobj = SWIG_Py_Void();
17890   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17891   return resultobj;
17892 fail:
17893   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17894   return NULL;
17895 }
17896
17897
17898 SWIGINTERN PyObject *_wrap_fatal_error(PyObject *self, PyObject *args) {
17899   int argc;
17900   PyObject *argv[4];
17901   int ii;
17902
17903   if (!PyTuple_Check(args)) SWIG_fail;
17904   argc = (int)PyObject_Length(args);
17905   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17906     argv[ii] = PyTuple_GET_ITEM(args,ii);
17907   }
17908   if (argc == 1) {
17909     int _v;
17910     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
17911     _v = SWIG_CheckState(res);
17912     if (_v) {
17913       return _wrap_fatal_error__SWIG_2(self, args);
17914     }
17915   }
17916   if (argc == 2) {
17917     int _v;
17918     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
17919     _v = SWIG_CheckState(res);
17920     if (_v) {
17921       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17922       _v = SWIG_CheckState(res);
17923       if (_v) {
17924         return _wrap_fatal_error__SWIG_1(self, args);
17925       }
17926     }
17927   }
17928   if (argc == 3) {
17929     int _v;
17930     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
17931     _v = SWIG_CheckState(res);
17932     if (_v) {
17933       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
17934       _v = SWIG_CheckState(res);
17935       if (_v) {
17936         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
17937         _v = SWIG_CheckState(res);
17938         if (_v) {
17939           return _wrap_fatal_error__SWIG_0(self, args);
17940         }
17941       }
17942     }
17943   }
17944
17945 fail:
17946   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'fatal_error'.\n"
17947     "  Possible C/C++ prototypes are:\n"
17948     "    Hex::fatal_error(cpchar,cpchar,cpchar)\n"
17949     "    Hex::fatal_error(cpchar,cpchar)\n"
17950     "    Hex::fatal_error(cpchar)\n");
17951   return NULL;
17952 }
17953
17954
17955 SWIGINTERN PyObject *_wrap_prod_scalaire(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17956   PyObject *resultobj = 0;
17957   double *arg1 ;
17958   double *arg2 ;
17959   void *argp1 = 0 ;
17960   int res1 = 0 ;
17961   void *argp2 = 0 ;
17962   int res2 = 0 ;
17963   PyObject * obj0 = 0 ;
17964   PyObject * obj1 = 0 ;
17965   double result;
17966
17967   if (!PyArg_ParseTuple(args,(char *)"OO:prod_scalaire",&obj0,&obj1)) SWIG_fail;
17968   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17969   if (!SWIG_IsOK(res1)) {
17970     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_scalaire" "', argument " "1"" of type '" "double []""'");
17971   }
17972   arg1 = reinterpret_cast< double * >(argp1);
17973   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
17974   if (!SWIG_IsOK(res2)) {
17975     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_scalaire" "', argument " "2"" of type '" "double []""'");
17976   }
17977   arg2 = reinterpret_cast< double * >(argp2);
17978   result = (double)Hex::prod_scalaire(arg1,arg2);
17979   resultobj = SWIG_From_double(static_cast< double >(result));
17980   return resultobj;
17981 fail:
17982   return NULL;
17983 }
17984
17985
17986 SWIGINTERN PyObject *_wrap_prod_vectoriel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17987   PyObject *resultobj = 0;
17988   double *arg1 ;
17989   double *arg2 ;
17990   double *arg3 ;
17991   void *argp1 = 0 ;
17992   int res1 = 0 ;
17993   void *argp2 = 0 ;
17994   int res2 = 0 ;
17995   void *argp3 = 0 ;
17996   int res3 = 0 ;
17997   PyObject * obj0 = 0 ;
17998   PyObject * obj1 = 0 ;
17999   PyObject * obj2 = 0 ;
18000   double *result = 0 ;
18001
18002   if (!PyArg_ParseTuple(args,(char *)"OOO:prod_vectoriel",&obj0,&obj1,&obj2)) SWIG_fail;
18003   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18004   if (!SWIG_IsOK(res1)) {
18005     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_vectoriel" "', argument " "1"" of type '" "double []""'");
18006   }
18007   arg1 = reinterpret_cast< double * >(argp1);
18008   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
18009   if (!SWIG_IsOK(res2)) {
18010     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_vectoriel" "', argument " "2"" of type '" "double []""'");
18011   }
18012   arg2 = reinterpret_cast< double * >(argp2);
18013   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
18014   if (!SWIG_IsOK(res3)) {
18015     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "prod_vectoriel" "', argument " "3"" of type '" "double []""'");
18016   }
18017   arg3 = reinterpret_cast< double * >(argp3);
18018   result = (double *)Hex::prod_vectoriel(arg1,arg2,arg3);
18019   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
18020   return resultobj;
18021 fail:
18022   return NULL;
18023 }
18024
18025
18026 SWIGINTERN PyObject *_wrap_prod_mixte(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18027   PyObject *resultobj = 0;
18028   double *arg1 ;
18029   double *arg2 ;
18030   double *arg3 ;
18031   void *argp1 = 0 ;
18032   int res1 = 0 ;
18033   void *argp2 = 0 ;
18034   int res2 = 0 ;
18035   void *argp3 = 0 ;
18036   int res3 = 0 ;
18037   PyObject * obj0 = 0 ;
18038   PyObject * obj1 = 0 ;
18039   PyObject * obj2 = 0 ;
18040   double result;
18041
18042   if (!PyArg_ParseTuple(args,(char *)"OOO:prod_mixte",&obj0,&obj1,&obj2)) SWIG_fail;
18043   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18044   if (!SWIG_IsOK(res1)) {
18045     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_mixte" "', argument " "1"" of type '" "double []""'");
18046   }
18047   arg1 = reinterpret_cast< double * >(argp1);
18048   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
18049   if (!SWIG_IsOK(res2)) {
18050     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_mixte" "', argument " "2"" of type '" "double []""'");
18051   }
18052   arg2 = reinterpret_cast< double * >(argp2);
18053   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
18054   if (!SWIG_IsOK(res3)) {
18055     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "prod_mixte" "', argument " "3"" of type '" "double []""'");
18056   }
18057   arg3 = reinterpret_cast< double * >(argp3);
18058   result = (double)Hex::prod_mixte(arg1,arg2,arg3);
18059   resultobj = SWIG_From_double(static_cast< double >(result));
18060   return resultobj;
18061 fail:
18062   return NULL;
18063 }
18064
18065
18066 SWIGINTERN PyObject *_wrap_deg2radians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18067   PyObject *resultobj = 0;
18068   double arg1 ;
18069   double val1 ;
18070   int ecode1 = 0 ;
18071   PyObject * obj0 = 0 ;
18072   double result;
18073
18074   if (!PyArg_ParseTuple(args,(char *)"O:deg2radians",&obj0)) SWIG_fail;
18075   ecode1 = SWIG_AsVal_double(obj0, &val1);
18076   if (!SWIG_IsOK(ecode1)) {
18077     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "deg2radians" "', argument " "1"" of type '" "double""'");
18078   }
18079   arg1 = static_cast< double >(val1);
18080   result = (double)Hex::deg2radians(arg1);
18081   resultobj = SWIG_From_double(static_cast< double >(result));
18082   return resultobj;
18083 fail:
18084   return NULL;
18085 }
18086
18087
18088 SWIGINTERN PyObject *_wrap_rad2degres(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18089   PyObject *resultobj = 0;
18090   double arg1 ;
18091   double val1 ;
18092   int ecode1 = 0 ;
18093   PyObject * obj0 = 0 ;
18094   double result;
18095
18096   if (!PyArg_ParseTuple(args,(char *)"O:rad2degres",&obj0)) SWIG_fail;
18097   ecode1 = SWIG_AsVal_double(obj0, &val1);
18098   if (!SWIG_IsOK(ecode1)) {
18099     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "rad2degres" "', argument " "1"" of type '" "double""'");
18100   }
18101   arg1 = static_cast< double >(val1);
18102   result = (double)Hex::rad2degres(arg1);
18103   resultobj = SWIG_From_double(static_cast< double >(result));
18104   return resultobj;
18105 fail:
18106   return NULL;
18107 }
18108
18109
18110 SWIGINTERN PyObject *_wrap_calc_norme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18111   PyObject *resultobj = 0;
18112   double *arg1 ;
18113   void *argp1 = 0 ;
18114   int res1 = 0 ;
18115   PyObject * obj0 = 0 ;
18116   double result;
18117
18118   if (!PyArg_ParseTuple(args,(char *)"O:calc_norme",&obj0)) SWIG_fail;
18119   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18120   if (!SWIG_IsOK(res1)) {
18121     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_norme" "', argument " "1"" of type '" "double []""'");
18122   }
18123   arg1 = reinterpret_cast< double * >(argp1);
18124   result = (double)Hex::calc_norme(arg1);
18125   resultobj = SWIG_From_double(static_cast< double >(result));
18126   return resultobj;
18127 fail:
18128   return NULL;
18129 }
18130
18131
18132 SWIGINTERN PyObject *_wrap_calc_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18133   PyObject *resultobj = 0;
18134   double *arg1 ;
18135   double *arg2 ;
18136   void *argp1 = 0 ;
18137   int res1 = 0 ;
18138   void *argp2 = 0 ;
18139   int res2 = 0 ;
18140   PyObject * obj0 = 0 ;
18141   PyObject * obj1 = 0 ;
18142   double result;
18143
18144   if (!PyArg_ParseTuple(args,(char *)"OO:calc_distance",&obj0,&obj1)) SWIG_fail;
18145   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18146   if (!SWIG_IsOK(res1)) {
18147     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_distance" "', argument " "1"" of type '" "double []""'");
18148   }
18149   arg1 = reinterpret_cast< double * >(argp1);
18150   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
18151   if (!SWIG_IsOK(res2)) {
18152     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_distance" "', argument " "2"" of type '" "double []""'");
18153   }
18154   arg2 = reinterpret_cast< double * >(argp2);
18155   result = (double)Hex::calc_distance(arg1,arg2);
18156   resultobj = SWIG_From_double(static_cast< double >(result));
18157   return resultobj;
18158 fail:
18159   return NULL;
18160 }
18161
18162
18163 SWIGINTERN PyObject *_wrap_calc_d2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18164   PyObject *resultobj = 0;
18165   double *arg1 ;
18166   double *arg2 ;
18167   void *argp1 = 0 ;
18168   int res1 = 0 ;
18169   void *argp2 = 0 ;
18170   int res2 = 0 ;
18171   PyObject * obj0 = 0 ;
18172   PyObject * obj1 = 0 ;
18173   double result;
18174
18175   if (!PyArg_ParseTuple(args,(char *)"OO:calc_d2",&obj0,&obj1)) SWIG_fail;
18176   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18177   if (!SWIG_IsOK(res1)) {
18178     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_d2" "', argument " "1"" of type '" "double []""'");
18179   }
18180   arg1 = reinterpret_cast< double * >(argp1);
18181   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
18182   if (!SWIG_IsOK(res2)) {
18183     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_d2" "', argument " "2"" of type '" "double []""'");
18184   }
18185   arg2 = reinterpret_cast< double * >(argp2);
18186   result = (double)Hex::calc_d2(arg1,arg2);
18187   resultobj = SWIG_From_double(static_cast< double >(result));
18188   return resultobj;
18189 fail:
18190   return NULL;
18191 }
18192
18193
18194 SWIGINTERN PyObject *_wrap_calc_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18195   PyObject *resultobj = 0;
18196   double *arg1 ;
18197   double *arg2 ;
18198   double *arg3 ;
18199   void *argp1 = 0 ;
18200   int res1 = 0 ;
18201   void *argp2 = 0 ;
18202   int res2 = 0 ;
18203   void *argp3 = 0 ;
18204   int res3 = 0 ;
18205   PyObject * obj0 = 0 ;
18206   PyObject * obj1 = 0 ;
18207   PyObject * obj2 = 0 ;
18208
18209   if (!PyArg_ParseTuple(args,(char *)"OOO:calc_vecteur",&obj0,&obj1,&obj2)) SWIG_fail;
18210   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18211   if (!SWIG_IsOK(res1)) {
18212     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_vecteur" "', argument " "1"" of type '" "double []""'");
18213   }
18214   arg1 = reinterpret_cast< double * >(argp1);
18215   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
18216   if (!SWIG_IsOK(res2)) {
18217     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_vecteur" "', argument " "2"" of type '" "double []""'");
18218   }
18219   arg2 = reinterpret_cast< double * >(argp2);
18220   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
18221   if (!SWIG_IsOK(res3)) {
18222     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "calc_vecteur" "', argument " "3"" of type '" "double []""'");
18223   }
18224   arg3 = reinterpret_cast< double * >(argp3);
18225   Hex::calc_vecteur(arg1,arg2,arg3);
18226   resultobj = SWIG_Py_Void();
18227   return resultobj;
18228 fail:
18229   return NULL;
18230 }
18231
18232
18233 SWIGINTERN PyObject *_wrap_copy_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18234   PyObject *resultobj = 0;
18235   double *arg1 ;
18236   double *arg2 ;
18237   void *argp1 = 0 ;
18238   int res1 = 0 ;
18239   void *argp2 = 0 ;
18240   int res2 = 0 ;
18241   PyObject * obj0 = 0 ;
18242   PyObject * obj1 = 0 ;
18243
18244   if (!PyArg_ParseTuple(args,(char *)"OO:copy_vecteur",&obj0,&obj1)) SWIG_fail;
18245   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18246   if (!SWIG_IsOK(res1)) {
18247     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_vecteur" "', argument " "1"" of type '" "double []""'");
18248   }
18249   arg1 = reinterpret_cast< double * >(argp1);
18250   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
18251   if (!SWIG_IsOK(res2)) {
18252     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copy_vecteur" "', argument " "2"" of type '" "double []""'");
18253   }
18254   arg2 = reinterpret_cast< double * >(argp2);
18255   Hex::copy_vecteur(arg1,arg2);
18256   resultobj = SWIG_Py_Void();
18257   return resultobj;
18258 fail:
18259   return NULL;
18260 }
18261
18262
18263 SWIGINTERN PyObject *_wrap_calc_milieu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18264   PyObject *resultobj = 0;
18265   double *arg1 ;
18266   double *arg2 ;
18267   double *arg3 ;
18268   void *argp1 = 0 ;
18269   int res1 = 0 ;
18270   void *argp2 = 0 ;
18271   int res2 = 0 ;
18272   void *argp3 = 0 ;
18273   int res3 = 0 ;
18274   PyObject * obj0 = 0 ;
18275   PyObject * obj1 = 0 ;
18276   PyObject * obj2 = 0 ;
18277
18278   if (!PyArg_ParseTuple(args,(char *)"OOO:calc_milieu",&obj0,&obj1,&obj2)) SWIG_fail;
18279   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18280   if (!SWIG_IsOK(res1)) {
18281     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_milieu" "', argument " "1"" of type '" "double []""'");
18282   }
18283   arg1 = reinterpret_cast< double * >(argp1);
18284   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
18285   if (!SWIG_IsOK(res2)) {
18286     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_milieu" "', argument " "2"" of type '" "double []""'");
18287   }
18288   arg2 = reinterpret_cast< double * >(argp2);
18289   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
18290   if (!SWIG_IsOK(res3)) {
18291     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "calc_milieu" "', argument " "3"" of type '" "double []""'");
18292   }
18293   arg3 = reinterpret_cast< double * >(argp3);
18294   Hex::calc_milieu(arg1,arg2,arg3);
18295   resultobj = SWIG_Py_Void();
18296   return resultobj;
18297 fail:
18298   return NULL;
18299 }
18300
18301
18302 SWIGINTERN PyObject *_wrap_normer_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18303   PyObject *resultobj = 0;
18304   double *arg1 ;
18305   void *argp1 = 0 ;
18306   int res1 = 0 ;
18307   PyObject * obj0 = 0 ;
18308   int result;
18309
18310   if (!PyArg_ParseTuple(args,(char *)"O:normer_vecteur",&obj0)) SWIG_fail;
18311   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18312   if (!SWIG_IsOK(res1)) {
18313     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "normer_vecteur" "', argument " "1"" of type '" "double []""'");
18314   }
18315   arg1 = reinterpret_cast< double * >(argp1);
18316   result = (int)Hex::normer_vecteur(arg1);
18317   resultobj = SWIG_From_int(static_cast< int >(result));
18318   return resultobj;
18319 fail:
18320   return NULL;
18321 }
18322
18323
18324 SWIGINTERN PyObject *_wrap_carre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18325   PyObject *resultobj = 0;
18326   double arg1 ;
18327   double val1 ;
18328   int ecode1 = 0 ;
18329   PyObject * obj0 = 0 ;
18330   double result;
18331
18332   if (!PyArg_ParseTuple(args,(char *)"O:carre",&obj0)) SWIG_fail;
18333   ecode1 = SWIG_AsVal_double(obj0, &val1);
18334   if (!SWIG_IsOK(ecode1)) {
18335     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "carre" "', argument " "1"" of type '" "double""'");
18336   }
18337   arg1 = static_cast< double >(val1);
18338   result = (double)Hex::carre(arg1);
18339   resultobj = SWIG_From_double(static_cast< double >(result));
18340   return resultobj;
18341 fail:
18342   return NULL;
18343 }
18344
18345
18346 SWIGINTERN PyObject *_wrap_same_coords__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18347   PyObject *resultobj = 0;
18348   double *arg1 = (double *) 0 ;
18349   double *arg2 = (double *) 0 ;
18350   double arg3 ;
18351   void *argp1 = 0 ;
18352   int res1 = 0 ;
18353   void *argp2 = 0 ;
18354   int res2 = 0 ;
18355   double val3 ;
18356   int ecode3 = 0 ;
18357   PyObject * obj0 = 0 ;
18358   PyObject * obj1 = 0 ;
18359   PyObject * obj2 = 0 ;
18360   bool result;
18361
18362   if (!PyArg_ParseTuple(args,(char *)"OOO:same_coords",&obj0,&obj1,&obj2)) SWIG_fail;
18363   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18364   if (!SWIG_IsOK(res1)) {
18365     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "same_coords" "', argument " "1"" of type '" "double *""'");
18366   }
18367   arg1 = reinterpret_cast< double * >(argp1);
18368   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
18369   if (!SWIG_IsOK(res2)) {
18370     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "same_coords" "', argument " "2"" of type '" "double *""'");
18371   }
18372   arg2 = reinterpret_cast< double * >(argp2);
18373   ecode3 = SWIG_AsVal_double(obj2, &val3);
18374   if (!SWIG_IsOK(ecode3)) {
18375     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "same_coords" "', argument " "3"" of type '" "double""'");
18376   }
18377   arg3 = static_cast< double >(val3);
18378   result = (bool)Hex::same_coords(arg1,arg2,arg3);
18379   resultobj = SWIG_From_bool(static_cast< bool >(result));
18380   return resultobj;
18381 fail:
18382   return NULL;
18383 }
18384
18385
18386 SWIGINTERN PyObject *_wrap_same_coords__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18387   PyObject *resultobj = 0;
18388   double *arg1 = (double *) 0 ;
18389   double *arg2 = (double *) 0 ;
18390   void *argp1 = 0 ;
18391   int res1 = 0 ;
18392   void *argp2 = 0 ;
18393   int res2 = 0 ;
18394   PyObject * obj0 = 0 ;
18395   PyObject * obj1 = 0 ;
18396   bool result;
18397
18398   if (!PyArg_ParseTuple(args,(char *)"OO:same_coords",&obj0,&obj1)) SWIG_fail;
18399   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18400   if (!SWIG_IsOK(res1)) {
18401     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "same_coords" "', argument " "1"" of type '" "double *""'");
18402   }
18403   arg1 = reinterpret_cast< double * >(argp1);
18404   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
18405   if (!SWIG_IsOK(res2)) {
18406     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "same_coords" "', argument " "2"" of type '" "double *""'");
18407   }
18408   arg2 = reinterpret_cast< double * >(argp2);
18409   result = (bool)Hex::same_coords(arg1,arg2);
18410   resultobj = SWIG_From_bool(static_cast< bool >(result));
18411   return resultobj;
18412 fail:
18413   return NULL;
18414 }
18415
18416
18417 SWIGINTERN PyObject *_wrap_same_coords(PyObject *self, PyObject *args) {
18418   int argc;
18419   PyObject *argv[4];
18420   int ii;
18421
18422   if (!PyTuple_Check(args)) SWIG_fail;
18423   argc = (int)PyObject_Length(args);
18424   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
18425     argv[ii] = PyTuple_GET_ITEM(args,ii);
18426   }
18427   if (argc == 2) {
18428     int _v;
18429     void *vptr = 0;
18430     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
18431     _v = SWIG_CheckState(res);
18432     if (_v) {
18433       void *vptr = 0;
18434       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
18435       _v = SWIG_CheckState(res);
18436       if (_v) {
18437         return _wrap_same_coords__SWIG_1(self, args);
18438       }
18439     }
18440   }
18441   if (argc == 3) {
18442     int _v;
18443     void *vptr = 0;
18444     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
18445     _v = SWIG_CheckState(res);
18446     if (_v) {
18447       void *vptr = 0;
18448       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
18449       _v = SWIG_CheckState(res);
18450       if (_v) {
18451         {
18452           int res = SWIG_AsVal_double(argv[2], NULL);
18453           _v = SWIG_CheckState(res);
18454         }
18455         if (_v) {
18456           return _wrap_same_coords__SWIG_0(self, args);
18457         }
18458       }
18459     }
18460   }
18461
18462 fail:
18463   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'same_coords'.\n"
18464     "  Possible C/C++ prototypes are:\n"
18465     "    Hex::same_coords(double *,double *,double)\n"
18466     "    Hex::same_coords(double *,double *)\n");
18467   return NULL;
18468 }
18469
18470
18471 SWIGINTERN PyObject *_wrap_requals__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18472   PyObject *resultobj = 0;
18473   double arg1 ;
18474   double arg2 ;
18475   double val1 ;
18476   int ecode1 = 0 ;
18477   double val2 ;
18478   int ecode2 = 0 ;
18479   PyObject * obj0 = 0 ;
18480   PyObject * obj1 = 0 ;
18481   bool result;
18482
18483   if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
18484   ecode1 = SWIG_AsVal_double(obj0, &val1);
18485   if (!SWIG_IsOK(ecode1)) {
18486     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "requals" "', argument " "1"" of type '" "double""'");
18487   }
18488   arg1 = static_cast< double >(val1);
18489   ecode2 = SWIG_AsVal_double(obj1, &val2);
18490   if (!SWIG_IsOK(ecode2)) {
18491     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "requals" "', argument " "2"" of type '" "double""'");
18492   }
18493   arg2 = static_cast< double >(val2);
18494   result = (bool)Hex::requals(arg1,arg2);
18495   resultobj = SWIG_From_bool(static_cast< bool >(result));
18496   return resultobj;
18497 fail:
18498   return NULL;
18499 }
18500
18501
18502 SWIGINTERN PyObject *_wrap_requals__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18503   PyObject *resultobj = 0;
18504   double *arg1 = (double *) 0 ;
18505   double *arg2 = (double *) 0 ;
18506   void *argp1 = 0 ;
18507   int res1 = 0 ;
18508   void *argp2 = 0 ;
18509   int res2 = 0 ;
18510   PyObject * obj0 = 0 ;
18511   PyObject * obj1 = 0 ;
18512   bool result;
18513
18514   if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
18515   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
18516   if (!SWIG_IsOK(res1)) {
18517     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "requals" "', argument " "1"" of type '" "double const *""'");
18518   }
18519   arg1 = reinterpret_cast< double * >(argp1);
18520   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
18521   if (!SWIG_IsOK(res2)) {
18522     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "requals" "', argument " "2"" of type '" "double const *""'");
18523   }
18524   arg2 = reinterpret_cast< double * >(argp2);
18525   result = (bool)Hex::requals((double const *)arg1,(double const *)arg2);
18526   resultobj = SWIG_From_bool(static_cast< bool >(result));
18527   return resultobj;
18528 fail:
18529   return NULL;
18530 }
18531
18532
18533 SWIGINTERN PyObject *_wrap_requals(PyObject *self, PyObject *args) {
18534   int argc;
18535   PyObject *argv[3];
18536   int ii;
18537
18538   if (!PyTuple_Check(args)) SWIG_fail;
18539   argc = (int)PyObject_Length(args);
18540   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
18541     argv[ii] = PyTuple_GET_ITEM(args,ii);
18542   }
18543   if (argc == 2) {
18544     int _v;
18545     void *vptr = 0;
18546     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
18547     _v = SWIG_CheckState(res);
18548     if (_v) {
18549       void *vptr = 0;
18550       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
18551       _v = SWIG_CheckState(res);
18552       if (_v) {
18553         return _wrap_requals__SWIG_1(self, args);
18554       }
18555     }
18556   }
18557   if (argc == 2) {
18558     int _v;
18559     {
18560       int res = SWIG_AsVal_double(argv[0], NULL);
18561       _v = SWIG_CheckState(res);
18562     }
18563     if (_v) {
18564       {
18565         int res = SWIG_AsVal_double(argv[1], NULL);
18566         _v = SWIG_CheckState(res);
18567       }
18568       if (_v) {
18569         return _wrap_requals__SWIG_0(self, args);
18570       }
18571     }
18572   }
18573
18574 fail:
18575   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'requals'.\n"
18576     "  Possible C/C++ prototypes are:\n"
18577     "    Hex::requals(double const,double const)\n"
18578     "    Hex::requals(double const *,double const *)\n");
18579   return NULL;
18580 }
18581
18582
18583 SWIGINTERN PyObject *_wrap_on_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18584   PyObject *resultobj = 0;
18585   bool result;
18586
18587   if (!PyArg_ParseTuple(args,(char *)":on_debug")) SWIG_fail;
18588   result = (bool)Hex::on_debug();
18589   resultobj = SWIG_From_bool(static_cast< bool >(result));
18590   return resultobj;
18591 fail:
18592   return NULL;
18593 }
18594
18595
18596 SWIGINTERN PyObject *_wrap_in_test(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18597   PyObject *resultobj = 0;
18598   bool result;
18599
18600   if (!PyArg_ParseTuple(args,(char *)":in_test")) SWIG_fail;
18601   result = (bool)Hex::in_test();
18602   resultobj = SWIG_From_bool(static_cast< bool >(result));
18603   return resultobj;
18604 fail:
18605   return NULL;
18606 }
18607
18608
18609 SWIGINTERN PyObject *_wrap_niv_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18610   PyObject *resultobj = 0;
18611   int result;
18612
18613   if (!PyArg_ParseTuple(args,(char *)":niv_debug")) SWIG_fail;
18614   result = (int)Hex::niv_debug();
18615   resultobj = SWIG_From_int(static_cast< int >(result));
18616   return resultobj;
18617 fail:
18618   return NULL;
18619 }
18620
18621
18622 SWIGINTERN PyObject *_wrap_set_minus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18623   PyObject *resultobj = 0;
18624   string *arg1 = 0 ;
18625   void *argp1 = 0 ;
18626   int res1 = 0 ;
18627   PyObject * obj0 = 0 ;
18628
18629   if (!PyArg_ParseTuple(args,(char *)"O:set_minus",&obj0)) SWIG_fail;
18630   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_string,  0 );
18631   if (!SWIG_IsOK(res1)) {
18632     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_minus" "', argument " "1"" of type '" "string &""'");
18633   }
18634   if (!argp1) {
18635     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_minus" "', argument " "1"" of type '" "string &""'");
18636   }
18637   arg1 = reinterpret_cast< string * >(argp1);
18638   Hex::set_minus(*arg1);
18639   resultobj = SWIG_Py_Void();
18640   return resultobj;
18641 fail:
18642   return NULL;
18643 }
18644
18645
18646 SWIGINTERN PyObject *_wrap_special_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18647   PyObject *resultobj = 0;
18648   bool result;
18649
18650   if (!PyArg_ParseTuple(args,(char *)":special_option")) SWIG_fail;
18651   result = (bool)Hex::special_option();
18652   resultobj = SWIG_From_bool(static_cast< bool >(result));
18653   return resultobj;
18654 fail:
18655   return NULL;
18656 }
18657
18658
18659 SWIGINTERN PyObject *_wrap_set_special_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18660   PyObject *resultobj = 0;
18661   bool arg1 ;
18662   bool val1 ;
18663   int ecode1 = 0 ;
18664   PyObject * obj0 = 0 ;
18665
18666   if (!PyArg_ParseTuple(args,(char *)"O:set_special_option",&obj0)) SWIG_fail;
18667   ecode1 = SWIG_AsVal_bool(obj0, &val1);
18668   if (!SWIG_IsOK(ecode1)) {
18669     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_special_option" "', argument " "1"" of type '" "bool""'");
18670   }
18671   arg1 = static_cast< bool >(val1);
18672   Hex::set_special_option(arg1);
18673   resultobj = SWIG_Py_Void();
18674   return resultobj;
18675 fail:
18676   return NULL;
18677 }
18678
18679
18680 SWIGINTERN PyObject *_wrap_sizeof_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18681   PyObject *resultobj = 0;
18682   cpchar arg1 = (cpchar) 0 ;
18683   int res1 ;
18684   char *buf1 = 0 ;
18685   int alloc1 = 0 ;
18686   PyObject * obj0 = 0 ;
18687   int result;
18688
18689   if (!PyArg_ParseTuple(args,(char *)"O:sizeof_file",&obj0)) SWIG_fail;
18690   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
18691   if (!SWIG_IsOK(res1)) {
18692     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sizeof_file" "', argument " "1"" of type '" "cpchar""'");
18693   }
18694   arg1 = reinterpret_cast< cpchar >(buf1);
18695   result = (int)Hex::sizeof_file((char const *)arg1);
18696   resultobj = SWIG_From_int(static_cast< int >(result));
18697   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18698   return resultobj;
18699 fail:
18700   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18701   return NULL;
18702 }
18703
18704
18705 SWIGINTERN PyObject *_wrap_read_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18706   PyObject *resultobj = 0;
18707   cpchar arg1 = (cpchar) 0 ;
18708   int *arg2 = 0 ;
18709   int res1 ;
18710   char *buf1 = 0 ;
18711   int alloc1 = 0 ;
18712   void *argp2 = 0 ;
18713   int res2 = 0 ;
18714   PyObject * obj0 = 0 ;
18715   PyObject * obj1 = 0 ;
18716   char *result = 0 ;
18717
18718   if (!PyArg_ParseTuple(args,(char *)"OO:read_file",&obj0,&obj1)) SWIG_fail;
18719   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
18720   if (!SWIG_IsOK(res1)) {
18721     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read_file" "', argument " "1"" of type '" "cpchar""'");
18722   }
18723   arg1 = reinterpret_cast< cpchar >(buf1);
18724   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
18725   if (!SWIG_IsOK(res2)) {
18726     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "read_file" "', argument " "2"" of type '" "int &""'");
18727   }
18728   if (!argp2) {
18729     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "read_file" "', argument " "2"" of type '" "int &""'");
18730   }
18731   arg2 = reinterpret_cast< int * >(argp2);
18732   result = (char *)Hex::read_file((char const *)arg1,*arg2);
18733   resultobj = SWIG_FromCharPtr((const char *)result);
18734   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18735   return resultobj;
18736 fail:
18737   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18738   return NULL;
18739 }
18740
18741
18742 SWIGINTERN PyObject *_wrap_get_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18743   PyObject *resultobj = 0;
18744   string *arg1 = 0 ;
18745   void *argp1 = 0 ;
18746   int res1 = 0 ;
18747   PyObject * obj0 = 0 ;
18748   cpchar result;
18749
18750   if (!PyArg_ParseTuple(args,(char *)"O:get_time",&obj0)) SWIG_fail;
18751   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_string,  0 );
18752   if (!SWIG_IsOK(res1)) {
18753     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_time" "', argument " "1"" of type '" "string &""'");
18754   }
18755   if (!argp1) {
18756     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get_time" "', argument " "1"" of type '" "string &""'");
18757   }
18758   arg1 = reinterpret_cast< string * >(argp1);
18759   result = (cpchar)Hex::get_time(*arg1);
18760   resultobj = SWIG_FromCharPtr((const char *)result);
18761   return resultobj;
18762 fail:
18763   return NULL;
18764 }
18765
18766
18767 SWIGINTERN PyObject *_wrap_make_basename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18768   PyObject *resultobj = 0;
18769   cpchar arg1 = (cpchar) 0 ;
18770   string *arg2 = 0 ;
18771   int res1 ;
18772   char *buf1 = 0 ;
18773   int alloc1 = 0 ;
18774   void *argp2 = 0 ;
18775   int res2 = 0 ;
18776   PyObject * obj0 = 0 ;
18777   PyObject * obj1 = 0 ;
18778   int result;
18779
18780   if (!PyArg_ParseTuple(args,(char *)"OO:make_basename",&obj0,&obj1)) SWIG_fail;
18781   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
18782   if (!SWIG_IsOK(res1)) {
18783     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_basename" "', argument " "1"" of type '" "cpchar""'");
18784   }
18785   arg1 = reinterpret_cast< cpchar >(buf1);
18786   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string,  0 );
18787   if (!SWIG_IsOK(res2)) {
18788     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_basename" "', argument " "2"" of type '" "string &""'");
18789   }
18790   if (!argp2) {
18791     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_basename" "', argument " "2"" of type '" "string &""'");
18792   }
18793   arg2 = reinterpret_cast< string * >(argp2);
18794   result = (int)Hex::make_basename((char const *)arg1,*arg2);
18795   resultobj = SWIG_From_int(static_cast< int >(result));
18796   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18797   return resultobj;
18798 fail:
18799   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18800   return NULL;
18801 }
18802
18803
18804 SWIGINTERN int Swig_var_Epsil_set(PyObject *) {
18805   SWIG_Error(SWIG_AttributeError,"Variable Epsil is read-only.");
18806   return 1;
18807 }
18808
18809
18810 SWIGINTERN PyObject *Swig_var_Epsil_get(void) {
18811   PyObject *pyobj = 0;
18812
18813   pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil));
18814   return pyobj;
18815 }
18816
18817
18818 SWIGINTERN int Swig_var_UnEpsil_set(PyObject *) {
18819   SWIG_Error(SWIG_AttributeError,"Variable UnEpsil is read-only.");
18820   return 1;
18821 }
18822
18823
18824 SWIGINTERN PyObject *Swig_var_UnEpsil_get(void) {
18825   PyObject *pyobj = 0;
18826
18827   pyobj = SWIG_From_double(static_cast< double >(Hex::UnEpsil));
18828   return pyobj;
18829 }
18830
18831
18832 SWIGINTERN int Swig_var_Epsil2_set(PyObject *) {
18833   SWIG_Error(SWIG_AttributeError,"Variable Epsil2 is read-only.");
18834   return 1;
18835 }
18836
18837
18838 SWIGINTERN PyObject *Swig_var_Epsil2_get(void) {
18839   PyObject *pyobj = 0;
18840
18841   pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil2));
18842   return pyobj;
18843 }
18844
18845
18846 SWIGINTERN PyObject *_wrap_EltBase_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18847   PyObject *resultobj = 0;
18848   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18849   void *argp1 = 0 ;
18850   int res1 = 0 ;
18851   PyObject * obj0 = 0 ;
18852   int result;
18853
18854   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countHexa",&obj0)) SWIG_fail;
18855   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18856   if (!SWIG_IsOK(res1)) {
18857     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countHexa" "', argument " "1"" of type '" "Hex::EltBase *""'");
18858   }
18859   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18860   result = (int)(arg1)->countHexa();
18861   resultobj = SWIG_From_int(static_cast< int >(result));
18862   return resultobj;
18863 fail:
18864   return NULL;
18865 }
18866
18867
18868 SWIGINTERN PyObject *_wrap_EltBase_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18869   PyObject *resultobj = 0;
18870   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18871   void *argp1 = 0 ;
18872   int res1 = 0 ;
18873   PyObject * obj0 = 0 ;
18874   int result;
18875
18876   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countQuad",&obj0)) SWIG_fail;
18877   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18878   if (!SWIG_IsOK(res1)) {
18879     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countQuad" "', argument " "1"" of type '" "Hex::EltBase *""'");
18880   }
18881   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18882   result = (int)(arg1)->countQuad();
18883   resultobj = SWIG_From_int(static_cast< int >(result));
18884   return resultobj;
18885 fail:
18886   return NULL;
18887 }
18888
18889
18890 SWIGINTERN PyObject *_wrap_EltBase_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18891   PyObject *resultobj = 0;
18892   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18893   void *argp1 = 0 ;
18894   int res1 = 0 ;
18895   PyObject * obj0 = 0 ;
18896   int result;
18897
18898   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countEdge",&obj0)) SWIG_fail;
18899   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18900   if (!SWIG_IsOK(res1)) {
18901     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countEdge" "', argument " "1"" of type '" "Hex::EltBase *""'");
18902   }
18903   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18904   result = (int)(arg1)->countEdge();
18905   resultobj = SWIG_From_int(static_cast< int >(result));
18906   return resultobj;
18907 fail:
18908   return NULL;
18909 }
18910
18911
18912 SWIGINTERN PyObject *_wrap_EltBase_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18913   PyObject *resultobj = 0;
18914   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18915   void *argp1 = 0 ;
18916   int res1 = 0 ;
18917   PyObject * obj0 = 0 ;
18918   int result;
18919
18920   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countVertex",&obj0)) SWIG_fail;
18921   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18922   if (!SWIG_IsOK(res1)) {
18923     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countVertex" "', argument " "1"" of type '" "Hex::EltBase *""'");
18924   }
18925   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18926   result = (int)(arg1)->countVertex();
18927   resultobj = SWIG_From_int(static_cast< int >(result));
18928   return resultobj;
18929 fail:
18930   return NULL;
18931 }
18932
18933
18934 SWIGINTERN PyObject *_wrap_EltBase_setError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18935   PyObject *resultobj = 0;
18936   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18937   int arg2 ;
18938   void *argp1 = 0 ;
18939   int res1 = 0 ;
18940   int val2 ;
18941   int ecode2 = 0 ;
18942   PyObject * obj0 = 0 ;
18943   PyObject * obj1 = 0 ;
18944
18945   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setError",&obj0,&obj1)) SWIG_fail;
18946   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18947   if (!SWIG_IsOK(res1)) {
18948     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setError" "', argument " "1"" of type '" "Hex::EltBase *""'");
18949   }
18950   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18951   ecode2 = SWIG_AsVal_int(obj1, &val2);
18952   if (!SWIG_IsOK(ecode2)) {
18953     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setError" "', argument " "2"" of type '" "int""'");
18954   }
18955   arg2 = static_cast< int >(val2);
18956   (arg1)->setError(arg2);
18957   resultobj = SWIG_Py_Void();
18958   return resultobj;
18959 fail:
18960   return NULL;
18961 }
18962
18963
18964 SWIGINTERN PyObject *_wrap_EltBase_setError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18965   PyObject *resultobj = 0;
18966   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18967   void *argp1 = 0 ;
18968   int res1 = 0 ;
18969   PyObject * obj0 = 0 ;
18970
18971   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_setError",&obj0)) SWIG_fail;
18972   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18973   if (!SWIG_IsOK(res1)) {
18974     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setError" "', argument " "1"" of type '" "Hex::EltBase *""'");
18975   }
18976   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18977   (arg1)->setError();
18978   resultobj = SWIG_Py_Void();
18979   return resultobj;
18980 fail:
18981   return NULL;
18982 }
18983
18984
18985 SWIGINTERN PyObject *_wrap_EltBase_setError(PyObject *self, PyObject *args) {
18986   int argc;
18987   PyObject *argv[3];
18988   int ii;
18989
18990   if (!PyTuple_Check(args)) SWIG_fail;
18991   argc = (int)PyObject_Length(args);
18992   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
18993     argv[ii] = PyTuple_GET_ITEM(args,ii);
18994   }
18995   if (argc == 1) {
18996     int _v;
18997     void *vptr = 0;
18998     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
18999     _v = SWIG_CheckState(res);
19000     if (_v) {
19001       return _wrap_EltBase_setError__SWIG_1(self, args);
19002     }
19003   }
19004   if (argc == 2) {
19005     int _v;
19006     void *vptr = 0;
19007     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19008     _v = SWIG_CheckState(res);
19009     if (_v) {
19010       {
19011         int res = SWIG_AsVal_int(argv[1], NULL);
19012         _v = SWIG_CheckState(res);
19013       }
19014       if (_v) {
19015         return _wrap_EltBase_setError__SWIG_0(self, args);
19016       }
19017     }
19018   }
19019
19020 fail:
19021   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_setError'.\n"
19022     "  Possible C/C++ prototypes are:\n"
19023     "    setError(Hex::EltBase *,int)\n"
19024     "    setError(Hex::EltBase *)\n");
19025   return NULL;
19026 }
19027
19028
19029 SWIGINTERN PyObject *_wrap_EltBase_getError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19030   PyObject *resultobj = 0;
19031   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19032   void *argp1 = 0 ;
19033   int res1 = 0 ;
19034   PyObject * obj0 = 0 ;
19035   int result;
19036
19037   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getError",&obj0)) SWIG_fail;
19038   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19039   if (!SWIG_IsOK(res1)) {
19040     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getError" "', argument " "1"" of type '" "Hex::EltBase *""'");
19041   }
19042   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19043   result = (int)(arg1)->getError();
19044   resultobj = SWIG_From_int(static_cast< int >(result));
19045   return resultobj;
19046 fail:
19047   return NULL;
19048 }
19049
19050
19051 SWIGINTERN PyObject *_wrap_EltBase_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19052   PyObject *resultobj = 0;
19053   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19054   void *argp1 = 0 ;
19055   int res1 = 0 ;
19056   PyObject * obj0 = 0 ;
19057   bool result;
19058
19059   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isValid",&obj0)) SWIG_fail;
19060   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19061   if (!SWIG_IsOK(res1)) {
19062     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isValid" "', argument " "1"" of type '" "Hex::EltBase *""'");
19063   }
19064   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19065   result = (bool)(arg1)->isValid();
19066   resultobj = SWIG_From_bool(static_cast< bool >(result));
19067   return resultobj;
19068 fail:
19069   return NULL;
19070 }
19071
19072
19073 SWIGINTERN PyObject *_wrap_EltBase_isBad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19074   PyObject *resultobj = 0;
19075   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19076   void *argp1 = 0 ;
19077   int res1 = 0 ;
19078   PyObject * obj0 = 0 ;
19079   bool result;
19080
19081   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isBad",&obj0)) SWIG_fail;
19082   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19083   if (!SWIG_IsOK(res1)) {
19084     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isBad" "', argument " "1"" of type '" "Hex::EltBase *""'");
19085   }
19086   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19087   result = (bool)(arg1)->isBad();
19088   resultobj = SWIG_From_bool(static_cast< bool >(result));
19089   return resultobj;
19090 fail:
19091   return NULL;
19092 }
19093
19094
19095 SWIGINTERN PyObject *_wrap_EltBase_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19096   PyObject *resultobj = 0;
19097   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19098   void *argp1 = 0 ;
19099   int res1 = 0 ;
19100   PyObject * obj0 = 0 ;
19101
19102   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_duplicate",&obj0)) SWIG_fail;
19103   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19104   if (!SWIG_IsOK(res1)) {
19105     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_duplicate" "', argument " "1"" of type '" "Hex::EltBase *""'");
19106   }
19107   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19108   (arg1)->duplicate();
19109   resultobj = SWIG_Py_Void();
19110   return resultobj;
19111 fail:
19112   return NULL;
19113 }
19114
19115
19116 SWIGINTERN PyObject *_wrap_EltBase_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19117   PyObject *resultobj = 0;
19118   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19119   void *argp1 = 0 ;
19120   int res1 = 0 ;
19121   PyObject * obj0 = 0 ;
19122
19123   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_clearAssociation",&obj0)) SWIG_fail;
19124   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19125   if (!SWIG_IsOK(res1)) {
19126     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_clearAssociation" "', argument " "1"" of type '" "Hex::EltBase *""'");
19127   }
19128   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19129   (arg1)->clearAssociation();
19130   resultobj = SWIG_Py_Void();
19131   return resultobj;
19132 fail:
19133   return NULL;
19134 }
19135
19136
19137 SWIGINTERN PyObject *_wrap_EltBase_replaceEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19138   PyObject *resultobj = 0;
19139   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19140   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
19141   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
19142   void *argp1 = 0 ;
19143   int res1 = 0 ;
19144   void *argp2 = 0 ;
19145   int res2 = 0 ;
19146   void *argp3 = 0 ;
19147   int res3 = 0 ;
19148   PyObject * obj0 = 0 ;
19149   PyObject * obj1 = 0 ;
19150   PyObject * obj2 = 0 ;
19151
19152   if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_replaceEdge",&obj0,&obj1,&obj2)) SWIG_fail;
19153   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19154   if (!SWIG_IsOK(res1)) {
19155     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_replaceEdge" "', argument " "1"" of type '" "Hex::EltBase *""'");
19156   }
19157   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19158   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
19159   if (!SWIG_IsOK(res2)) {
19160     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_replaceEdge" "', argument " "2"" of type '" "Hex::Edge *""'");
19161   }
19162   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
19163   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
19164   if (!SWIG_IsOK(res3)) {
19165     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_replaceEdge" "', argument " "3"" of type '" "Hex::Edge *""'");
19166   }
19167   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
19168   (arg1)->replaceEdge(arg2,arg3);
19169   resultobj = SWIG_Py_Void();
19170   return resultobj;
19171 fail:
19172   return NULL;
19173 }
19174
19175
19176 SWIGINTERN PyObject *_wrap_EltBase_replaceVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19177   PyObject *resultobj = 0;
19178   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19179   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
19180   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
19181   void *argp1 = 0 ;
19182   int res1 = 0 ;
19183   void *argp2 = 0 ;
19184   int res2 = 0 ;
19185   void *argp3 = 0 ;
19186   int res3 = 0 ;
19187   PyObject * obj0 = 0 ;
19188   PyObject * obj1 = 0 ;
19189   PyObject * obj2 = 0 ;
19190
19191   if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_replaceVertex",&obj0,&obj1,&obj2)) SWIG_fail;
19192   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19193   if (!SWIG_IsOK(res1)) {
19194     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_replaceVertex" "', argument " "1"" of type '" "Hex::EltBase *""'");
19195   }
19196   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19197   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19198   if (!SWIG_IsOK(res2)) {
19199     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_replaceVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
19200   }
19201   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
19202   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19203   if (!SWIG_IsOK(res3)) {
19204     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_replaceVertex" "', argument " "3"" of type '" "Hex::Vertex *""'");
19205   }
19206   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
19207   (arg1)->replaceVertex(arg2,arg3);
19208   resultobj = SWIG_Py_Void();
19209   return resultobj;
19210 fail:
19211   return NULL;
19212 }
19213
19214
19215 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19216   PyObject *resultobj = 0;
19217   Hex::Document *arg1 = (Hex::Document *) 0 ;
19218   Hex::EnumElt arg2 ;
19219   void *argp1 = 0 ;
19220   int res1 = 0 ;
19221   int val2 ;
19222   int ecode2 = 0 ;
19223   PyObject * obj0 = 0 ;
19224   PyObject * obj1 = 0 ;
19225   Hex::EltBase *result = 0 ;
19226
19227   if (!PyArg_ParseTuple(args,(char *)"OO:new_EltBase",&obj0,&obj1)) SWIG_fail;
19228   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
19229   if (!SWIG_IsOK(res1)) {
19230     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::Document *""'");
19231   }
19232   arg1 = reinterpret_cast< Hex::Document * >(argp1);
19233   ecode2 = SWIG_AsVal_int(obj1, &val2);
19234   if (!SWIG_IsOK(ecode2)) {
19235     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EltBase" "', argument " "2"" of type '" "Hex::EnumElt""'");
19236   }
19237   arg2 = static_cast< Hex::EnumElt >(val2);
19238   result = (Hex::EltBase *)new Hex::EltBase(arg1,arg2);
19239   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
19240   return resultobj;
19241 fail:
19242   return NULL;
19243 }
19244
19245
19246 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19247   PyObject *resultobj = 0;
19248   Hex::Document *arg1 = (Hex::Document *) 0 ;
19249   void *argp1 = 0 ;
19250   int res1 = 0 ;
19251   PyObject * obj0 = 0 ;
19252   Hex::EltBase *result = 0 ;
19253
19254   if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
19255   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
19256   if (!SWIG_IsOK(res1)) {
19257     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::Document *""'");
19258   }
19259   arg1 = reinterpret_cast< Hex::Document * >(argp1);
19260   result = (Hex::EltBase *)new Hex::EltBase(arg1);
19261   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
19262   return resultobj;
19263 fail:
19264   return NULL;
19265 }
19266
19267
19268 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19269   PyObject *resultobj = 0;
19270   Hex::EnumElt arg1 ;
19271   int val1 ;
19272   int ecode1 = 0 ;
19273   PyObject * obj0 = 0 ;
19274   Hex::EltBase *result = 0 ;
19275
19276   if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
19277   ecode1 = SWIG_AsVal_int(obj0, &val1);
19278   if (!SWIG_IsOK(ecode1)) {
19279     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::EnumElt""'");
19280   }
19281   arg1 = static_cast< Hex::EnumElt >(val1);
19282   result = (Hex::EltBase *)new Hex::EltBase(arg1);
19283   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
19284   return resultobj;
19285 fail:
19286   return NULL;
19287 }
19288
19289
19290 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19291   PyObject *resultobj = 0;
19292   Hex::EltBase *result = 0 ;
19293
19294   if (!PyArg_ParseTuple(args,(char *)":new_EltBase")) SWIG_fail;
19295   result = (Hex::EltBase *)new Hex::EltBase();
19296   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
19297   return resultobj;
19298 fail:
19299   return NULL;
19300 }
19301
19302
19303 SWIGINTERN PyObject *_wrap_new_EltBase(PyObject *self, PyObject *args) {
19304   int argc;
19305   PyObject *argv[3];
19306   int ii;
19307
19308   if (!PyTuple_Check(args)) SWIG_fail;
19309   argc = (int)PyObject_Length(args);
19310   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
19311     argv[ii] = PyTuple_GET_ITEM(args,ii);
19312   }
19313   if (argc == 0) {
19314     return _wrap_new_EltBase__SWIG_3(self, args);
19315   }
19316   if (argc == 1) {
19317     int _v;
19318     void *vptr = 0;
19319     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
19320     _v = SWIG_CheckState(res);
19321     if (_v) {
19322       return _wrap_new_EltBase__SWIG_1(self, args);
19323     }
19324   }
19325   if (argc == 1) {
19326     int _v;
19327     {
19328       int res = SWIG_AsVal_int(argv[0], NULL);
19329       _v = SWIG_CheckState(res);
19330     }
19331     if (_v) {
19332       return _wrap_new_EltBase__SWIG_2(self, args);
19333     }
19334   }
19335   if (argc == 2) {
19336     int _v;
19337     void *vptr = 0;
19338     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
19339     _v = SWIG_CheckState(res);
19340     if (_v) {
19341       {
19342         int res = SWIG_AsVal_int(argv[1], NULL);
19343         _v = SWIG_CheckState(res);
19344       }
19345       if (_v) {
19346         return _wrap_new_EltBase__SWIG_0(self, args);
19347       }
19348     }
19349   }
19350
19351 fail:
19352   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EltBase'.\n"
19353     "  Possible C/C++ prototypes are:\n"
19354     "    Hex::EltBase(Hex::Document *,Hex::EnumElt)\n"
19355     "    Hex::EltBase(Hex::Document *)\n"
19356     "    Hex::EltBase(Hex::EnumElt)\n"
19357     "    Hex::EltBase()\n");
19358   return NULL;
19359 }
19360
19361
19362 SWIGINTERN PyObject *_wrap_delete_EltBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19363   PyObject *resultobj = 0;
19364   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19365   void *argp1 = 0 ;
19366   int res1 = 0 ;
19367   PyObject * obj0 = 0 ;
19368
19369   if (!PyArg_ParseTuple(args,(char *)"O:delete_EltBase",&obj0)) SWIG_fail;
19370   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_DISOWN |  0 );
19371   if (!SWIG_IsOK(res1)) {
19372     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EltBase" "', argument " "1"" of type '" "Hex::EltBase *""'");
19373   }
19374   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19375   delete arg1;
19376   resultobj = SWIG_Py_Void();
19377   return resultobj;
19378 fail:
19379   return NULL;
19380 }
19381
19382
19383 SWIGINTERN PyObject *_wrap_EltBase_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19384   PyObject *resultobj = 0;
19385   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19386   void *argp1 = 0 ;
19387   int res1 = 0 ;
19388   PyObject * obj0 = 0 ;
19389
19390   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_remove",&obj0)) SWIG_fail;
19391   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19392   if (!SWIG_IsOK(res1)) {
19393     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_remove" "', argument " "1"" of type '" "Hex::EltBase *""'");
19394   }
19395   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19396   (arg1)->remove();
19397   resultobj = SWIG_Py_Void();
19398   return resultobj;
19399 fail:
19400   return NULL;
19401 }
19402
19403
19404 SWIGINTERN PyObject *_wrap_EltBase_suppress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19405   PyObject *resultobj = 0;
19406   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19407   void *argp1 = 0 ;
19408   int res1 = 0 ;
19409   PyObject * obj0 = 0 ;
19410
19411   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_suppress",&obj0)) SWIG_fail;
19412   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19413   if (!SWIG_IsOK(res1)) {
19414     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_suppress" "', argument " "1"" of type '" "Hex::EltBase *""'");
19415   }
19416   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19417   (arg1)->suppress();
19418   resultobj = SWIG_Py_Void();
19419   return resultobj;
19420 fail:
19421   return NULL;
19422 }
19423
19424
19425 SWIGINTERN PyObject *_wrap_EltBase_dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19426   PyObject *resultobj = 0;
19427   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19428   void *argp1 = 0 ;
19429   int res1 = 0 ;
19430   PyObject * obj0 = 0 ;
19431
19432   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dump",&obj0)) SWIG_fail;
19433   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19434   if (!SWIG_IsOK(res1)) {
19435     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dump" "', argument " "1"" of type '" "Hex::EltBase *""'");
19436   }
19437   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19438   (arg1)->dump();
19439   resultobj = SWIG_Py_Void();
19440   return resultobj;
19441 fail:
19442   return NULL;
19443 }
19444
19445
19446 SWIGINTERN PyObject *_wrap_EltBase_saveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19447   PyObject *resultobj = 0;
19448   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19449   Hex::XmlWriter *arg2 = (Hex::XmlWriter *) 0 ;
19450   void *argp1 = 0 ;
19451   int res1 = 0 ;
19452   void *argp2 = 0 ;
19453   int res2 = 0 ;
19454   PyObject * obj0 = 0 ;
19455   PyObject * obj1 = 0 ;
19456
19457   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_saveXml",&obj0,&obj1)) SWIG_fail;
19458   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19459   if (!SWIG_IsOK(res1)) {
19460     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_saveXml" "', argument " "1"" of type '" "Hex::EltBase *""'");
19461   }
19462   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19463   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__XmlWriter, 0 |  0 );
19464   if (!SWIG_IsOK(res2)) {
19465     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_saveXml" "', argument " "2"" of type '" "Hex::XmlWriter *""'");
19466   }
19467   arg2 = reinterpret_cast< Hex::XmlWriter * >(argp2);
19468   (arg1)->saveXml(arg2);
19469   resultobj = SWIG_Py_Void();
19470   return resultobj;
19471 fail:
19472   return NULL;
19473 }
19474
19475
19476 SWIGINTERN PyObject *_wrap_EltBase_majReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19477   PyObject *resultobj = 0;
19478   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19479   void *argp1 = 0 ;
19480   int res1 = 0 ;
19481   PyObject * obj0 = 0 ;
19482
19483   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_majReferences",&obj0)) SWIG_fail;
19484   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19485   if (!SWIG_IsOK(res1)) {
19486     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_majReferences" "', argument " "1"" of type '" "Hex::EltBase *""'");
19487   }
19488   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19489   (arg1)->majReferences();
19490   resultobj = SWIG_Py_Void();
19491   return resultobj;
19492 fail:
19493   return NULL;
19494 }
19495
19496
19497 SWIGINTERN PyObject *_wrap_EltBase_makeVarName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19498   PyObject *resultobj = 0;
19499   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19500   char *arg2 = (char *) 0 ;
19501   void *argp1 = 0 ;
19502   int res1 = 0 ;
19503   int res2 ;
19504   char *buf2 = 0 ;
19505   int alloc2 = 0 ;
19506   PyObject * obj0 = 0 ;
19507   PyObject * obj1 = 0 ;
19508   char *result = 0 ;
19509
19510   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_makeVarName",&obj0,&obj1)) SWIG_fail;
19511   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19512   if (!SWIG_IsOK(res1)) {
19513     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_makeVarName" "', argument " "1"" of type '" "Hex::EltBase *""'");
19514   }
19515   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19516   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
19517   if (!SWIG_IsOK(res2)) {
19518     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_makeVarName" "', argument " "2"" of type '" "char *""'");
19519   }
19520   arg2 = reinterpret_cast< char * >(buf2);
19521   result = (char *)(arg1)->makeVarName(arg2);
19522   resultobj = SWIG_FromCharPtr((const char *)result);
19523   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19524   return resultobj;
19525 fail:
19526   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19527   return NULL;
19528 }
19529
19530
19531 SWIGINTERN PyObject *_wrap_EltBase_makeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19532   PyObject *resultobj = 0;
19533   int arg1 ;
19534   int arg2 ;
19535   char *arg3 = (char *) 0 ;
19536   int val1 ;
19537   int ecode1 = 0 ;
19538   int val2 ;
19539   int ecode2 = 0 ;
19540   int res3 ;
19541   char *buf3 = 0 ;
19542   int alloc3 = 0 ;
19543   PyObject * obj0 = 0 ;
19544   PyObject * obj1 = 0 ;
19545   PyObject * obj2 = 0 ;
19546   char *result = 0 ;
19547
19548   if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_makeName",&obj0,&obj1,&obj2)) SWIG_fail;
19549   ecode1 = SWIG_AsVal_int(obj0, &val1);
19550   if (!SWIG_IsOK(ecode1)) {
19551     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EltBase_makeName" "', argument " "1"" of type '" "int""'");
19552   }
19553   arg1 = static_cast< int >(val1);
19554   ecode2 = SWIG_AsVal_int(obj1, &val2);
19555   if (!SWIG_IsOK(ecode2)) {
19556     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_makeName" "', argument " "2"" of type '" "int""'");
19557   }
19558   arg2 = static_cast< int >(val2);
19559   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
19560   if (!SWIG_IsOK(res3)) {
19561     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_makeName" "', argument " "3"" of type '" "char *""'");
19562   }
19563   arg3 = reinterpret_cast< char * >(buf3);
19564   result = (char *)Hex::EltBase::makeName(arg1,arg2,arg3);
19565   resultobj = SWIG_FromCharPtr((const char *)result);
19566   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19567   return resultobj;
19568 fail:
19569   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19570   return NULL;
19571 }
19572
19573
19574 SWIGINTERN PyObject *_wrap_EltBase_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19575   PyObject *resultobj = 0;
19576   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19577   void *argp1 = 0 ;
19578   int res1 = 0 ;
19579   PyObject * obj0 = 0 ;
19580   Hex::EltBase *result = 0 ;
19581
19582   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_next",&obj0)) SWIG_fail;
19583   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19584   if (!SWIG_IsOK(res1)) {
19585     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_next" "', argument " "1"" of type '" "Hex::EltBase *""'");
19586   }
19587   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19588   result = (Hex::EltBase *)(arg1)->next();
19589   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19590   return resultobj;
19591 fail:
19592   return NULL;
19593 }
19594
19595
19596 SWIGINTERN PyObject *_wrap_EltBase_setNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19597   PyObject *resultobj = 0;
19598   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19599   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
19600   void *argp1 = 0 ;
19601   int res1 = 0 ;
19602   void *argp2 = 0 ;
19603   int res2 = 0 ;
19604   PyObject * obj0 = 0 ;
19605   PyObject * obj1 = 0 ;
19606
19607   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setNext",&obj0,&obj1)) SWIG_fail;
19608   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19609   if (!SWIG_IsOK(res1)) {
19610     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setNext" "', argument " "1"" of type '" "Hex::EltBase *""'");
19611   }
19612   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19613   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19614   if (!SWIG_IsOK(res2)) {
19615     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setNext" "', argument " "2"" of type '" "Hex::EltBase *""'");
19616   }
19617   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
19618   (arg1)->setNext(arg2);
19619   resultobj = SWIG_Py_Void();
19620   return resultobj;
19621 fail:
19622   return NULL;
19623 }
19624
19625
19626 SWIGINTERN PyObject *_wrap_EltBase_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19627   PyObject *resultobj = 0;
19628   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19629   void *argp1 = 0 ;
19630   int res1 = 0 ;
19631   PyObject * obj0 = 0 ;
19632   int result;
19633
19634   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getId",&obj0)) SWIG_fail;
19635   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19636   if (!SWIG_IsOK(res1)) {
19637     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getId" "', argument " "1"" of type '" "Hex::EltBase *""'");
19638   }
19639   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19640   result = (int)(arg1)->getId();
19641   resultobj = SWIG_From_int(static_cast< int >(result));
19642   return resultobj;
19643 fail:
19644   return NULL;
19645 }
19646
19647
19648 SWIGINTERN PyObject *_wrap_EltBase_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19649   PyObject *resultobj = 0;
19650   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19651   int arg2 ;
19652   void *argp1 = 0 ;
19653   int res1 = 0 ;
19654   int val2 ;
19655   int ecode2 = 0 ;
19656   PyObject * obj0 = 0 ;
19657   PyObject * obj1 = 0 ;
19658
19659   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setId",&obj0,&obj1)) SWIG_fail;
19660   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19661   if (!SWIG_IsOK(res1)) {
19662     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setId" "', argument " "1"" of type '" "Hex::EltBase *""'");
19663   }
19664   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19665   ecode2 = SWIG_AsVal_int(obj1, &val2);
19666   if (!SWIG_IsOK(ecode2)) {
19667     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setId" "', argument " "2"" of type '" "int""'");
19668   }
19669   arg2 = static_cast< int >(val2);
19670   (arg1)->setId(arg2);
19671   resultobj = SWIG_Py_Void();
19672   return resultobj;
19673 fail:
19674   return NULL;
19675 }
19676
19677
19678 SWIGINTERN PyObject *_wrap_EltBase_dad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19679   PyObject *resultobj = 0;
19680   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19681   void *argp1 = 0 ;
19682   int res1 = 0 ;
19683   PyObject * obj0 = 0 ;
19684   Hex::Document *result = 0 ;
19685
19686   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dad",&obj0)) SWIG_fail;
19687   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19688   if (!SWIG_IsOK(res1)) {
19689     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dad" "', argument " "1"" of type '" "Hex::EltBase *""'");
19690   }
19691   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19692   result = (Hex::Document *)(arg1)->dad();
19693   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
19694   return resultobj;
19695 fail:
19696   return NULL;
19697 }
19698
19699
19700 SWIGINTERN PyObject *_wrap_EltBase_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19701   PyObject *resultobj = 0;
19702   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19703   void *argp1 = 0 ;
19704   int res1 = 0 ;
19705   PyObject * obj0 = 0 ;
19706   Hex::EnumElt result;
19707
19708   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getType",&obj0)) SWIG_fail;
19709   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19710   if (!SWIG_IsOK(res1)) {
19711     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getType" "', argument " "1"" of type '" "Hex::EltBase *""'");
19712   }
19713   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19714   result = (Hex::EnumElt)(arg1)->getType();
19715   resultobj = SWIG_From_int(static_cast< int >(result));
19716   return resultobj;
19717 fail:
19718   return NULL;
19719 }
19720
19721
19722 SWIGINTERN PyObject *_wrap_EltBase_isHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19723   PyObject *resultobj = 0;
19724   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19725   void *argp1 = 0 ;
19726   int res1 = 0 ;
19727   PyObject * obj0 = 0 ;
19728   bool result;
19729
19730   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isHere",&obj0)) SWIG_fail;
19731   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19732   if (!SWIG_IsOK(res1)) {
19733     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isHere" "', argument " "1"" of type '" "Hex::EltBase *""'");
19734   }
19735   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19736   result = (bool)(arg1)->isHere();
19737   resultobj = SWIG_From_bool(static_cast< bool >(result));
19738   return resultobj;
19739 fail:
19740   return NULL;
19741 }
19742
19743
19744 SWIGINTERN PyObject *_wrap_EltBase_isDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19745   PyObject *resultobj = 0;
19746   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19747   void *argp1 = 0 ;
19748   int res1 = 0 ;
19749   PyObject * obj0 = 0 ;
19750   bool result;
19751
19752   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isDeleted",&obj0)) SWIG_fail;
19753   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19754   if (!SWIG_IsOK(res1)) {
19755     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isDeleted" "', argument " "1"" of type '" "Hex::EltBase *""'");
19756   }
19757   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19758   result = (bool)(arg1)->isDeleted();
19759   resultobj = SWIG_From_bool(static_cast< bool >(result));
19760   return resultobj;
19761 fail:
19762   return NULL;
19763 }
19764
19765
19766 SWIGINTERN PyObject *_wrap_EltBase_razReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19767   PyObject *resultobj = 0;
19768   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19769   void *argp1 = 0 ;
19770   int res1 = 0 ;
19771   PyObject * obj0 = 0 ;
19772
19773   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_razReferences",&obj0)) SWIG_fail;
19774   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19775   if (!SWIG_IsOK(res1)) {
19776     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_razReferences" "', argument " "1"" of type '" "Hex::EltBase *""'");
19777   }
19778   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19779   (arg1)->razReferences();
19780   resultobj = SWIG_Py_Void();
19781   return resultobj;
19782 fail:
19783   return NULL;
19784 }
19785
19786
19787 SWIGINTERN PyObject *_wrap_EltBase_addParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19788   PyObject *resultobj = 0;
19789   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19790   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
19791   void *argp1 = 0 ;
19792   int res1 = 0 ;
19793   void *argp2 = 0 ;
19794   int res2 = 0 ;
19795   PyObject * obj0 = 0 ;
19796   PyObject * obj1 = 0 ;
19797
19798   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_addParent",&obj0,&obj1)) SWIG_fail;
19799   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19800   if (!SWIG_IsOK(res1)) {
19801     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_addParent" "', argument " "1"" of type '" "Hex::EltBase *""'");
19802   }
19803   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19804   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19805   if (!SWIG_IsOK(res2)) {
19806     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_addParent" "', argument " "2"" of type '" "Hex::EltBase *""'");
19807   }
19808   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
19809   (arg1)->addParent(arg2);
19810   resultobj = SWIG_Py_Void();
19811   return resultobj;
19812 fail:
19813   return NULL;
19814 }
19815
19816
19817 SWIGINTERN PyObject *_wrap_EltBase_getNbrParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19818   PyObject *resultobj = 0;
19819   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19820   void *argp1 = 0 ;
19821   int res1 = 0 ;
19822   PyObject * obj0 = 0 ;
19823   int result;
19824
19825   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNbrParents",&obj0)) SWIG_fail;
19826   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19827   if (!SWIG_IsOK(res1)) {
19828     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getNbrParents" "', argument " "1"" of type '" "Hex::EltBase *""'");
19829   }
19830   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19831   result = (int)(arg1)->getNbrParents();
19832   resultobj = SWIG_From_int(static_cast< int >(result));
19833   return resultobj;
19834 fail:
19835   return NULL;
19836 }
19837
19838
19839 SWIGINTERN PyObject *_wrap_EltBase_hasParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19840   PyObject *resultobj = 0;
19841   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19842   void *argp1 = 0 ;
19843   int res1 = 0 ;
19844   PyObject * obj0 = 0 ;
19845   bool result;
19846
19847   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_hasParents",&obj0)) SWIG_fail;
19848   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19849   if (!SWIG_IsOK(res1)) {
19850     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_hasParents" "', argument " "1"" of type '" "Hex::EltBase *""'");
19851   }
19852   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19853   result = (bool)(arg1)->hasParents();
19854   resultobj = SWIG_From_bool(static_cast< bool >(result));
19855   return resultobj;
19856 fail:
19857   return NULL;
19858 }
19859
19860
19861 SWIGINTERN PyObject *_wrap_EltBase_getFather(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19862   PyObject *resultobj = 0;
19863   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19864   int arg2 ;
19865   void *argp1 = 0 ;
19866   int res1 = 0 ;
19867   int val2 ;
19868   int ecode2 = 0 ;
19869   PyObject * obj0 = 0 ;
19870   PyObject * obj1 = 0 ;
19871   Hex::EltBase *result = 0 ;
19872
19873   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getFather",&obj0,&obj1)) SWIG_fail;
19874   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19875   if (!SWIG_IsOK(res1)) {
19876     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getFather" "', argument " "1"" of type '" "Hex::EltBase *""'");
19877   }
19878   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19879   ecode2 = SWIG_AsVal_int(obj1, &val2);
19880   if (!SWIG_IsOK(ecode2)) {
19881     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_getFather" "', argument " "2"" of type '" "int""'");
19882   }
19883   arg2 = static_cast< int >(val2);
19884   result = (Hex::EltBase *)(arg1)->getFather(arg2);
19885   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19886   return resultobj;
19887 fail:
19888   return NULL;
19889 }
19890
19891
19892 SWIGINTERN PyObject *_wrap_EltBase_getMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19893   PyObject *resultobj = 0;
19894   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19895   void *argp1 = 0 ;
19896   int res1 = 0 ;
19897   PyObject * obj0 = 0 ;
19898   int result;
19899
19900   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getMark",&obj0)) SWIG_fail;
19901   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19902   if (!SWIG_IsOK(res1)) {
19903     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getMark" "', argument " "1"" of type '" "Hex::EltBase *""'");
19904   }
19905   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19906   result = (int)(arg1)->getMark();
19907   resultobj = SWIG_From_int(static_cast< int >(result));
19908   return resultobj;
19909 fail:
19910   return NULL;
19911 }
19912
19913
19914 SWIGINTERN PyObject *_wrap_EltBase_setMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19915   PyObject *resultobj = 0;
19916   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19917   int arg2 ;
19918   void *argp1 = 0 ;
19919   int res1 = 0 ;
19920   int val2 ;
19921   int ecode2 = 0 ;
19922   PyObject * obj0 = 0 ;
19923   PyObject * obj1 = 0 ;
19924
19925   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setMark",&obj0,&obj1)) SWIG_fail;
19926   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19927   if (!SWIG_IsOK(res1)) {
19928     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setMark" "', argument " "1"" of type '" "Hex::EltBase *""'");
19929   }
19930   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19931   ecode2 = SWIG_AsVal_int(obj1, &val2);
19932   if (!SWIG_IsOK(ecode2)) {
19933     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setMark" "', argument " "2"" of type '" "int""'");
19934   }
19935   arg2 = static_cast< int >(val2);
19936   (arg1)->setMark(arg2);
19937   resultobj = SWIG_Py_Void();
19938   return resultobj;
19939 fail:
19940   return NULL;
19941 }
19942
19943
19944 SWIGINTERN PyObject *_wrap_EltBase_getName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19945   PyObject *resultobj = 0;
19946   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19947   pchar arg2 = (pchar) 0 ;
19948   void *argp1 = 0 ;
19949   int res1 = 0 ;
19950   int res2 ;
19951   char *buf2 = 0 ;
19952   int alloc2 = 0 ;
19953   PyObject * obj0 = 0 ;
19954   PyObject * obj1 = 0 ;
19955   char *result = 0 ;
19956
19957   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getName",&obj0,&obj1)) SWIG_fail;
19958   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19959   if (!SWIG_IsOK(res1)) {
19960     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getName" "', argument " "1"" of type '" "Hex::EltBase *""'");
19961   }
19962   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19963   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
19964   if (!SWIG_IsOK(res2)) {
19965     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_getName" "', argument " "2"" of type '" "pchar""'");
19966   }
19967   arg2 = reinterpret_cast< pchar >(buf2);
19968   result = (char *)(arg1)->getName(arg2);
19969   resultobj = SWIG_FromCharPtr((const char *)result);
19970   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19971   return resultobj;
19972 fail:
19973   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19974   return NULL;
19975 }
19976
19977
19978 SWIGINTERN PyObject *_wrap_EltBase_printName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19979   PyObject *resultobj = 0;
19980   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19981   cpchar arg2 = (cpchar) 0 ;
19982   void *argp1 = 0 ;
19983   int res1 = 0 ;
19984   int res2 ;
19985   char *buf2 = 0 ;
19986   int alloc2 = 0 ;
19987   PyObject * obj0 = 0 ;
19988   PyObject * obj1 = 0 ;
19989
19990   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_printName",&obj0,&obj1)) SWIG_fail;
19991   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19992   if (!SWIG_IsOK(res1)) {
19993     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_printName" "', argument " "1"" of type '" "Hex::EltBase *""'");
19994   }
19995   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19996   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
19997   if (!SWIG_IsOK(res2)) {
19998     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_printName" "', argument " "2"" of type '" "cpchar""'");
19999   }
20000   arg2 = reinterpret_cast< cpchar >(buf2);
20001   (arg1)->printName(arg2);
20002   resultobj = SWIG_Py_Void();
20003   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20004   return resultobj;
20005 fail:
20006   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20007   return NULL;
20008 }
20009
20010
20011 SWIGINTERN PyObject *_wrap_EltBase_printName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20012   PyObject *resultobj = 0;
20013   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
20014   void *argp1 = 0 ;
20015   int res1 = 0 ;
20016   PyObject * obj0 = 0 ;
20017
20018   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_printName",&obj0)) SWIG_fail;
20019   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
20020   if (!SWIG_IsOK(res1)) {
20021     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_printName" "', argument " "1"" of type '" "Hex::EltBase *""'");
20022   }
20023   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
20024   (arg1)->printName();
20025   resultobj = SWIG_Py_Void();
20026   return resultobj;
20027 fail:
20028   return NULL;
20029 }
20030
20031
20032 SWIGINTERN PyObject *_wrap_EltBase_printName(PyObject *self, PyObject *args) {
20033   int argc;
20034   PyObject *argv[3];
20035   int ii;
20036
20037   if (!PyTuple_Check(args)) SWIG_fail;
20038   argc = (int)PyObject_Length(args);
20039   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
20040     argv[ii] = PyTuple_GET_ITEM(args,ii);
20041   }
20042   if (argc == 1) {
20043     int _v;
20044     void *vptr = 0;
20045     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
20046     _v = SWIG_CheckState(res);
20047     if (_v) {
20048       return _wrap_EltBase_printName__SWIG_1(self, args);
20049     }
20050   }
20051   if (argc == 2) {
20052     int _v;
20053     void *vptr = 0;
20054     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
20055     _v = SWIG_CheckState(res);
20056     if (_v) {
20057       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
20058       _v = SWIG_CheckState(res);
20059       if (_v) {
20060         return _wrap_EltBase_printName__SWIG_0(self, args);
20061       }
20062     }
20063   }
20064
20065 fail:
20066   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_printName'.\n"
20067     "  Possible C/C++ prototypes are:\n"
20068     "    printName(Hex::EltBase *,cpchar)\n"
20069     "    printName(Hex::EltBase *)\n");
20070   return NULL;
20071 }
20072
20073
20074 SWIGINTERN PyObject *_wrap_EltBase_dumpRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20075   PyObject *resultobj = 0;
20076   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
20077   void *argp1 = 0 ;
20078   int res1 = 0 ;
20079   PyObject * obj0 = 0 ;
20080
20081   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dumpRef",&obj0)) SWIG_fail;
20082   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
20083   if (!SWIG_IsOK(res1)) {
20084     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dumpRef" "', argument " "1"" of type '" "Hex::EltBase *""'");
20085   }
20086   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
20087   (arg1)->dumpRef();
20088   resultobj = SWIG_Py_Void();
20089   return resultobj;
20090 fail:
20091   return NULL;
20092 }
20093
20094
20095 SWIGINTERN PyObject *_wrap_EltBase_getName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20096   PyObject *resultobj = 0;
20097   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
20098   void *argp1 = 0 ;
20099   int res1 = 0 ;
20100   PyObject * obj0 = 0 ;
20101   cpchar result;
20102
20103   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getName",&obj0)) SWIG_fail;
20104   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
20105   if (!SWIG_IsOK(res1)) {
20106     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getName" "', argument " "1"" of type '" "Hex::EltBase *""'");
20107   }
20108   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
20109   result = (cpchar)(arg1)->getName();
20110   resultobj = SWIG_FromCharPtr((const char *)result);
20111   return resultobj;
20112 fail:
20113   return NULL;
20114 }
20115
20116
20117 SWIGINTERN PyObject *_wrap_EltBase_getName(PyObject *self, PyObject *args) {
20118   int argc;
20119   PyObject *argv[3];
20120   int ii;
20121
20122   if (!PyTuple_Check(args)) SWIG_fail;
20123   argc = (int)PyObject_Length(args);
20124   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
20125     argv[ii] = PyTuple_GET_ITEM(args,ii);
20126   }
20127   if (argc == 1) {
20128     int _v;
20129     void *vptr = 0;
20130     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
20131     _v = SWIG_CheckState(res);
20132     if (_v) {
20133       return _wrap_EltBase_getName__SWIG_1(self, args);
20134     }
20135   }
20136   if (argc == 2) {
20137     int _v;
20138     void *vptr = 0;
20139     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
20140     _v = SWIG_CheckState(res);
20141     if (_v) {
20142       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
20143       _v = SWIG_CheckState(res);
20144       if (_v) {
20145         return _wrap_EltBase_getName__SWIG_0(self, args);
20146       }
20147     }
20148   }
20149
20150 fail:
20151   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_getName'.\n"
20152     "  Possible C/C++ prototypes are:\n"
20153     "    getName(Hex::EltBase *,pchar)\n"
20154     "    getName(Hex::EltBase *)\n");
20155   return NULL;
20156 }
20157
20158
20159 SWIGINTERN PyObject *_wrap_EltBase_setName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20160   PyObject *resultobj = 0;
20161   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
20162   string *arg2 = 0 ;
20163   void *argp1 = 0 ;
20164   int res1 = 0 ;
20165   void *argp2 = 0 ;
20166   int res2 = 0 ;
20167   PyObject * obj0 = 0 ;
20168   PyObject * obj1 = 0 ;
20169
20170   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setName",&obj0,&obj1)) SWIG_fail;
20171   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
20172   if (!SWIG_IsOK(res1)) {
20173     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setName" "', argument " "1"" of type '" "Hex::EltBase *""'");
20174   }
20175   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
20176   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string,  0  | 0);
20177   if (!SWIG_IsOK(res2)) {
20178     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setName" "', argument " "2"" of type '" "string const &""'");
20179   }
20180   if (!argp2) {
20181     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EltBase_setName" "', argument " "2"" of type '" "string const &""'");
20182   }
20183   arg2 = reinterpret_cast< string * >(argp2);
20184   (arg1)->setName((string const &)*arg2);
20185   resultobj = SWIG_Py_Void();
20186   return resultobj;
20187 fail:
20188   return NULL;
20189 }
20190
20191
20192 SWIGINTERN PyObject *_wrap_EltBase_setName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20193   PyObject *resultobj = 0;
20194   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
20195   cpchar arg2 = (cpchar) 0 ;
20196   void *argp1 = 0 ;
20197   int res1 = 0 ;
20198   int res2 ;
20199   char *buf2 = 0 ;
20200   int alloc2 = 0 ;
20201   PyObject * obj0 = 0 ;
20202   PyObject * obj1 = 0 ;
20203
20204   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setName",&obj0,&obj1)) SWIG_fail;
20205   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
20206   if (!SWIG_IsOK(res1)) {
20207     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setName" "', argument " "1"" of type '" "Hex::EltBase *""'");
20208   }
20209   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
20210   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20211   if (!SWIG_IsOK(res2)) {
20212     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setName" "', argument " "2"" of type '" "cpchar""'");
20213   }
20214   arg2 = reinterpret_cast< cpchar >(buf2);
20215   (arg1)->setName(arg2);
20216   resultobj = SWIG_Py_Void();
20217   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20218   return resultobj;
20219 fail:
20220   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20221   return NULL;
20222 }
20223
20224
20225 SWIGINTERN PyObject *_wrap_EltBase_setName(PyObject *self, PyObject *args) {
20226   int argc;
20227   PyObject *argv[3];
20228   int ii;
20229
20230   if (!PyTuple_Check(args)) SWIG_fail;
20231   argc = (int)PyObject_Length(args);
20232   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
20233     argv[ii] = PyTuple_GET_ITEM(args,ii);
20234   }
20235   if (argc == 2) {
20236     int _v;
20237     void *vptr = 0;
20238     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
20239     _v = SWIG_CheckState(res);
20240     if (_v) {
20241       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_string, 0);
20242       _v = SWIG_CheckState(res);
20243       if (_v) {
20244         return _wrap_EltBase_setName__SWIG_0(self, args);
20245       }
20246     }
20247   }
20248   if (argc == 2) {
20249     int _v;
20250     void *vptr = 0;
20251     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
20252     _v = SWIG_CheckState(res);
20253     if (_v) {
20254       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
20255       _v = SWIG_CheckState(res);
20256       if (_v) {
20257         return _wrap_EltBase_setName__SWIG_1(self, args);
20258       }
20259     }
20260   }
20261
20262 fail:
20263   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_setName'.\n"
20264     "  Possible C/C++ prototypes are:\n"
20265     "    setName(Hex::EltBase *,string const &)\n"
20266     "    setName(Hex::EltBase *,cpchar)\n");
20267   return NULL;
20268 }
20269
20270
20271 SWIGINTERN PyObject *_wrap_EltBase_debug__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20272   PyObject *resultobj = 0;
20273   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
20274   int arg2 ;
20275   void *argp1 = 0 ;
20276   int res1 = 0 ;
20277   int val2 ;
20278   int ecode2 = 0 ;
20279   PyObject * obj0 = 0 ;
20280   PyObject * obj1 = 0 ;
20281   bool result;
20282
20283   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_debug",&obj0,&obj1)) SWIG_fail;
20284   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
20285   if (!SWIG_IsOK(res1)) {
20286     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_debug" "', argument " "1"" of type '" "Hex::EltBase *""'");
20287   }
20288   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
20289   ecode2 = SWIG_AsVal_int(obj1, &val2);
20290   if (!SWIG_IsOK(ecode2)) {
20291     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_debug" "', argument " "2"" of type '" "int""'");
20292   }
20293   arg2 = static_cast< int >(val2);
20294   result = (bool)(arg1)->debug(arg2);
20295   resultobj = SWIG_From_bool(static_cast< bool >(result));
20296   return resultobj;
20297 fail:
20298   return NULL;
20299 }
20300
20301
20302 SWIGINTERN PyObject *_wrap_EltBase_debug__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20303   PyObject *resultobj = 0;
20304   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
20305   void *argp1 = 0 ;
20306   int res1 = 0 ;
20307   PyObject * obj0 = 0 ;
20308   bool result;
20309
20310   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_debug",&obj0)) SWIG_fail;
20311   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
20312   if (!SWIG_IsOK(res1)) {
20313     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_debug" "', argument " "1"" of type '" "Hex::EltBase *""'");
20314   }
20315   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
20316   result = (bool)(arg1)->debug();
20317   resultobj = SWIG_From_bool(static_cast< bool >(result));
20318   return resultobj;
20319 fail:
20320   return NULL;
20321 }
20322
20323
20324 SWIGINTERN PyObject *_wrap_EltBase_debug(PyObject *self, PyObject *args) {
20325   int argc;
20326   PyObject *argv[3];
20327   int ii;
20328
20329   if (!PyTuple_Check(args)) SWIG_fail;
20330   argc = (int)PyObject_Length(args);
20331   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
20332     argv[ii] = PyTuple_GET_ITEM(args,ii);
20333   }
20334   if (argc == 1) {
20335     int _v;
20336     void *vptr = 0;
20337     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
20338     _v = SWIG_CheckState(res);
20339     if (_v) {
20340       return _wrap_EltBase_debug__SWIG_1(self, args);
20341     }
20342   }
20343   if (argc == 2) {
20344     int _v;
20345     void *vptr = 0;
20346     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
20347     _v = SWIG_CheckState(res);
20348     if (_v) {
20349       {
20350         int res = SWIG_AsVal_int(argv[1], NULL);
20351         _v = SWIG_CheckState(res);
20352       }
20353       if (_v) {
20354         return _wrap_EltBase_debug__SWIG_0(self, args);
20355       }
20356     }
20357   }
20358
20359 fail:
20360   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_debug'.\n"
20361     "  Possible C/C++ prototypes are:\n"
20362     "    debug(Hex::EltBase *,int)\n"
20363     "    debug(Hex::EltBase *)\n");
20364   return NULL;
20365 }
20366
20367
20368 SWIGINTERN PyObject *_wrap_EltBase_isAssociated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20369   PyObject *resultobj = 0;
20370   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
20371   void *argp1 = 0 ;
20372   int res1 = 0 ;
20373   PyObject * obj0 = 0 ;
20374   bool result;
20375
20376   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isAssociated",&obj0)) SWIG_fail;
20377   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
20378   if (!SWIG_IsOK(res1)) {
20379     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isAssociated" "', argument " "1"" of type '" "Hex::EltBase *""'");
20380   }
20381   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
20382   result = (bool)(arg1)->isAssociated();
20383   resultobj = SWIG_From_bool(static_cast< bool >(result));
20384   return resultobj;
20385 fail:
20386   return NULL;
20387 }
20388
20389
20390 SWIGINTERN PyObject *_wrap_EltBase_getNextName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20391   PyObject *resultobj = 0;
20392   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
20393   void *argp1 = 0 ;
20394   int res1 = 0 ;
20395   PyObject * obj0 = 0 ;
20396   string result;
20397
20398   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNextName",&obj0)) SWIG_fail;
20399   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
20400   if (!SWIG_IsOK(res1)) {
20401     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getNextName" "', argument " "1"" of type '" "Hex::EltBase *""'");
20402   }
20403   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
20404   result = (arg1)->getNextName();
20405   resultobj = SWIG_NewPointerObj((new string(static_cast< const string& >(result))), SWIGTYPE_p_string, SWIG_POINTER_OWN |  0 );
20406   return resultobj;
20407 fail:
20408   return NULL;
20409 }
20410
20411
20412 SWIGINTERN PyObject *EltBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20413   PyObject *obj;
20414   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
20415   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__EltBase, SWIG_NewClientData(obj));
20416   return SWIG_Py_Void();
20417 }
20418
20419 SWIGINTERN PyObject *_wrap_Vertex_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20420   PyObject *resultobj = 0;
20421   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20422   void *argp1 = 0 ;
20423   int res1 = 0 ;
20424   PyObject * obj0 = 0 ;
20425   double result;
20426
20427   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getX",&obj0)) SWIG_fail;
20428   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20429   if (!SWIG_IsOK(res1)) {
20430     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getX" "', argument " "1"" of type '" "Hex::Vertex *""'");
20431   }
20432   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20433   result = (double)(arg1)->getX();
20434   resultobj = SWIG_From_double(static_cast< double >(result));
20435   return resultobj;
20436 fail:
20437   return NULL;
20438 }
20439
20440
20441 SWIGINTERN PyObject *_wrap_Vertex_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20442   PyObject *resultobj = 0;
20443   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20444   void *argp1 = 0 ;
20445   int res1 = 0 ;
20446   PyObject * obj0 = 0 ;
20447   double result;
20448
20449   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getY",&obj0)) SWIG_fail;
20450   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20451   if (!SWIG_IsOK(res1)) {
20452     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getY" "', argument " "1"" of type '" "Hex::Vertex *""'");
20453   }
20454   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20455   result = (double)(arg1)->getY();
20456   resultobj = SWIG_From_double(static_cast< double >(result));
20457   return resultobj;
20458 fail:
20459   return NULL;
20460 }
20461
20462
20463 SWIGINTERN PyObject *_wrap_Vertex_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20464   PyObject *resultobj = 0;
20465   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20466   void *argp1 = 0 ;
20467   int res1 = 0 ;
20468   PyObject * obj0 = 0 ;
20469   double result;
20470
20471   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getZ",&obj0)) SWIG_fail;
20472   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20473   if (!SWIG_IsOK(res1)) {
20474     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
20475   }
20476   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20477   result = (double)(arg1)->getZ();
20478   resultobj = SWIG_From_double(static_cast< double >(result));
20479   return resultobj;
20480 fail:
20481   return NULL;
20482 }
20483
20484
20485 SWIGINTERN PyObject *_wrap_Vertex_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20486   PyObject *resultobj = 0;
20487   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20488   double arg2 ;
20489   void *argp1 = 0 ;
20490   int res1 = 0 ;
20491   double val2 ;
20492   int ecode2 = 0 ;
20493   PyObject * obj0 = 0 ;
20494   PyObject * obj1 = 0 ;
20495
20496   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setX",&obj0,&obj1)) SWIG_fail;
20497   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20498   if (!SWIG_IsOK(res1)) {
20499     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setX" "', argument " "1"" of type '" "Hex::Vertex *""'");
20500   }
20501   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20502   ecode2 = SWIG_AsVal_double(obj1, &val2);
20503   if (!SWIG_IsOK(ecode2)) {
20504     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setX" "', argument " "2"" of type '" "double""'");
20505   }
20506   arg2 = static_cast< double >(val2);
20507   (arg1)->setX(arg2);
20508   resultobj = SWIG_Py_Void();
20509   return resultobj;
20510 fail:
20511   return NULL;
20512 }
20513
20514
20515 SWIGINTERN PyObject *_wrap_Vertex_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20516   PyObject *resultobj = 0;
20517   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20518   double arg2 ;
20519   void *argp1 = 0 ;
20520   int res1 = 0 ;
20521   double val2 ;
20522   int ecode2 = 0 ;
20523   PyObject * obj0 = 0 ;
20524   PyObject * obj1 = 0 ;
20525
20526   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setY",&obj0,&obj1)) SWIG_fail;
20527   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20528   if (!SWIG_IsOK(res1)) {
20529     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setY" "', argument " "1"" of type '" "Hex::Vertex *""'");
20530   }
20531   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20532   ecode2 = SWIG_AsVal_double(obj1, &val2);
20533   if (!SWIG_IsOK(ecode2)) {
20534     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setY" "', argument " "2"" of type '" "double""'");
20535   }
20536   arg2 = static_cast< double >(val2);
20537   (arg1)->setY(arg2);
20538   resultobj = SWIG_Py_Void();
20539   return resultobj;
20540 fail:
20541   return NULL;
20542 }
20543
20544
20545 SWIGINTERN PyObject *_wrap_Vertex_setZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20546   PyObject *resultobj = 0;
20547   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20548   double arg2 ;
20549   void *argp1 = 0 ;
20550   int res1 = 0 ;
20551   double val2 ;
20552   int ecode2 = 0 ;
20553   PyObject * obj0 = 0 ;
20554   PyObject * obj1 = 0 ;
20555
20556   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setZ",&obj0,&obj1)) SWIG_fail;
20557   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20558   if (!SWIG_IsOK(res1)) {
20559     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
20560   }
20561   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20562   ecode2 = SWIG_AsVal_double(obj1, &val2);
20563   if (!SWIG_IsOK(ecode2)) {
20564     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setZ" "', argument " "2"" of type '" "double""'");
20565   }
20566   arg2 = static_cast< double >(val2);
20567   (arg1)->setZ(arg2);
20568   resultobj = SWIG_Py_Void();
20569   return resultobj;
20570 fail:
20571   return NULL;
20572 }
20573
20574
20575 SWIGINTERN PyObject *_wrap_Vertex_getAssoX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20576   PyObject *resultobj = 0;
20577   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20578   void *argp1 = 0 ;
20579   int res1 = 0 ;
20580   PyObject * obj0 = 0 ;
20581   double result;
20582
20583   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoX",&obj0)) SWIG_fail;
20584   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20585   if (!SWIG_IsOK(res1)) {
20586     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoX" "', argument " "1"" of type '" "Hex::Vertex *""'");
20587   }
20588   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20589   result = (double)(arg1)->getAssoX();
20590   resultobj = SWIG_From_double(static_cast< double >(result));
20591   return resultobj;
20592 fail:
20593   return NULL;
20594 }
20595
20596
20597 SWIGINTERN PyObject *_wrap_Vertex_getAssoY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20598   PyObject *resultobj = 0;
20599   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20600   void *argp1 = 0 ;
20601   int res1 = 0 ;
20602   PyObject * obj0 = 0 ;
20603   double result;
20604
20605   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoY",&obj0)) SWIG_fail;
20606   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20607   if (!SWIG_IsOK(res1)) {
20608     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoY" "', argument " "1"" of type '" "Hex::Vertex *""'");
20609   }
20610   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20611   result = (double)(arg1)->getAssoY();
20612   resultobj = SWIG_From_double(static_cast< double >(result));
20613   return resultobj;
20614 fail:
20615   return NULL;
20616 }
20617
20618
20619 SWIGINTERN PyObject *_wrap_Vertex_getAssoZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20620   PyObject *resultobj = 0;
20621   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20622   void *argp1 = 0 ;
20623   int res1 = 0 ;
20624   PyObject * obj0 = 0 ;
20625   double result;
20626
20627   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoZ",&obj0)) SWIG_fail;
20628   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20629   if (!SWIG_IsOK(res1)) {
20630     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
20631   }
20632   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20633   result = (double)(arg1)->getAssoZ();
20634   resultobj = SWIG_From_double(static_cast< double >(result));
20635   return resultobj;
20636 fail:
20637   return NULL;
20638 }
20639
20640
20641 SWIGINTERN PyObject *_wrap_Vertex_setAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20642   PyObject *resultobj = 0;
20643   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20644   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
20645   int arg3 ;
20646   void *argp1 = 0 ;
20647   int res1 = 0 ;
20648   void *argp2 = 0 ;
20649   int res2 = 0 ;
20650   int val3 ;
20651   int ecode3 = 0 ;
20652   PyObject * obj0 = 0 ;
20653   PyObject * obj1 = 0 ;
20654   PyObject * obj2 = 0 ;
20655   int result;
20656
20657   if (!PyArg_ParseTuple(args,(char *)"OOO:Vertex_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
20658   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20659   if (!SWIG_IsOK(res1)) {
20660     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setAssociation" "', argument " "1"" of type '" "Hex::Vertex *""'");
20661   }
20662   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20663   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
20664   if (!SWIG_IsOK(res2)) {
20665     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vertex_setAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
20666   }
20667   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
20668   ecode3 = SWIG_AsVal_int(obj2, &val3);
20669   if (!SWIG_IsOK(ecode3)) {
20670     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vertex_setAssociation" "', argument " "3"" of type '" "int""'");
20671   }
20672   arg3 = static_cast< int >(val3);
20673   result = (int)(arg1)->setAssociation(arg2,arg3);
20674   resultobj = SWIG_From_int(static_cast< int >(result));
20675   return resultobj;
20676 fail:
20677   return NULL;
20678 }
20679
20680
20681 SWIGINTERN PyObject *_wrap_Vertex_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20682   PyObject *resultobj = 0;
20683   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20684   void *argp1 = 0 ;
20685   int res1 = 0 ;
20686   PyObject * obj0 = 0 ;
20687
20688   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_clearAssociation",&obj0)) SWIG_fail;
20689   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20690   if (!SWIG_IsOK(res1)) {
20691     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_clearAssociation" "', argument " "1"" of type '" "Hex::Vertex *""'");
20692   }
20693   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20694   (arg1)->clearAssociation();
20695   resultobj = SWIG_Py_Void();
20696   return resultobj;
20697 fail:
20698   return NULL;
20699 }
20700
20701
20702 SWIGINTERN PyObject *_wrap_Vertex_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20703   PyObject *resultobj = 0;
20704   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20705   double arg2 ;
20706   void *argp1 = 0 ;
20707   int res1 = 0 ;
20708   double val2 ;
20709   int ecode2 = 0 ;
20710   PyObject * obj0 = 0 ;
20711   PyObject * obj1 = 0 ;
20712
20713   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setColor",&obj0,&obj1)) SWIG_fail;
20714   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20715   if (!SWIG_IsOK(res1)) {
20716     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setColor" "', argument " "1"" of type '" "Hex::Vertex *""'");
20717   }
20718   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20719   ecode2 = SWIG_AsVal_double(obj1, &val2);
20720   if (!SWIG_IsOK(ecode2)) {
20721     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setColor" "', argument " "2"" of type '" "double""'");
20722   }
20723   arg2 = static_cast< double >(val2);
20724   (arg1)->setColor(arg2);
20725   resultobj = SWIG_Py_Void();
20726   return resultobj;
20727 fail:
20728   return NULL;
20729 }
20730
20731
20732 SWIGINTERN PyObject *_wrap_new_Vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20733   PyObject *resultobj = 0;
20734   Hex::Document *arg1 = (Hex::Document *) 0 ;
20735   double arg2 ;
20736   double arg3 ;
20737   double arg4 ;
20738   void *argp1 = 0 ;
20739   int res1 = 0 ;
20740   double val2 ;
20741   int ecode2 = 0 ;
20742   double val3 ;
20743   int ecode3 = 0 ;
20744   double val4 ;
20745   int ecode4 = 0 ;
20746   PyObject * obj0 = 0 ;
20747   PyObject * obj1 = 0 ;
20748   PyObject * obj2 = 0 ;
20749   PyObject * obj3 = 0 ;
20750   Hex::Vertex *result = 0 ;
20751
20752   if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20753   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
20754   if (!SWIG_IsOK(res1)) {
20755     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vertex" "', argument " "1"" of type '" "Hex::Document *""'");
20756   }
20757   arg1 = reinterpret_cast< Hex::Document * >(argp1);
20758   ecode2 = SWIG_AsVal_double(obj1, &val2);
20759   if (!SWIG_IsOK(ecode2)) {
20760     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vertex" "', argument " "2"" of type '" "double""'");
20761   }
20762   arg2 = static_cast< double >(val2);
20763   ecode3 = SWIG_AsVal_double(obj2, &val3);
20764   if (!SWIG_IsOK(ecode3)) {
20765     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vertex" "', argument " "3"" of type '" "double""'");
20766   }
20767   arg3 = static_cast< double >(val3);
20768   ecode4 = SWIG_AsVal_double(obj3, &val4);
20769   if (!SWIG_IsOK(ecode4)) {
20770     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vertex" "', argument " "4"" of type '" "double""'");
20771   }
20772   arg4 = static_cast< double >(val4);
20773   result = (Hex::Vertex *)new Hex::Vertex(arg1,arg2,arg3,arg4);
20774   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, SWIG_POINTER_NEW |  0 );
20775   return resultobj;
20776 fail:
20777   return NULL;
20778 }
20779
20780
20781 SWIGINTERN PyObject *_wrap_delete_Vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20782   PyObject *resultobj = 0;
20783   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20784   void *argp1 = 0 ;
20785   int res1 = 0 ;
20786   PyObject * obj0 = 0 ;
20787
20788   if (!PyArg_ParseTuple(args,(char *)"O:delete_Vertex",&obj0)) SWIG_fail;
20789   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, SWIG_POINTER_DISOWN |  0 );
20790   if (!SWIG_IsOK(res1)) {
20791     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vertex" "', argument " "1"" of type '" "Hex::Vertex *""'");
20792   }
20793   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20794   delete arg1;
20795   resultobj = SWIG_Py_Void();
20796   return resultobj;
20797 fail:
20798   return NULL;
20799 }
20800
20801
20802 SWIGINTERN PyObject *Vertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20803   PyObject *obj;
20804   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
20805   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vertex, SWIG_NewClientData(obj));
20806   return SWIG_Py_Void();
20807 }
20808
20809 SWIGINTERN PyObject *_wrap_Edge_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20810   PyObject *resultobj = 0;
20811   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
20812   int arg2 ;
20813   void *argp1 = 0 ;
20814   int res1 = 0 ;
20815   int val2 ;
20816   int ecode2 = 0 ;
20817   PyObject * obj0 = 0 ;
20818   PyObject * obj1 = 0 ;
20819   Hex::Vertex *result = 0 ;
20820
20821   if (!PyArg_ParseTuple(args,(char *)"OO:Edge_getVertex",&obj0,&obj1)) SWIG_fail;
20822   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
20823   if (!SWIG_IsOK(res1)) {
20824     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getVertex" "', argument " "1"" of type '" "Hex::Edge *""'");
20825   }
20826   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
20827   ecode2 = SWIG_AsVal_int(obj1, &val2);
20828   if (!SWIG_IsOK(ecode2)) {
20829     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Edge_getVertex" "', argument " "2"" of type '" "int""'");
20830   }
20831   arg2 = static_cast< int >(val2);
20832   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
20833   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20834   return resultobj;
20835 fail:
20836   return NULL;
20837 }
20838
20839
20840 SWIGINTERN PyObject *_wrap_Edge_addAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20841   PyObject *resultobj = 0;
20842   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
20843   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
20844   int arg3 ;
20845   double arg4 ;
20846   double arg5 ;
20847   void *argp1 = 0 ;
20848   int res1 = 0 ;
20849   void *argp2 = 0 ;
20850   int res2 = 0 ;
20851   int val3 ;
20852   int ecode3 = 0 ;
20853   double val4 ;
20854   int ecode4 = 0 ;
20855   double val5 ;
20856   int ecode5 = 0 ;
20857   PyObject * obj0 = 0 ;
20858   PyObject * obj1 = 0 ;
20859   PyObject * obj2 = 0 ;
20860   PyObject * obj3 = 0 ;
20861   PyObject * obj4 = 0 ;
20862   int result;
20863
20864   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Edge_addAssociation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20865   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
20866   if (!SWIG_IsOK(res1)) {
20867     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_addAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
20868   }
20869   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
20870   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
20871   if (!SWIG_IsOK(res2)) {
20872     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_addAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
20873   }
20874   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
20875   ecode3 = SWIG_AsVal_int(obj2, &val3);
20876   if (!SWIG_IsOK(ecode3)) {
20877     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Edge_addAssociation" "', argument " "3"" of type '" "int""'");
20878   }
20879   arg3 = static_cast< int >(val3);
20880   ecode4 = SWIG_AsVal_double(obj3, &val4);
20881   if (!SWIG_IsOK(ecode4)) {
20882     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Edge_addAssociation" "', argument " "4"" of type '" "double""'");
20883   }
20884   arg4 = static_cast< double >(val4);
20885   ecode5 = SWIG_AsVal_double(obj4, &val5);
20886   if (!SWIG_IsOK(ecode5)) {
20887     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Edge_addAssociation" "', argument " "5"" of type '" "double""'");
20888   }
20889   arg5 = static_cast< double >(val5);
20890   result = (int)(arg1)->addAssociation(arg2,arg3,arg4,arg5);
20891   resultobj = SWIG_From_int(static_cast< int >(result));
20892   return resultobj;
20893 fail:
20894   return NULL;
20895 }
20896
20897
20898 SWIGINTERN PyObject *_wrap_Edge_setAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20899   PyObject *resultobj = 0;
20900   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
20901   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
20902   int arg3 ;
20903   void *argp1 = 0 ;
20904   int res1 = 0 ;
20905   void *argp2 = 0 ;
20906   int res2 = 0 ;
20907   int val3 ;
20908   int ecode3 = 0 ;
20909   PyObject * obj0 = 0 ;
20910   PyObject * obj1 = 0 ;
20911   PyObject * obj2 = 0 ;
20912   int result;
20913
20914   if (!PyArg_ParseTuple(args,(char *)"OOO:Edge_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
20915   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
20916   if (!SWIG_IsOK(res1)) {
20917     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_setAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
20918   }
20919   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
20920   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
20921   if (!SWIG_IsOK(res2)) {
20922     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_setAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
20923   }
20924   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
20925   ecode3 = SWIG_AsVal_int(obj2, &val3);
20926   if (!SWIG_IsOK(ecode3)) {
20927     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Edge_setAssociation" "', argument " "3"" of type '" "int""'");
20928   }
20929   arg3 = static_cast< int >(val3);
20930   result = (int)(arg1)->setAssociation(arg2,arg3);
20931   resultobj = SWIG_From_int(static_cast< int >(result));
20932   return resultobj;
20933 fail:
20934   return NULL;
20935 }
20936
20937
20938 SWIGINTERN PyObject *_wrap_Edge_findAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20939   PyObject *resultobj = 0;
20940   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
20941   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
20942   void *argp1 = 0 ;
20943   int res1 = 0 ;
20944   void *argp2 = 0 ;
20945   int res2 = 0 ;
20946   PyObject * obj0 = 0 ;
20947   PyObject * obj1 = 0 ;
20948   int result;
20949
20950   if (!PyArg_ParseTuple(args,(char *)"OO:Edge_findAssociation",&obj0,&obj1)) SWIG_fail;
20951   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
20952   if (!SWIG_IsOK(res1)) {
20953     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_findAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
20954   }
20955   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
20956   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
20957   if (!SWIG_IsOK(res2)) {
20958     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_findAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
20959   }
20960   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
20961   result = (int)(arg1)->findAssociation(arg2);
20962   resultobj = SWIG_From_int(static_cast< int >(result));
20963   return resultobj;
20964 fail:
20965   return NULL;
20966 }
20967
20968
20969 SWIGINTERN PyObject *_wrap_Edge_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20970   PyObject *resultobj = 0;
20971   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
20972   void *argp1 = 0 ;
20973   int res1 = 0 ;
20974   PyObject * obj0 = 0 ;
20975
20976   if (!PyArg_ParseTuple(args,(char *)"O:Edge_clearAssociation",&obj0)) SWIG_fail;
20977   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
20978   if (!SWIG_IsOK(res1)) {
20979     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_clearAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
20980   }
20981   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
20982   (arg1)->clearAssociation();
20983   resultobj = SWIG_Py_Void();
20984   return resultobj;
20985 fail:
20986   return NULL;
20987 }
20988
20989
20990 SWIGINTERN PyObject *_wrap_Edge_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20991   PyObject *resultobj = 0;
20992   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
20993   double arg2 ;
20994   void *argp1 = 0 ;
20995   int res1 = 0 ;
20996   double val2 ;
20997   int ecode2 = 0 ;
20998   PyObject * obj0 = 0 ;
20999   PyObject * obj1 = 0 ;
21000
21001   if (!PyArg_ParseTuple(args,(char *)"OO:Edge_setColor",&obj0,&obj1)) SWIG_fail;
21002   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
21003   if (!SWIG_IsOK(res1)) {
21004     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_setColor" "', argument " "1"" of type '" "Hex::Edge *""'");
21005   }
21006   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
21007   ecode2 = SWIG_AsVal_double(obj1, &val2);
21008   if (!SWIG_IsOK(ecode2)) {
21009     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Edge_setColor" "', argument " "2"" of type '" "double""'");
21010   }
21011   arg2 = static_cast< double >(val2);
21012   (arg1)->setColor(arg2);
21013   resultobj = SWIG_Py_Void();
21014   return resultobj;
21015 fail:
21016   return NULL;
21017 }
21018
21019
21020 SWIGINTERN PyObject *_wrap_Edge_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21021   PyObject *resultobj = 0;
21022   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
21023   void *argp1 = 0 ;
21024   int res1 = 0 ;
21025   PyObject * obj0 = 0 ;
21026   bool result;
21027
21028   if (!PyArg_ParseTuple(args,(char *)"O:Edge_getWay",&obj0)) SWIG_fail;
21029   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
21030   if (!SWIG_IsOK(res1)) {
21031     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getWay" "', argument " "1"" of type '" "Hex::Edge *""'");
21032   }
21033   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
21034   result = (bool)(arg1)->getWay();
21035   resultobj = SWIG_From_bool(static_cast< bool >(result));
21036   return resultobj;
21037 fail:
21038   return NULL;
21039 }
21040
21041
21042 SWIGINTERN PyObject *_wrap_Edge_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21043   PyObject *resultobj = 0;
21044   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
21045   void *argp1 = 0 ;
21046   int res1 = 0 ;
21047   PyObject * obj0 = 0 ;
21048   double result;
21049
21050   if (!PyArg_ParseTuple(args,(char *)"O:Edge_getLength",&obj0)) SWIG_fail;
21051   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
21052   if (!SWIG_IsOK(res1)) {
21053     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getLength" "', argument " "1"" of type '" "Hex::Edge *""'");
21054   }
21055   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
21056   result = (double)(arg1)->getLength();
21057   resultobj = SWIG_From_double(static_cast< double >(result));
21058   return resultobj;
21059 fail:
21060   return NULL;
21061 }
21062
21063
21064 SWIGINTERN PyObject *_wrap_new_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21065   PyObject *resultobj = 0;
21066   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
21067   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21068   void *argp1 = 0 ;
21069   int res1 = 0 ;
21070   void *argp2 = 0 ;
21071   int res2 = 0 ;
21072   PyObject * obj0 = 0 ;
21073   PyObject * obj1 = 0 ;
21074   Hex::Edge *result = 0 ;
21075
21076   if (!PyArg_ParseTuple(args,(char *)"OO:new_Edge",&obj0,&obj1)) SWIG_fail;
21077   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21078   if (!SWIG_IsOK(res1)) {
21079     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Edge" "', argument " "1"" of type '" "Hex::Vertex *""'");
21080   }
21081   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
21082   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21083   if (!SWIG_IsOK(res2)) {
21084     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Edge" "', argument " "2"" of type '" "Hex::Vertex *""'");
21085   }
21086   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21087   result = (Hex::Edge *)new Hex::Edge(arg1,arg2);
21088   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, SWIG_POINTER_NEW |  0 );
21089   return resultobj;
21090 fail:
21091   return NULL;
21092 }
21093
21094
21095 SWIGINTERN PyObject *_wrap_delete_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21096   PyObject *resultobj = 0;
21097   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
21098   void *argp1 = 0 ;
21099   int res1 = 0 ;
21100   PyObject * obj0 = 0 ;
21101
21102   if (!PyArg_ParseTuple(args,(char *)"O:delete_Edge",&obj0)) SWIG_fail;
21103   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, SWIG_POINTER_DISOWN |  0 );
21104   if (!SWIG_IsOK(res1)) {
21105     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Edge" "', argument " "1"" of type '" "Hex::Edge *""'");
21106   }
21107   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
21108   delete arg1;
21109   resultobj = SWIG_Py_Void();
21110   return resultobj;
21111 fail:
21112   return NULL;
21113 }
21114
21115
21116 SWIGINTERN PyObject *Edge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21117   PyObject *obj;
21118   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
21119   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Edge, SWIG_NewClientData(obj));
21120   return SWIG_Py_Void();
21121 }
21122
21123 SWIGINTERN PyObject *_wrap_Quad_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21124   PyObject *resultobj = 0;
21125   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
21126   int arg2 ;
21127   void *argp1 = 0 ;
21128   int res1 = 0 ;
21129   int val2 ;
21130   int ecode2 = 0 ;
21131   PyObject * obj0 = 0 ;
21132   PyObject * obj1 = 0 ;
21133   Hex::Edge *result = 0 ;
21134
21135   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getEdge",&obj0,&obj1)) SWIG_fail;
21136   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21137   if (!SWIG_IsOK(res1)) {
21138     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getEdge" "', argument " "1"" of type '" "Hex::Quad *""'");
21139   }
21140   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
21141   ecode2 = SWIG_AsVal_int(obj1, &val2);
21142   if (!SWIG_IsOK(ecode2)) {
21143     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_getEdge" "', argument " "2"" of type '" "int""'");
21144   }
21145   arg2 = static_cast< int >(val2);
21146   result = (Hex::Edge *)(arg1)->getEdge(arg2);
21147   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
21148   return resultobj;
21149 fail:
21150   return NULL;
21151 }
21152
21153
21154 SWIGINTERN PyObject *_wrap_Quad_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21155   PyObject *resultobj = 0;
21156   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
21157   int arg2 ;
21158   void *argp1 = 0 ;
21159   int res1 = 0 ;
21160   int val2 ;
21161   int ecode2 = 0 ;
21162   PyObject * obj0 = 0 ;
21163   PyObject * obj1 = 0 ;
21164   Hex::Vertex *result = 0 ;
21165
21166   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getVertex",&obj0,&obj1)) SWIG_fail;
21167   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21168   if (!SWIG_IsOK(res1)) {
21169     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getVertex" "', argument " "1"" of type '" "Hex::Quad *""'");
21170   }
21171   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
21172   ecode2 = SWIG_AsVal_int(obj1, &val2);
21173   if (!SWIG_IsOK(ecode2)) {
21174     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_getVertex" "', argument " "2"" of type '" "int""'");
21175   }
21176   arg2 = static_cast< int >(val2);
21177   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
21178   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21179   return resultobj;
21180 fail:
21181   return NULL;
21182 }
21183
21184
21185 SWIGINTERN PyObject *_wrap_Quad_addAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21186   PyObject *resultobj = 0;
21187   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
21188   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
21189   int arg3 ;
21190   void *argp1 = 0 ;
21191   int res1 = 0 ;
21192   void *argp2 = 0 ;
21193   int res2 = 0 ;
21194   int val3 ;
21195   int ecode3 = 0 ;
21196   PyObject * obj0 = 0 ;
21197   PyObject * obj1 = 0 ;
21198   PyObject * obj2 = 0 ;
21199   int result;
21200
21201   if (!PyArg_ParseTuple(args,(char *)"OOO:Quad_addAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
21202   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21203   if (!SWIG_IsOK(res1)) {
21204     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_addAssociation" "', argument " "1"" of type '" "Hex::Quad *""'");
21205   }
21206   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
21207   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
21208   if (!SWIG_IsOK(res2)) {
21209     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_addAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
21210   }
21211   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
21212   ecode3 = SWIG_AsVal_int(obj2, &val3);
21213   if (!SWIG_IsOK(ecode3)) {
21214     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quad_addAssociation" "', argument " "3"" of type '" "int""'");
21215   }
21216   arg3 = static_cast< int >(val3);
21217   result = (int)(arg1)->addAssociation(arg2,arg3);
21218   resultobj = SWIG_From_int(static_cast< int >(result));
21219   return resultobj;
21220 fail:
21221   return NULL;
21222 }
21223
21224
21225 SWIGINTERN PyObject *_wrap_Quad_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21226   PyObject *resultobj = 0;
21227   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
21228   void *argp1 = 0 ;
21229   int res1 = 0 ;
21230   PyObject * obj0 = 0 ;
21231
21232   if (!PyArg_ParseTuple(args,(char *)"O:Quad_clearAssociation",&obj0)) SWIG_fail;
21233   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21234   if (!SWIG_IsOK(res1)) {
21235     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_clearAssociation" "', argument " "1"" of type '" "Hex::Quad *""'");
21236   }
21237   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
21238   (arg1)->clearAssociation();
21239   resultobj = SWIG_Py_Void();
21240   return resultobj;
21241 fail:
21242   return NULL;
21243 }
21244
21245
21246 SWIGINTERN PyObject *_wrap_Quad_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21247   PyObject *resultobj = 0;
21248   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
21249   double arg2 ;
21250   void *argp1 = 0 ;
21251   int res1 = 0 ;
21252   double val2 ;
21253   int ecode2 = 0 ;
21254   PyObject * obj0 = 0 ;
21255   PyObject * obj1 = 0 ;
21256
21257   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_setColor",&obj0,&obj1)) SWIG_fail;
21258   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21259   if (!SWIG_IsOK(res1)) {
21260     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_setColor" "', argument " "1"" of type '" "Hex::Quad *""'");
21261   }
21262   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
21263   ecode2 = SWIG_AsVal_double(obj1, &val2);
21264   if (!SWIG_IsOK(ecode2)) {
21265     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_setColor" "', argument " "2"" of type '" "double""'");
21266   }
21267   arg2 = static_cast< double >(val2);
21268   (arg1)->setColor(arg2);
21269   resultobj = SWIG_Py_Void();
21270   return resultobj;
21271 fail:
21272   return NULL;
21273 }
21274
21275
21276 SWIGINTERN PyObject *_wrap_Quad_nearestVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21277   PyObject *resultobj = 0;
21278   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
21279   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21280   void *argp1 = 0 ;
21281   int res1 = 0 ;
21282   void *argp2 = 0 ;
21283   int res2 = 0 ;
21284   PyObject * obj0 = 0 ;
21285   PyObject * obj1 = 0 ;
21286   Hex::Vertex *result = 0 ;
21287
21288   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_nearestVertex",&obj0,&obj1)) SWIG_fail;
21289   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21290   if (!SWIG_IsOK(res1)) {
21291     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_nearestVertex" "', argument " "1"" of type '" "Hex::Quad *""'");
21292   }
21293   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
21294   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21295   if (!SWIG_IsOK(res2)) {
21296     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_nearestVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
21297   }
21298   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21299   result = (Hex::Vertex *)(arg1)->nearestVertex(arg2);
21300   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21301   return resultobj;
21302 fail:
21303   return NULL;
21304 }
21305
21306
21307 SWIGINTERN PyObject *_wrap_Quad_getCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21308   PyObject *resultobj = 0;
21309   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
21310   double *arg2 = (double *) 0 ;
21311   void *argp1 = 0 ;
21312   int res1 = 0 ;
21313   void *argp2 = 0 ;
21314   int res2 = 0 ;
21315   PyObject * obj0 = 0 ;
21316   PyObject * obj1 = 0 ;
21317   double *result = 0 ;
21318
21319   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getCenter",&obj0,&obj1)) SWIG_fail;
21320   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21321   if (!SWIG_IsOK(res1)) {
21322     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getCenter" "', argument " "1"" of type '" "Hex::Quad *""'");
21323   }
21324   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
21325   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
21326   if (!SWIG_IsOK(res2)) {
21327     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_getCenter" "', argument " "2"" of type '" "double *""'");
21328   }
21329   arg2 = reinterpret_cast< double * >(argp2);
21330   result = (double *)(arg1)->getCenter(arg2);
21331   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
21332   return resultobj;
21333 fail:
21334   return NULL;
21335 }
21336
21337
21338 SWIGINTERN PyObject *_wrap_new_Quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21339   PyObject *resultobj = 0;
21340   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
21341   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21342   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
21343   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
21344   void *argp1 = 0 ;
21345   int res1 = 0 ;
21346   void *argp2 = 0 ;
21347   int res2 = 0 ;
21348   void *argp3 = 0 ;
21349   int res3 = 0 ;
21350   void *argp4 = 0 ;
21351   int res4 = 0 ;
21352   PyObject * obj0 = 0 ;
21353   PyObject * obj1 = 0 ;
21354   PyObject * obj2 = 0 ;
21355   PyObject * obj3 = 0 ;
21356   Hex::Quad *result = 0 ;
21357
21358   if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Quad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21359   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21360   if (!SWIG_IsOK(res1)) {
21361     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Quad" "', argument " "1"" of type '" "Hex::Vertex *""'");
21362   }
21363   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
21364   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21365   if (!SWIG_IsOK(res2)) {
21366     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Quad" "', argument " "2"" of type '" "Hex::Vertex *""'");
21367   }
21368   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21369   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21370   if (!SWIG_IsOK(res3)) {
21371     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Quad" "', argument " "3"" of type '" "Hex::Vertex *""'");
21372   }
21373   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
21374   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21375   if (!SWIG_IsOK(res4)) {
21376     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Quad" "', argument " "4"" of type '" "Hex::Vertex *""'");
21377   }
21378   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
21379   result = (Hex::Quad *)new Hex::Quad(arg1,arg2,arg3,arg4);
21380   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, SWIG_POINTER_NEW |  0 );
21381   return resultobj;
21382 fail:
21383   return NULL;
21384 }
21385
21386
21387 SWIGINTERN PyObject *_wrap_delete_Quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21388   PyObject *resultobj = 0;
21389   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
21390   void *argp1 = 0 ;
21391   int res1 = 0 ;
21392   PyObject * obj0 = 0 ;
21393
21394   if (!PyArg_ParseTuple(args,(char *)"O:delete_Quad",&obj0)) SWIG_fail;
21395   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, SWIG_POINTER_DISOWN |  0 );
21396   if (!SWIG_IsOK(res1)) {
21397     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Quad" "', argument " "1"" of type '" "Hex::Quad *""'");
21398   }
21399   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
21400   delete arg1;
21401   resultobj = SWIG_Py_Void();
21402   return resultobj;
21403 fail:
21404   return NULL;
21405 }
21406
21407
21408 SWIGINTERN PyObject *Quad_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21409   PyObject *obj;
21410   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
21411   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Quad, SWIG_NewClientData(obj));
21412   return SWIG_Py_Void();
21413 }
21414
21415 SWIGINTERN PyObject *_wrap_Hexa_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21416   PyObject *resultobj = 0;
21417   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
21418   int arg2 ;
21419   void *argp1 = 0 ;
21420   int res1 = 0 ;
21421   int val2 ;
21422   int ecode2 = 0 ;
21423   PyObject * obj0 = 0 ;
21424   PyObject * obj1 = 0 ;
21425   Hex::Quad *result = 0 ;
21426
21427   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getQuad",&obj0,&obj1)) SWIG_fail;
21428   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
21429   if (!SWIG_IsOK(res1)) {
21430     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getQuad" "', argument " "1"" of type '" "Hex::Hexa *""'");
21431   }
21432   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
21433   ecode2 = SWIG_AsVal_int(obj1, &val2);
21434   if (!SWIG_IsOK(ecode2)) {
21435     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getQuad" "', argument " "2"" of type '" "int""'");
21436   }
21437   arg2 = static_cast< int >(val2);
21438   result = (Hex::Quad *)(arg1)->getQuad(arg2);
21439   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
21440   return resultobj;
21441 fail:
21442   return NULL;
21443 }
21444
21445
21446 SWIGINTERN PyObject *_wrap_Hexa_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21447   PyObject *resultobj = 0;
21448   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
21449   int arg2 ;
21450   void *argp1 = 0 ;
21451   int res1 = 0 ;
21452   int val2 ;
21453   int ecode2 = 0 ;
21454   PyObject * obj0 = 0 ;
21455   PyObject * obj1 = 0 ;
21456   Hex::Edge *result = 0 ;
21457
21458   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getEdge",&obj0,&obj1)) SWIG_fail;
21459   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
21460   if (!SWIG_IsOK(res1)) {
21461     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getEdge" "', argument " "1"" of type '" "Hex::Hexa *""'");
21462   }
21463   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
21464   ecode2 = SWIG_AsVal_int(obj1, &val2);
21465   if (!SWIG_IsOK(ecode2)) {
21466     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getEdge" "', argument " "2"" of type '" "int""'");
21467   }
21468   arg2 = static_cast< int >(val2);
21469   result = (Hex::Edge *)(arg1)->getEdge(arg2);
21470   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
21471   return resultobj;
21472 fail:
21473   return NULL;
21474 }
21475
21476
21477 SWIGINTERN PyObject *_wrap_Hexa_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21478   PyObject *resultobj = 0;
21479   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
21480   int arg2 ;
21481   void *argp1 = 0 ;
21482   int res1 = 0 ;
21483   int val2 ;
21484   int ecode2 = 0 ;
21485   PyObject * obj0 = 0 ;
21486   PyObject * obj1 = 0 ;
21487   Hex::Vertex *result = 0 ;
21488
21489   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getVertex",&obj0,&obj1)) SWIG_fail;
21490   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
21491   if (!SWIG_IsOK(res1)) {
21492     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getVertex" "', argument " "1"" of type '" "Hex::Hexa *""'");
21493   }
21494   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
21495   ecode2 = SWIG_AsVal_int(obj1, &val2);
21496   if (!SWIG_IsOK(ecode2)) {
21497     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getVertex" "', argument " "2"" of type '" "int""'");
21498   }
21499   arg2 = static_cast< int >(val2);
21500   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
21501   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21502   return resultobj;
21503 fail:
21504   return NULL;
21505 }
21506
21507
21508 SWIGINTERN PyObject *_wrap_Hexa_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21509   PyObject *resultobj = 0;
21510   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
21511   double arg2 ;
21512   void *argp1 = 0 ;
21513   int res1 = 0 ;
21514   double val2 ;
21515   int ecode2 = 0 ;
21516   PyObject * obj0 = 0 ;
21517   PyObject * obj1 = 0 ;
21518
21519   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_setColor",&obj0,&obj1)) SWIG_fail;
21520   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
21521   if (!SWIG_IsOK(res1)) {
21522     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_setColor" "', argument " "1"" of type '" "Hex::Hexa *""'");
21523   }
21524   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
21525   ecode2 = SWIG_AsVal_double(obj1, &val2);
21526   if (!SWIG_IsOK(ecode2)) {
21527     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_setColor" "', argument " "2"" of type '" "double""'");
21528   }
21529   arg2 = static_cast< double >(val2);
21530   (arg1)->setColor(arg2);
21531   resultobj = SWIG_Py_Void();
21532   return resultobj;
21533 fail:
21534   return NULL;
21535 }
21536
21537
21538 SWIGINTERN PyObject *_wrap_new_Hexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21539   PyObject *resultobj = 0;
21540   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
21541   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
21542   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
21543   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
21544   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
21545   Hex::Quad *arg6 = (Hex::Quad *) 0 ;
21546   void *argp1 = 0 ;
21547   int res1 = 0 ;
21548   void *argp2 = 0 ;
21549   int res2 = 0 ;
21550   void *argp3 = 0 ;
21551   int res3 = 0 ;
21552   void *argp4 = 0 ;
21553   int res4 = 0 ;
21554   void *argp5 = 0 ;
21555   int res5 = 0 ;
21556   void *argp6 = 0 ;
21557   int res6 = 0 ;
21558   PyObject * obj0 = 0 ;
21559   PyObject * obj1 = 0 ;
21560   PyObject * obj2 = 0 ;
21561   PyObject * obj3 = 0 ;
21562   PyObject * obj4 = 0 ;
21563   PyObject * obj5 = 0 ;
21564   Hex::Hexa *result = 0 ;
21565
21566   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Hexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
21567   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21568   if (!SWIG_IsOK(res1)) {
21569     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Hexa" "', argument " "1"" of type '" "Hex::Quad *""'");
21570   }
21571   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
21572   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21573   if (!SWIG_IsOK(res2)) {
21574     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Hexa" "', argument " "2"" of type '" "Hex::Quad *""'");
21575   }
21576   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
21577   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21578   if (!SWIG_IsOK(res3)) {
21579     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Hexa" "', argument " "3"" of type '" "Hex::Quad *""'");
21580   }
21581   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
21582   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21583   if (!SWIG_IsOK(res4)) {
21584     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Hexa" "', argument " "4"" of type '" "Hex::Quad *""'");
21585   }
21586   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
21587   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21588   if (!SWIG_IsOK(res5)) {
21589     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Hexa" "', argument " "5"" of type '" "Hex::Quad *""'");
21590   }
21591   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
21592   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21593   if (!SWIG_IsOK(res6)) {
21594     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Hexa" "', argument " "6"" of type '" "Hex::Quad *""'");
21595   }
21596   arg6 = reinterpret_cast< Hex::Quad * >(argp6);
21597   result = (Hex::Hexa *)new Hex::Hexa(arg1,arg2,arg3,arg4,arg5,arg6);
21598   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, SWIG_POINTER_NEW |  0 );
21599   return resultobj;
21600 fail:
21601   return NULL;
21602 }
21603
21604
21605 SWIGINTERN PyObject *_wrap_delete_Hexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21606   PyObject *resultobj = 0;
21607   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
21608   void *argp1 = 0 ;
21609   int res1 = 0 ;
21610   PyObject * obj0 = 0 ;
21611
21612   if (!PyArg_ParseTuple(args,(char *)"O:delete_Hexa",&obj0)) SWIG_fail;
21613   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, SWIG_POINTER_DISOWN |  0 );
21614   if (!SWIG_IsOK(res1)) {
21615     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hexa" "', argument " "1"" of type '" "Hex::Hexa *""'");
21616   }
21617   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
21618   delete arg1;
21619   resultobj = SWIG_Py_Void();
21620   return resultobj;
21621 fail:
21622   return NULL;
21623 }
21624
21625
21626 SWIGINTERN PyObject *Hexa_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21627   PyObject *obj;
21628   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
21629   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hexa, SWIG_NewClientData(obj));
21630   return SWIG_Py_Void();
21631 }
21632
21633 SWIGINTERN PyObject *_wrap_Vector_getDx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21634   PyObject *resultobj = 0;
21635   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
21636   void *argp1 = 0 ;
21637   int res1 = 0 ;
21638   PyObject * obj0 = 0 ;
21639   double result;
21640
21641   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDx",&obj0)) SWIG_fail;
21642   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
21643   if (!SWIG_IsOK(res1)) {
21644     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDx" "', argument " "1"" of type '" "Hex::Vector *""'");
21645   }
21646   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
21647   result = (double)(arg1)->getDx();
21648   resultobj = SWIG_From_double(static_cast< double >(result));
21649   return resultobj;
21650 fail:
21651   return NULL;
21652 }
21653
21654
21655 SWIGINTERN PyObject *_wrap_Vector_getDy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21656   PyObject *resultobj = 0;
21657   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
21658   void *argp1 = 0 ;
21659   int res1 = 0 ;
21660   PyObject * obj0 = 0 ;
21661   double result;
21662
21663   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDy",&obj0)) SWIG_fail;
21664   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
21665   if (!SWIG_IsOK(res1)) {
21666     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDy" "', argument " "1"" of type '" "Hex::Vector *""'");
21667   }
21668   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
21669   result = (double)(arg1)->getDy();
21670   resultobj = SWIG_From_double(static_cast< double >(result));
21671   return resultobj;
21672 fail:
21673   return NULL;
21674 }
21675
21676
21677 SWIGINTERN PyObject *_wrap_Vector_getDz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21678   PyObject *resultobj = 0;
21679   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
21680   void *argp1 = 0 ;
21681   int res1 = 0 ;
21682   PyObject * obj0 = 0 ;
21683   double result;
21684
21685   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDz",&obj0)) SWIG_fail;
21686   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
21687   if (!SWIG_IsOK(res1)) {
21688     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDz" "', argument " "1"" of type '" "Hex::Vector *""'");
21689   }
21690   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
21691   result = (double)(arg1)->getDz();
21692   resultobj = SWIG_From_double(static_cast< double >(result));
21693   return resultobj;
21694 fail:
21695   return NULL;
21696 }
21697
21698
21699 SWIGINTERN PyObject *_wrap_Vector_getNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21700   PyObject *resultobj = 0;
21701   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
21702   void *argp1 = 0 ;
21703   int res1 = 0 ;
21704   PyObject * obj0 = 0 ;
21705   double result;
21706
21707   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getNorm",&obj0)) SWIG_fail;
21708   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
21709   if (!SWIG_IsOK(res1)) {
21710     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getNorm" "', argument " "1"" of type '" "Hex::Vector *""'");
21711   }
21712   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
21713   result = (double)(arg1)->getNorm();
21714   resultobj = SWIG_From_double(static_cast< double >(result));
21715   return resultobj;
21716 fail:
21717   return NULL;
21718 }
21719
21720
21721 SWIGINTERN PyObject *_wrap_Vector_getAngleX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21722   PyObject *resultobj = 0;
21723   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
21724   void *argp1 = 0 ;
21725   int res1 = 0 ;
21726   PyObject * obj0 = 0 ;
21727   double result;
21728
21729   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getAngleX",&obj0)) SWIG_fail;
21730   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
21731   if (!SWIG_IsOK(res1)) {
21732     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getAngleX" "', argument " "1"" of type '" "Hex::Vector *""'");
21733   }
21734   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
21735   result = (double)(arg1)->getAngleX();
21736   resultobj = SWIG_From_double(static_cast< double >(result));
21737   return resultobj;
21738 fail:
21739   return NULL;
21740 }
21741
21742
21743 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21744   PyObject *resultobj = 0;
21745   Hex::Document *arg1 = (Hex::Document *) 0 ;
21746   double arg2 ;
21747   double arg3 ;
21748   double arg4 ;
21749   void *argp1 = 0 ;
21750   int res1 = 0 ;
21751   double val2 ;
21752   int ecode2 = 0 ;
21753   double val3 ;
21754   int ecode3 = 0 ;
21755   double val4 ;
21756   int ecode4 = 0 ;
21757   PyObject * obj0 = 0 ;
21758   PyObject * obj1 = 0 ;
21759   PyObject * obj2 = 0 ;
21760   PyObject * obj3 = 0 ;
21761   Hex::Vector *result = 0 ;
21762
21763   if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21764   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21765   if (!SWIG_IsOK(res1)) {
21766     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
21767   }
21768   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21769   ecode2 = SWIG_AsVal_double(obj1, &val2);
21770   if (!SWIG_IsOK(ecode2)) {
21771     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
21772   }
21773   arg2 = static_cast< double >(val2);
21774   ecode3 = SWIG_AsVal_double(obj2, &val3);
21775   if (!SWIG_IsOK(ecode3)) {
21776     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vector" "', argument " "3"" of type '" "double""'");
21777   }
21778   arg3 = static_cast< double >(val3);
21779   ecode4 = SWIG_AsVal_double(obj3, &val4);
21780   if (!SWIG_IsOK(ecode4)) {
21781     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vector" "', argument " "4"" of type '" "double""'");
21782   }
21783   arg4 = static_cast< double >(val4);
21784   result = (Hex::Vector *)new Hex::Vector(arg1,arg2,arg3,arg4);
21785   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
21786   return resultobj;
21787 fail:
21788   return NULL;
21789 }
21790
21791
21792 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21793   PyObject *resultobj = 0;
21794   Hex::Document *arg1 = (Hex::Document *) 0 ;
21795   double arg2 ;
21796   double arg3 ;
21797   void *argp1 = 0 ;
21798   int res1 = 0 ;
21799   double val2 ;
21800   int ecode2 = 0 ;
21801   double val3 ;
21802   int ecode3 = 0 ;
21803   PyObject * obj0 = 0 ;
21804   PyObject * obj1 = 0 ;
21805   PyObject * obj2 = 0 ;
21806   Hex::Vector *result = 0 ;
21807
21808   if (!PyArg_ParseTuple(args,(char *)"OOO:new_Vector",&obj0,&obj1,&obj2)) SWIG_fail;
21809   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21810   if (!SWIG_IsOK(res1)) {
21811     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
21812   }
21813   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21814   ecode2 = SWIG_AsVal_double(obj1, &val2);
21815   if (!SWIG_IsOK(ecode2)) {
21816     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
21817   }
21818   arg2 = static_cast< double >(val2);
21819   ecode3 = SWIG_AsVal_double(obj2, &val3);
21820   if (!SWIG_IsOK(ecode3)) {
21821     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vector" "', argument " "3"" of type '" "double""'");
21822   }
21823   arg3 = static_cast< double >(val3);
21824   result = (Hex::Vector *)new Hex::Vector(arg1,arg2,arg3);
21825   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
21826   return resultobj;
21827 fail:
21828   return NULL;
21829 }
21830
21831
21832 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21833   PyObject *resultobj = 0;
21834   Hex::Document *arg1 = (Hex::Document *) 0 ;
21835   double arg2 ;
21836   void *argp1 = 0 ;
21837   int res1 = 0 ;
21838   double val2 ;
21839   int ecode2 = 0 ;
21840   PyObject * obj0 = 0 ;
21841   PyObject * obj1 = 0 ;
21842   Hex::Vector *result = 0 ;
21843
21844   if (!PyArg_ParseTuple(args,(char *)"OO:new_Vector",&obj0,&obj1)) SWIG_fail;
21845   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21846   if (!SWIG_IsOK(res1)) {
21847     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
21848   }
21849   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21850   ecode2 = SWIG_AsVal_double(obj1, &val2);
21851   if (!SWIG_IsOK(ecode2)) {
21852     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
21853   }
21854   arg2 = static_cast< double >(val2);
21855   result = (Hex::Vector *)new Hex::Vector(arg1,arg2);
21856   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
21857   return resultobj;
21858 fail:
21859   return NULL;
21860 }
21861
21862
21863 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21864   PyObject *resultobj = 0;
21865   Hex::Document *arg1 = (Hex::Document *) 0 ;
21866   void *argp1 = 0 ;
21867   int res1 = 0 ;
21868   PyObject * obj0 = 0 ;
21869   Hex::Vector *result = 0 ;
21870
21871   if (!PyArg_ParseTuple(args,(char *)"O:new_Vector",&obj0)) SWIG_fail;
21872   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21873   if (!SWIG_IsOK(res1)) {
21874     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
21875   }
21876   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21877   result = (Hex::Vector *)new Hex::Vector(arg1);
21878   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
21879   return resultobj;
21880 fail:
21881   return NULL;
21882 }
21883
21884
21885 SWIGINTERN PyObject *_wrap_new_Vector(PyObject *self, PyObject *args) {
21886   int argc;
21887   PyObject *argv[5];
21888   int ii;
21889
21890   if (!PyTuple_Check(args)) SWIG_fail;
21891   argc = (int)PyObject_Length(args);
21892   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
21893     argv[ii] = PyTuple_GET_ITEM(args,ii);
21894   }
21895   if (argc == 1) {
21896     int _v;
21897     void *vptr = 0;
21898     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21899     _v = SWIG_CheckState(res);
21900     if (_v) {
21901       return _wrap_new_Vector__SWIG_3(self, args);
21902     }
21903   }
21904   if (argc == 2) {
21905     int _v;
21906     void *vptr = 0;
21907     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21908     _v = SWIG_CheckState(res);
21909     if (_v) {
21910       {
21911         int res = SWIG_AsVal_double(argv[1], NULL);
21912         _v = SWIG_CheckState(res);
21913       }
21914       if (_v) {
21915         return _wrap_new_Vector__SWIG_2(self, args);
21916       }
21917     }
21918   }
21919   if (argc == 3) {
21920     int _v;
21921     void *vptr = 0;
21922     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21923     _v = SWIG_CheckState(res);
21924     if (_v) {
21925       {
21926         int res = SWIG_AsVal_double(argv[1], NULL);
21927         _v = SWIG_CheckState(res);
21928       }
21929       if (_v) {
21930         {
21931           int res = SWIG_AsVal_double(argv[2], NULL);
21932           _v = SWIG_CheckState(res);
21933         }
21934         if (_v) {
21935           return _wrap_new_Vector__SWIG_1(self, args);
21936         }
21937       }
21938     }
21939   }
21940   if (argc == 4) {
21941     int _v;
21942     void *vptr = 0;
21943     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21944     _v = SWIG_CheckState(res);
21945     if (_v) {
21946       {
21947         int res = SWIG_AsVal_double(argv[1], NULL);
21948         _v = SWIG_CheckState(res);
21949       }
21950       if (_v) {
21951         {
21952           int res = SWIG_AsVal_double(argv[2], NULL);
21953           _v = SWIG_CheckState(res);
21954         }
21955         if (_v) {
21956           {
21957             int res = SWIG_AsVal_double(argv[3], NULL);
21958             _v = SWIG_CheckState(res);
21959           }
21960           if (_v) {
21961             return _wrap_new_Vector__SWIG_0(self, args);
21962           }
21963         }
21964       }
21965     }
21966   }
21967
21968 fail:
21969   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vector'.\n"
21970     "  Possible C/C++ prototypes are:\n"
21971     "    Hex::Vector(Hex::Document *,double,double,double)\n"
21972     "    Hex::Vector(Hex::Document *,double,double)\n"
21973     "    Hex::Vector(Hex::Document *,double)\n"
21974     "    Hex::Vector(Hex::Document *)\n");
21975   return NULL;
21976 }
21977
21978
21979 SWIGINTERN PyObject *_wrap_delete_Vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21980   PyObject *resultobj = 0;
21981   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
21982   void *argp1 = 0 ;
21983   int res1 = 0 ;
21984   PyObject * obj0 = 0 ;
21985
21986   if (!PyArg_ParseTuple(args,(char *)"O:delete_Vector",&obj0)) SWIG_fail;
21987   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, SWIG_POINTER_DISOWN |  0 );
21988   if (!SWIG_IsOK(res1)) {
21989     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector" "', argument " "1"" of type '" "Hex::Vector *""'");
21990   }
21991   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
21992   delete arg1;
21993   resultobj = SWIG_Py_Void();
21994   return resultobj;
21995 fail:
21996   return NULL;
21997 }
21998
21999
22000 SWIGINTERN PyObject *Vector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22001   PyObject *obj;
22002   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
22003   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vector, SWIG_NewClientData(obj));
22004   return SWIG_Py_Void();
22005 }
22006
22007 SWIGINTERN PyObject *_wrap_new_Document__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22008   PyObject *resultobj = 0;
22009   cpchar arg1 = (cpchar) 0 ;
22010   Hex::Hex *arg2 = (Hex::Hex *) 0 ;
22011   int res1 ;
22012   char *buf1 = 0 ;
22013   int alloc1 = 0 ;
22014   void *argp2 = 0 ;
22015   int res2 = 0 ;
22016   PyObject * obj0 = 0 ;
22017   PyObject * obj1 = 0 ;
22018   Hex::Document *result = 0 ;
22019
22020   if (!PyArg_ParseTuple(args,(char *)"OO:new_Document",&obj0,&obj1)) SWIG_fail;
22021   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
22022   if (!SWIG_IsOK(res1)) {
22023     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Document" "', argument " "1"" of type '" "cpchar""'");
22024   }
22025   arg1 = reinterpret_cast< cpchar >(buf1);
22026   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hex, 0 |  0 );
22027   if (!SWIG_IsOK(res2)) {
22028     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Document" "', argument " "2"" of type '" "Hex::Hex *""'");
22029   }
22030   arg2 = reinterpret_cast< Hex::Hex * >(argp2);
22031   result = (Hex::Document *)new Hex::Document(arg1,arg2);
22032   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, SWIG_POINTER_NEW |  0 );
22033   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22034   return resultobj;
22035 fail:
22036   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22037   return NULL;
22038 }
22039
22040
22041 SWIGINTERN PyObject *_wrap_new_Document__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22042   PyObject *resultobj = 0;
22043   cpchar arg1 = (cpchar) 0 ;
22044   int res1 ;
22045   char *buf1 = 0 ;
22046   int alloc1 = 0 ;
22047   PyObject * obj0 = 0 ;
22048   Hex::Document *result = 0 ;
22049
22050   if (!PyArg_ParseTuple(args,(char *)"O:new_Document",&obj0)) SWIG_fail;
22051   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
22052   if (!SWIG_IsOK(res1)) {
22053     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Document" "', argument " "1"" of type '" "cpchar""'");
22054   }
22055   arg1 = reinterpret_cast< cpchar >(buf1);
22056   result = (Hex::Document *)new Hex::Document(arg1);
22057   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, SWIG_POINTER_NEW |  0 );
22058   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22059   return resultobj;
22060 fail:
22061   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22062   return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_new_Document(PyObject *self, PyObject *args) {
22067   int argc;
22068   PyObject *argv[3];
22069   int ii;
22070
22071   if (!PyTuple_Check(args)) SWIG_fail;
22072   argc = (int)PyObject_Length(args);
22073   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22074     argv[ii] = PyTuple_GET_ITEM(args,ii);
22075   }
22076   if (argc == 1) {
22077     int _v;
22078     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
22079     _v = SWIG_CheckState(res);
22080     if (_v) {
22081       return _wrap_new_Document__SWIG_1(self, args);
22082     }
22083   }
22084   if (argc == 2) {
22085     int _v;
22086     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
22087     _v = SWIG_CheckState(res);
22088     if (_v) {
22089       void *vptr = 0;
22090       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Hex, 0);
22091       _v = SWIG_CheckState(res);
22092       if (_v) {
22093         return _wrap_new_Document__SWIG_0(self, args);
22094       }
22095     }
22096   }
22097
22098 fail:
22099   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Document'.\n"
22100     "  Possible C/C++ prototypes are:\n"
22101     "    Hex::Document(cpchar,Hex::Hex *)\n"
22102     "    Hex::Document(cpchar)\n");
22103   return NULL;
22104 }
22105
22106
22107 SWIGINTERN PyObject *_wrap_Document_dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22108   PyObject *resultobj = 0;
22109   Hex::Document *arg1 = (Hex::Document *) 0 ;
22110   void *argp1 = 0 ;
22111   int res1 = 0 ;
22112   PyObject * obj0 = 0 ;
22113
22114   if (!PyArg_ParseTuple(args,(char *)"O:Document_dump",&obj0)) SWIG_fail;
22115   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22116   if (!SWIG_IsOK(res1)) {
22117     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_dump" "', argument " "1"" of type '" "Hex::Document *""'");
22118   }
22119   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22120   (arg1)->dump();
22121   resultobj = SWIG_Py_Void();
22122   return resultobj;
22123 fail:
22124   return NULL;
22125 }
22126
22127
22128 SWIGINTERN PyObject *_wrap_Document_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22129   PyObject *resultobj = 0;
22130   Hex::Document *arg1 = (Hex::Document *) 0 ;
22131   char *arg2 = (char *) 0 ;
22132   void *argp1 = 0 ;
22133   int res1 = 0 ;
22134   int res2 ;
22135   char *buf2 = 0 ;
22136   int alloc2 = 0 ;
22137   PyObject * obj0 = 0 ;
22138   PyObject * obj1 = 0 ;
22139   int result;
22140
22141   if (!PyArg_ParseTuple(args,(char *)"OO:Document_setName",&obj0,&obj1)) SWIG_fail;
22142   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22143   if (!SWIG_IsOK(res1)) {
22144     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setName" "', argument " "1"" of type '" "Hex::Document *""'");
22145   }
22146   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22147   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22148   if (!SWIG_IsOK(res2)) {
22149     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_setName" "', argument " "2"" of type '" "char const *""'");
22150   }
22151   arg2 = reinterpret_cast< char * >(buf2);
22152   result = (int)(arg1)->setName((char const *)arg2);
22153   resultobj = SWIG_From_int(static_cast< int >(result));
22154   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22155   return resultobj;
22156 fail:
22157   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22158   return NULL;
22159 }
22160
22161
22162 SWIGINTERN PyObject *_wrap_Document_setLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22163   PyObject *resultobj = 0;
22164   Hex::Document *arg1 = (Hex::Document *) 0 ;
22165   int arg2 ;
22166   void *argp1 = 0 ;
22167   int res1 = 0 ;
22168   int val2 ;
22169   int ecode2 = 0 ;
22170   PyObject * obj0 = 0 ;
22171   PyObject * obj1 = 0 ;
22172
22173   if (!PyArg_ParseTuple(args,(char *)"OO:Document_setLevel",&obj0,&obj1)) SWIG_fail;
22174   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22175   if (!SWIG_IsOK(res1)) {
22176     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setLevel" "', argument " "1"" of type '" "Hex::Document *""'");
22177   }
22178   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22179   ecode2 = SWIG_AsVal_int(obj1, &val2);
22180   if (!SWIG_IsOK(ecode2)) {
22181     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_setLevel" "', argument " "2"" of type '" "int""'");
22182   }
22183   arg2 = static_cast< int >(val2);
22184   (arg1)->setLevel(arg2);
22185   resultobj = SWIG_Py_Void();
22186   return resultobj;
22187 fail:
22188   return NULL;
22189 }
22190
22191
22192 SWIGINTERN PyObject *_wrap_Document_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22193   PyObject *resultobj = 0;
22194   Hex::Document *arg1 = (Hex::Document *) 0 ;
22195   char *arg2 = (char *) 0 ;
22196   void *argp1 = 0 ;
22197   int res1 = 0 ;
22198   int res2 ;
22199   char *buf2 = 0 ;
22200   int alloc2 = 0 ;
22201   PyObject * obj0 = 0 ;
22202   PyObject * obj1 = 0 ;
22203   int result;
22204
22205   if (!PyArg_ParseTuple(args,(char *)"OO:Document_save",&obj0,&obj1)) SWIG_fail;
22206   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22207   if (!SWIG_IsOK(res1)) {
22208     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_save" "', argument " "1"" of type '" "Hex::Document *""'");
22209   }
22210   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22211   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22212   if (!SWIG_IsOK(res2)) {
22213     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_save" "', argument " "2"" of type '" "char const *""'");
22214   }
22215   arg2 = reinterpret_cast< char * >(buf2);
22216   result = (int)(arg1)->save((char const *)arg2);
22217   resultobj = SWIG_From_int(static_cast< int >(result));
22218   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22219   return resultobj;
22220 fail:
22221   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22222   return NULL;
22223 }
22224
22225
22226 SWIGINTERN PyObject *_wrap_Document_saveVtk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22227   PyObject *resultobj = 0;
22228   Hex::Document *arg1 = (Hex::Document *) 0 ;
22229   cpchar arg2 = (cpchar) 0 ;
22230   void *argp1 = 0 ;
22231   int res1 = 0 ;
22232   int res2 ;
22233   char *buf2 = 0 ;
22234   int alloc2 = 0 ;
22235   PyObject * obj0 = 0 ;
22236   PyObject * obj1 = 0 ;
22237   int result;
22238
22239   if (!PyArg_ParseTuple(args,(char *)"OO:Document_saveVtk",&obj0,&obj1)) SWIG_fail;
22240   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22241   if (!SWIG_IsOK(res1)) {
22242     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_saveVtk" "', argument " "1"" of type '" "Hex::Document *""'");
22243   }
22244   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22245   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22246   if (!SWIG_IsOK(res2)) {
22247     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_saveVtk" "', argument " "2"" of type '" "cpchar""'");
22248   }
22249   arg2 = reinterpret_cast< cpchar >(buf2);
22250   result = (int)(arg1)->saveVtk(arg2);
22251   resultobj = SWIG_From_int(static_cast< int >(result));
22252   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22253   return resultobj;
22254 fail:
22255   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22256   return NULL;
22257 }
22258
22259
22260 SWIGINTERN PyObject *_wrap_Document_purge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22261   PyObject *resultobj = 0;
22262   Hex::Document *arg1 = (Hex::Document *) 0 ;
22263   void *argp1 = 0 ;
22264   int res1 = 0 ;
22265   PyObject * obj0 = 0 ;
22266
22267   if (!PyArg_ParseTuple(args,(char *)"O:Document_purge",&obj0)) SWIG_fail;
22268   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22269   if (!SWIG_IsOK(res1)) {
22270     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_purge" "', argument " "1"" of type '" "Hex::Document *""'");
22271   }
22272   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22273   (arg1)->purge();
22274   resultobj = SWIG_Py_Void();
22275   return resultobj;
22276 fail:
22277   return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_Document_setTolerance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282   PyObject *resultobj = 0;
22283   Hex::Document *arg1 = (Hex::Document *) 0 ;
22284   double arg2 ;
22285   void *argp1 = 0 ;
22286   int res1 = 0 ;
22287   double val2 ;
22288   int ecode2 = 0 ;
22289   PyObject * obj0 = 0 ;
22290   PyObject * obj1 = 0 ;
22291
22292   if (!PyArg_ParseTuple(args,(char *)"OO:Document_setTolerance",&obj0,&obj1)) SWIG_fail;
22293   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22294   if (!SWIG_IsOK(res1)) {
22295     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setTolerance" "', argument " "1"" of type '" "Hex::Document *""'");
22296   }
22297   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22298   ecode2 = SWIG_AsVal_double(obj1, &val2);
22299   if (!SWIG_IsOK(ecode2)) {
22300     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_setTolerance" "', argument " "2"" of type '" "double""'");
22301   }
22302   arg2 = static_cast< double >(val2);
22303   (arg1)->setTolerance(arg2);
22304   resultobj = SWIG_Py_Void();
22305   return resultobj;
22306 fail:
22307   return NULL;
22308 }
22309
22310
22311 SWIGINTERN PyObject *_wrap_Document_getTolerance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312   PyObject *resultobj = 0;
22313   Hex::Document *arg1 = (Hex::Document *) 0 ;
22314   void *argp1 = 0 ;
22315   int res1 = 0 ;
22316   PyObject * obj0 = 0 ;
22317   double result;
22318
22319   if (!PyArg_ParseTuple(args,(char *)"O:Document_getTolerance",&obj0)) SWIG_fail;
22320   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22321   if (!SWIG_IsOK(res1)) {
22322     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getTolerance" "', argument " "1"" of type '" "Hex::Document *""'");
22323   }
22324   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22325   result = (double)(arg1)->getTolerance();
22326   resultobj = SWIG_From_double(static_cast< double >(result));
22327   return resultobj;
22328 fail:
22329   return NULL;
22330 }
22331
22332
22333 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22334   PyObject *resultobj = 0;
22335   Hex::Document *arg1 = (Hex::Document *) 0 ;
22336   double arg2 ;
22337   double arg3 ;
22338   double arg4 ;
22339   void *argp1 = 0 ;
22340   int res1 = 0 ;
22341   double val2 ;
22342   int ecode2 = 0 ;
22343   double val3 ;
22344   int ecode3 = 0 ;
22345   double val4 ;
22346   int ecode4 = 0 ;
22347   PyObject * obj0 = 0 ;
22348   PyObject * obj1 = 0 ;
22349   PyObject * obj2 = 0 ;
22350   PyObject * obj3 = 0 ;
22351   Hex::Vertex *result = 0 ;
22352
22353   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22354   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22355   if (!SWIG_IsOK(res1)) {
22356     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
22357   }
22358   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22359   ecode2 = SWIG_AsVal_double(obj1, &val2);
22360   if (!SWIG_IsOK(ecode2)) {
22361     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
22362   }
22363   arg2 = static_cast< double >(val2);
22364   ecode3 = SWIG_AsVal_double(obj2, &val3);
22365   if (!SWIG_IsOK(ecode3)) {
22366     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVertex" "', argument " "3"" of type '" "double""'");
22367   }
22368   arg3 = static_cast< double >(val3);
22369   ecode4 = SWIG_AsVal_double(obj3, &val4);
22370   if (!SWIG_IsOK(ecode4)) {
22371     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_addVertex" "', argument " "4"" of type '" "double""'");
22372   }
22373   arg4 = static_cast< double >(val4);
22374   result = (Hex::Vertex *)(arg1)->addVertex(arg2,arg3,arg4);
22375   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22376   return resultobj;
22377 fail:
22378   return NULL;
22379 }
22380
22381
22382 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22383   PyObject *resultobj = 0;
22384   Hex::Document *arg1 = (Hex::Document *) 0 ;
22385   double arg2 ;
22386   double arg3 ;
22387   void *argp1 = 0 ;
22388   int res1 = 0 ;
22389   double val2 ;
22390   int ecode2 = 0 ;
22391   double val3 ;
22392   int ecode3 = 0 ;
22393   PyObject * obj0 = 0 ;
22394   PyObject * obj1 = 0 ;
22395   PyObject * obj2 = 0 ;
22396   Hex::Vertex *result = 0 ;
22397
22398   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVertex",&obj0,&obj1,&obj2)) SWIG_fail;
22399   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22400   if (!SWIG_IsOK(res1)) {
22401     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
22402   }
22403   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22404   ecode2 = SWIG_AsVal_double(obj1, &val2);
22405   if (!SWIG_IsOK(ecode2)) {
22406     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
22407   }
22408   arg2 = static_cast< double >(val2);
22409   ecode3 = SWIG_AsVal_double(obj2, &val3);
22410   if (!SWIG_IsOK(ecode3)) {
22411     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVertex" "', argument " "3"" of type '" "double""'");
22412   }
22413   arg3 = static_cast< double >(val3);
22414   result = (Hex::Vertex *)(arg1)->addVertex(arg2,arg3);
22415   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22416   return resultobj;
22417 fail:
22418   return NULL;
22419 }
22420
22421
22422 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22423   PyObject *resultobj = 0;
22424   Hex::Document *arg1 = (Hex::Document *) 0 ;
22425   double arg2 ;
22426   void *argp1 = 0 ;
22427   int res1 = 0 ;
22428   double val2 ;
22429   int ecode2 = 0 ;
22430   PyObject * obj0 = 0 ;
22431   PyObject * obj1 = 0 ;
22432   Hex::Vertex *result = 0 ;
22433
22434   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertex",&obj0,&obj1)) SWIG_fail;
22435   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22436   if (!SWIG_IsOK(res1)) {
22437     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
22438   }
22439   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22440   ecode2 = SWIG_AsVal_double(obj1, &val2);
22441   if (!SWIG_IsOK(ecode2)) {
22442     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
22443   }
22444   arg2 = static_cast< double >(val2);
22445   result = (Hex::Vertex *)(arg1)->addVertex(arg2);
22446   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22447   return resultobj;
22448 fail:
22449   return NULL;
22450 }
22451
22452
22453 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22454   PyObject *resultobj = 0;
22455   Hex::Document *arg1 = (Hex::Document *) 0 ;
22456   void *argp1 = 0 ;
22457   int res1 = 0 ;
22458   PyObject * obj0 = 0 ;
22459   Hex::Vertex *result = 0 ;
22460
22461   if (!PyArg_ParseTuple(args,(char *)"O:Document_addVertex",&obj0)) SWIG_fail;
22462   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22463   if (!SWIG_IsOK(res1)) {
22464     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
22465   }
22466   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22467   result = (Hex::Vertex *)(arg1)->addVertex();
22468   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22469   return resultobj;
22470 fail:
22471   return NULL;
22472 }
22473
22474
22475 SWIGINTERN PyObject *_wrap_Document_addVertex(PyObject *self, PyObject *args) {
22476   int argc;
22477   PyObject *argv[5];
22478   int ii;
22479
22480   if (!PyTuple_Check(args)) SWIG_fail;
22481   argc = (int)PyObject_Length(args);
22482   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
22483     argv[ii] = PyTuple_GET_ITEM(args,ii);
22484   }
22485   if (argc == 1) {
22486     int _v;
22487     void *vptr = 0;
22488     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22489     _v = SWIG_CheckState(res);
22490     if (_v) {
22491       return _wrap_Document_addVertex__SWIG_3(self, args);
22492     }
22493   }
22494   if (argc == 2) {
22495     int _v;
22496     void *vptr = 0;
22497     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22498     _v = SWIG_CheckState(res);
22499     if (_v) {
22500       {
22501         int res = SWIG_AsVal_double(argv[1], NULL);
22502         _v = SWIG_CheckState(res);
22503       }
22504       if (_v) {
22505         return _wrap_Document_addVertex__SWIG_2(self, args);
22506       }
22507     }
22508   }
22509   if (argc == 3) {
22510     int _v;
22511     void *vptr = 0;
22512     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22513     _v = SWIG_CheckState(res);
22514     if (_v) {
22515       {
22516         int res = SWIG_AsVal_double(argv[1], NULL);
22517         _v = SWIG_CheckState(res);
22518       }
22519       if (_v) {
22520         {
22521           int res = SWIG_AsVal_double(argv[2], NULL);
22522           _v = SWIG_CheckState(res);
22523         }
22524         if (_v) {
22525           return _wrap_Document_addVertex__SWIG_1(self, args);
22526         }
22527       }
22528     }
22529   }
22530   if (argc == 4) {
22531     int _v;
22532     void *vptr = 0;
22533     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22534     _v = SWIG_CheckState(res);
22535     if (_v) {
22536       {
22537         int res = SWIG_AsVal_double(argv[1], NULL);
22538         _v = SWIG_CheckState(res);
22539       }
22540       if (_v) {
22541         {
22542           int res = SWIG_AsVal_double(argv[2], NULL);
22543           _v = SWIG_CheckState(res);
22544         }
22545         if (_v) {
22546           {
22547             int res = SWIG_AsVal_double(argv[3], NULL);
22548             _v = SWIG_CheckState(res);
22549           }
22550           if (_v) {
22551             return _wrap_Document_addVertex__SWIG_0(self, args);
22552           }
22553         }
22554       }
22555     }
22556   }
22557
22558 fail:
22559   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addVertex'.\n"
22560     "  Possible C/C++ prototypes are:\n"
22561     "    addVertex(Hex::Document *,double,double,double)\n"
22562     "    addVertex(Hex::Document *,double,double)\n"
22563     "    addVertex(Hex::Document *,double)\n"
22564     "    addVertex(Hex::Document *)\n");
22565   return NULL;
22566 }
22567
22568
22569 SWIGINTERN PyObject *_wrap_Document_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22570   PyObject *resultobj = 0;
22571   Hex::Document *arg1 = (Hex::Document *) 0 ;
22572   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
22573   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22574   void *argp1 = 0 ;
22575   int res1 = 0 ;
22576   void *argp2 = 0 ;
22577   int res2 = 0 ;
22578   void *argp3 = 0 ;
22579   int res3 = 0 ;
22580   PyObject * obj0 = 0 ;
22581   PyObject * obj1 = 0 ;
22582   PyObject * obj2 = 0 ;
22583   Hex::Edge *result = 0 ;
22584
22585   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdge",&obj0,&obj1,&obj2)) SWIG_fail;
22586   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22587   if (!SWIG_IsOK(res1)) {
22588     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdge" "', argument " "1"" of type '" "Hex::Document *""'");
22589   }
22590   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22591   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22592   if (!SWIG_IsOK(res2)) {
22593     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdge" "', argument " "2"" of type '" "Hex::Vertex *""'");
22594   }
22595   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
22596   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22597   if (!SWIG_IsOK(res3)) {
22598     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addEdge" "', argument " "3"" of type '" "Hex::Vertex *""'");
22599   }
22600   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22601   result = (Hex::Edge *)(arg1)->addEdge(arg2,arg3);
22602   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
22603   return resultobj;
22604 fail:
22605   return NULL;
22606 }
22607
22608
22609 SWIGINTERN PyObject *_wrap_Document_addEdgeVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22610   PyObject *resultobj = 0;
22611   Hex::Document *arg1 = (Hex::Document *) 0 ;
22612   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
22613   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
22614   void *argp1 = 0 ;
22615   int res1 = 0 ;
22616   void *argp2 = 0 ;
22617   int res2 = 0 ;
22618   void *argp3 = 0 ;
22619   int res3 = 0 ;
22620   PyObject * obj0 = 0 ;
22621   PyObject * obj1 = 0 ;
22622   PyObject * obj2 = 0 ;
22623   Hex::Edge *result = 0 ;
22624
22625   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdgeVector",&obj0,&obj1,&obj2)) SWIG_fail;
22626   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22627   if (!SWIG_IsOK(res1)) {
22628     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeVector" "', argument " "1"" of type '" "Hex::Document *""'");
22629   }
22630   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22631   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22632   if (!SWIG_IsOK(res2)) {
22633     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeVector" "', argument " "2"" of type '" "Hex::Vertex *""'");
22634   }
22635   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
22636   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
22637   if (!SWIG_IsOK(res3)) {
22638     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addEdgeVector" "', argument " "3"" of type '" "Hex::Vector *""'");
22639   }
22640   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
22641   result = (Hex::Edge *)(arg1)->addEdgeVector(arg2,arg3);
22642   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
22643   return resultobj;
22644 fail:
22645   return NULL;
22646 }
22647
22648
22649 SWIGINTERN PyObject *_wrap_Document_addQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22650   PyObject *resultobj = 0;
22651   Hex::Document *arg1 = (Hex::Document *) 0 ;
22652   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
22653   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
22654   Hex::Edge *arg4 = (Hex::Edge *) 0 ;
22655   Hex::Edge *arg5 = (Hex::Edge *) 0 ;
22656   void *argp1 = 0 ;
22657   int res1 = 0 ;
22658   void *argp2 = 0 ;
22659   int res2 = 0 ;
22660   void *argp3 = 0 ;
22661   int res3 = 0 ;
22662   void *argp4 = 0 ;
22663   int res4 = 0 ;
22664   void *argp5 = 0 ;
22665   int res5 = 0 ;
22666   PyObject * obj0 = 0 ;
22667   PyObject * obj1 = 0 ;
22668   PyObject * obj2 = 0 ;
22669   PyObject * obj3 = 0 ;
22670   PyObject * obj4 = 0 ;
22671   Hex::Quad *result = 0 ;
22672
22673   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22674   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22675   if (!SWIG_IsOK(res1)) {
22676     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuad" "', argument " "1"" of type '" "Hex::Document *""'");
22677   }
22678   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22679   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
22680   if (!SWIG_IsOK(res2)) {
22681     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuad" "', argument " "2"" of type '" "Hex::Edge *""'");
22682   }
22683   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
22684   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
22685   if (!SWIG_IsOK(res3)) {
22686     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addQuad" "', argument " "3"" of type '" "Hex::Edge *""'");
22687   }
22688   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
22689   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Edge, 0 |  0 );
22690   if (!SWIG_IsOK(res4)) {
22691     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addQuad" "', argument " "4"" of type '" "Hex::Edge *""'");
22692   }
22693   arg4 = reinterpret_cast< Hex::Edge * >(argp4);
22694   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Edge, 0 |  0 );
22695   if (!SWIG_IsOK(res5)) {
22696     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addQuad" "', argument " "5"" of type '" "Hex::Edge *""'");
22697   }
22698   arg5 = reinterpret_cast< Hex::Edge * >(argp5);
22699   result = (Hex::Quad *)(arg1)->addQuad(arg2,arg3,arg4,arg5);
22700   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
22701   return resultobj;
22702 fail:
22703   return NULL;
22704 }
22705
22706
22707 SWIGINTERN PyObject *_wrap_Document_addQuadVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22708   PyObject *resultobj = 0;
22709   Hex::Document *arg1 = (Hex::Document *) 0 ;
22710   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
22711   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22712   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
22713   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
22714   void *argp1 = 0 ;
22715   int res1 = 0 ;
22716   void *argp2 = 0 ;
22717   int res2 = 0 ;
22718   void *argp3 = 0 ;
22719   int res3 = 0 ;
22720   void *argp4 = 0 ;
22721   int res4 = 0 ;
22722   void *argp5 = 0 ;
22723   int res5 = 0 ;
22724   PyObject * obj0 = 0 ;
22725   PyObject * obj1 = 0 ;
22726   PyObject * obj2 = 0 ;
22727   PyObject * obj3 = 0 ;
22728   PyObject * obj4 = 0 ;
22729   Hex::Quad *result = 0 ;
22730
22731   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuadVertices",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22732   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22733   if (!SWIG_IsOK(res1)) {
22734     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadVertices" "', argument " "1"" of type '" "Hex::Document *""'");
22735   }
22736   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22737   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22738   if (!SWIG_IsOK(res2)) {
22739     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
22740   }
22741   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
22742   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22743   if (!SWIG_IsOK(res3)) {
22744     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addQuadVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
22745   }
22746   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22747   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22748   if (!SWIG_IsOK(res4)) {
22749     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addQuadVertices" "', argument " "4"" of type '" "Hex::Vertex *""'");
22750   }
22751   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
22752   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22753   if (!SWIG_IsOK(res5)) {
22754     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addQuadVertices" "', argument " "5"" of type '" "Hex::Vertex *""'");
22755   }
22756   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
22757   result = (Hex::Quad *)(arg1)->addQuadVertices(arg2,arg3,arg4,arg5);
22758   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
22759   return resultobj;
22760 fail:
22761   return NULL;
22762 }
22763
22764
22765 SWIGINTERN PyObject *_wrap_Document_addHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22766   PyObject *resultobj = 0;
22767   Hex::Document *arg1 = (Hex::Document *) 0 ;
22768   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
22769   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
22770   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
22771   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
22772   Hex::Quad *arg6 = (Hex::Quad *) 0 ;
22773   Hex::Quad *arg7 = (Hex::Quad *) 0 ;
22774   void *argp1 = 0 ;
22775   int res1 = 0 ;
22776   void *argp2 = 0 ;
22777   int res2 = 0 ;
22778   void *argp3 = 0 ;
22779   int res3 = 0 ;
22780   void *argp4 = 0 ;
22781   int res4 = 0 ;
22782   void *argp5 = 0 ;
22783   int res5 = 0 ;
22784   void *argp6 = 0 ;
22785   int res6 = 0 ;
22786   void *argp7 = 0 ;
22787   int res7 = 0 ;
22788   PyObject * obj0 = 0 ;
22789   PyObject * obj1 = 0 ;
22790   PyObject * obj2 = 0 ;
22791   PyObject * obj3 = 0 ;
22792   PyObject * obj4 = 0 ;
22793   PyObject * obj5 = 0 ;
22794   PyObject * obj6 = 0 ;
22795   Hex::Hexa *result = 0 ;
22796
22797   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_addHexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22798   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22799   if (!SWIG_IsOK(res1)) {
22800     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa" "', argument " "1"" of type '" "Hex::Document *""'");
22801   }
22802   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22803   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22804   if (!SWIG_IsOK(res2)) {
22805     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa" "', argument " "2"" of type '" "Hex::Quad *""'");
22806   }
22807   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
22808   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22809   if (!SWIG_IsOK(res3)) {
22810     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa" "', argument " "3"" of type '" "Hex::Quad *""'");
22811   }
22812   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
22813   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22814   if (!SWIG_IsOK(res4)) {
22815     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa" "', argument " "4"" of type '" "Hex::Quad *""'");
22816   }
22817   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
22818   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22819   if (!SWIG_IsOK(res5)) {
22820     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa" "', argument " "5"" of type '" "Hex::Quad *""'");
22821   }
22822   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
22823   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22824   if (!SWIG_IsOK(res6)) {
22825     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexa" "', argument " "6"" of type '" "Hex::Quad *""'");
22826   }
22827   arg6 = reinterpret_cast< Hex::Quad * >(argp6);
22828   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22829   if (!SWIG_IsOK(res7)) {
22830     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_addHexa" "', argument " "7"" of type '" "Hex::Quad *""'");
22831   }
22832   arg7 = reinterpret_cast< Hex::Quad * >(argp7);
22833   result = (Hex::Hexa *)(arg1)->addHexa(arg2,arg3,arg4,arg5,arg6,arg7);
22834   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
22835   return resultobj;
22836 fail:
22837   return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_Document_addHexaVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22842   PyObject *resultobj = 0;
22843   Hex::Document *arg1 = (Hex::Document *) 0 ;
22844   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
22845   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22846   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
22847   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
22848   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
22849   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
22850   Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
22851   Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
22852   void *argp1 = 0 ;
22853   int res1 = 0 ;
22854   void *argp2 = 0 ;
22855   int res2 = 0 ;
22856   void *argp3 = 0 ;
22857   int res3 = 0 ;
22858   void *argp4 = 0 ;
22859   int res4 = 0 ;
22860   void *argp5 = 0 ;
22861   int res5 = 0 ;
22862   void *argp6 = 0 ;
22863   int res6 = 0 ;
22864   void *argp7 = 0 ;
22865   int res7 = 0 ;
22866   void *argp8 = 0 ;
22867   int res8 = 0 ;
22868   void *argp9 = 0 ;
22869   int res9 = 0 ;
22870   PyObject * obj0 = 0 ;
22871   PyObject * obj1 = 0 ;
22872   PyObject * obj2 = 0 ;
22873   PyObject * obj3 = 0 ;
22874   PyObject * obj4 = 0 ;
22875   PyObject * obj5 = 0 ;
22876   PyObject * obj6 = 0 ;
22877   PyObject * obj7 = 0 ;
22878   PyObject * obj8 = 0 ;
22879   Hex::Hexa *result = 0 ;
22880
22881   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_addHexaVertices",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
22882   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22883   if (!SWIG_IsOK(res1)) {
22884     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaVertices" "', argument " "1"" of type '" "Hex::Document *""'");
22885   }
22886   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22887   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22888   if (!SWIG_IsOK(res2)) {
22889     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
22890   }
22891   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
22892   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22893   if (!SWIG_IsOK(res3)) {
22894     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexaVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
22895   }
22896   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22897   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22898   if (!SWIG_IsOK(res4)) {
22899     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexaVertices" "', argument " "4"" of type '" "Hex::Vertex *""'");
22900   }
22901   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
22902   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22903   if (!SWIG_IsOK(res5)) {
22904     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexaVertices" "', argument " "5"" of type '" "Hex::Vertex *""'");
22905   }
22906   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
22907   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22908   if (!SWIG_IsOK(res6)) {
22909     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexaVertices" "', argument " "6"" of type '" "Hex::Vertex *""'");
22910   }
22911   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
22912   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22913   if (!SWIG_IsOK(res7)) {
22914     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_addHexaVertices" "', argument " "7"" of type '" "Hex::Vertex *""'");
22915   }
22916   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
22917   res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22918   if (!SWIG_IsOK(res8)) {
22919     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_addHexaVertices" "', argument " "8"" of type '" "Hex::Vertex *""'");
22920   }
22921   arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
22922   res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22923   if (!SWIG_IsOK(res9)) {
22924     SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Document_addHexaVertices" "', argument " "9"" of type '" "Hex::Vertex *""'");
22925   }
22926   arg9 = reinterpret_cast< Hex::Vertex * >(argp9);
22927   result = (Hex::Hexa *)(arg1)->addHexaVertices(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
22928   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
22929   return resultobj;
22930 fail:
22931   return NULL;
22932 }
22933
22934
22935 SWIGINTERN PyObject *_wrap_Document_addHexa2Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22936   PyObject *resultobj = 0;
22937   Hex::Document *arg1 = (Hex::Document *) 0 ;
22938   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
22939   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
22940   void *argp1 = 0 ;
22941   int res1 = 0 ;
22942   void *argp2 = 0 ;
22943   int res2 = 0 ;
22944   void *argp3 = 0 ;
22945   int res3 = 0 ;
22946   PyObject * obj0 = 0 ;
22947   PyObject * obj1 = 0 ;
22948   PyObject * obj2 = 0 ;
22949   Hex::Hexa *result = 0 ;
22950
22951   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addHexa2Quads",&obj0,&obj1,&obj2)) SWIG_fail;
22952   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22953   if (!SWIG_IsOK(res1)) {
22954     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa2Quads" "', argument " "1"" of type '" "Hex::Document *""'");
22955   }
22956   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22957   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22958   if (!SWIG_IsOK(res2)) {
22959     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa2Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
22960   }
22961   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
22962   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22963   if (!SWIG_IsOK(res3)) {
22964     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa2Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
22965   }
22966   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
22967   result = (Hex::Hexa *)(arg1)->addHexa2Quads(arg2,arg3);
22968   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
22969   return resultobj;
22970 fail:
22971   return NULL;
22972 }
22973
22974
22975 SWIGINTERN PyObject *_wrap_Document_addHexa3Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22976   PyObject *resultobj = 0;
22977   Hex::Document *arg1 = (Hex::Document *) 0 ;
22978   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
22979   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
22980   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
22981   void *argp1 = 0 ;
22982   int res1 = 0 ;
22983   void *argp2 = 0 ;
22984   int res2 = 0 ;
22985   void *argp3 = 0 ;
22986   int res3 = 0 ;
22987   void *argp4 = 0 ;
22988   int res4 = 0 ;
22989   PyObject * obj0 = 0 ;
22990   PyObject * obj1 = 0 ;
22991   PyObject * obj2 = 0 ;
22992   PyObject * obj3 = 0 ;
22993   Hex::Hexa *result = 0 ;
22994
22995   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addHexa3Quads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22996   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22997   if (!SWIG_IsOK(res1)) {
22998     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa3Quads" "', argument " "1"" of type '" "Hex::Document *""'");
22999   }
23000   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23001   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23002   if (!SWIG_IsOK(res2)) {
23003     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa3Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
23004   }
23005   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
23006   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23007   if (!SWIG_IsOK(res3)) {
23008     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa3Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
23009   }
23010   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
23011   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23012   if (!SWIG_IsOK(res4)) {
23013     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa3Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
23014   }
23015   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
23016   result = (Hex::Hexa *)(arg1)->addHexa3Quads(arg2,arg3,arg4);
23017   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
23018   return resultobj;
23019 fail:
23020   return NULL;
23021 }
23022
23023
23024 SWIGINTERN PyObject *_wrap_Document_addHexa4Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23025   PyObject *resultobj = 0;
23026   Hex::Document *arg1 = (Hex::Document *) 0 ;
23027   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
23028   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
23029   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
23030   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
23031   void *argp1 = 0 ;
23032   int res1 = 0 ;
23033   void *argp2 = 0 ;
23034   int res2 = 0 ;
23035   void *argp3 = 0 ;
23036   int res3 = 0 ;
23037   void *argp4 = 0 ;
23038   int res4 = 0 ;
23039   void *argp5 = 0 ;
23040   int res5 = 0 ;
23041   PyObject * obj0 = 0 ;
23042   PyObject * obj1 = 0 ;
23043   PyObject * obj2 = 0 ;
23044   PyObject * obj3 = 0 ;
23045   PyObject * obj4 = 0 ;
23046   Hex::Hexa *result = 0 ;
23047
23048   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addHexa4Quads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23049   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23050   if (!SWIG_IsOK(res1)) {
23051     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa4Quads" "', argument " "1"" of type '" "Hex::Document *""'");
23052   }
23053   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23054   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23055   if (!SWIG_IsOK(res2)) {
23056     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa4Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
23057   }
23058   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
23059   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23060   if (!SWIG_IsOK(res3)) {
23061     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa4Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
23062   }
23063   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
23064   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23065   if (!SWIG_IsOK(res4)) {
23066     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa4Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
23067   }
23068   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
23069   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23070   if (!SWIG_IsOK(res5)) {
23071     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa4Quads" "', argument " "5"" of type '" "Hex::Quad *""'");
23072   }
23073   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
23074   result = (Hex::Hexa *)(arg1)->addHexa4Quads(arg2,arg3,arg4,arg5);
23075   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
23076   return resultobj;
23077 fail:
23078   return NULL;
23079 }
23080
23081
23082 SWIGINTERN PyObject *_wrap_Document_addHexa5Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23083   PyObject *resultobj = 0;
23084   Hex::Document *arg1 = (Hex::Document *) 0 ;
23085   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
23086   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
23087   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
23088   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
23089   Hex::Quad *arg6 = (Hex::Quad *) 0 ;
23090   void *argp1 = 0 ;
23091   int res1 = 0 ;
23092   void *argp2 = 0 ;
23093   int res2 = 0 ;
23094   void *argp3 = 0 ;
23095   int res3 = 0 ;
23096   void *argp4 = 0 ;
23097   int res4 = 0 ;
23098   void *argp5 = 0 ;
23099   int res5 = 0 ;
23100   void *argp6 = 0 ;
23101   int res6 = 0 ;
23102   PyObject * obj0 = 0 ;
23103   PyObject * obj1 = 0 ;
23104   PyObject * obj2 = 0 ;
23105   PyObject * obj3 = 0 ;
23106   PyObject * obj4 = 0 ;
23107   PyObject * obj5 = 0 ;
23108   Hex::Hexa *result = 0 ;
23109
23110   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_addHexa5Quads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
23111   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23112   if (!SWIG_IsOK(res1)) {
23113     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa5Quads" "', argument " "1"" of type '" "Hex::Document *""'");
23114   }
23115   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23116   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23117   if (!SWIG_IsOK(res2)) {
23118     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa5Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
23119   }
23120   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
23121   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23122   if (!SWIG_IsOK(res3)) {
23123     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa5Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
23124   }
23125   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
23126   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23127   if (!SWIG_IsOK(res4)) {
23128     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa5Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
23129   }
23130   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
23131   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23132   if (!SWIG_IsOK(res5)) {
23133     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa5Quads" "', argument " "5"" of type '" "Hex::Quad *""'");
23134   }
23135   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
23136   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23137   if (!SWIG_IsOK(res6)) {
23138     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexa5Quads" "', argument " "6"" of type '" "Hex::Quad *""'");
23139   }
23140   arg6 = reinterpret_cast< Hex::Quad * >(argp6);
23141   result = (Hex::Hexa *)(arg1)->addHexa5Quads(arg2,arg3,arg4,arg5,arg6);
23142   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
23143   return resultobj;
23144 fail:
23145   return NULL;
23146 }
23147
23148
23149 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23150   PyObject *resultobj = 0;
23151   Hex::Document *arg1 = (Hex::Document *) 0 ;
23152   double arg2 ;
23153   double arg3 ;
23154   double arg4 ;
23155   void *argp1 = 0 ;
23156   int res1 = 0 ;
23157   double val2 ;
23158   int ecode2 = 0 ;
23159   double val3 ;
23160   int ecode3 = 0 ;
23161   double val4 ;
23162   int ecode4 = 0 ;
23163   PyObject * obj0 = 0 ;
23164   PyObject * obj1 = 0 ;
23165   PyObject * obj2 = 0 ;
23166   PyObject * obj3 = 0 ;
23167   Hex::Vector *result = 0 ;
23168
23169   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23170   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23171   if (!SWIG_IsOK(res1)) {
23172     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
23173   }
23174   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23175   ecode2 = SWIG_AsVal_double(obj1, &val2);
23176   if (!SWIG_IsOK(ecode2)) {
23177     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
23178   }
23179   arg2 = static_cast< double >(val2);
23180   ecode3 = SWIG_AsVal_double(obj2, &val3);
23181   if (!SWIG_IsOK(ecode3)) {
23182     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVector" "', argument " "3"" of type '" "double""'");
23183   }
23184   arg3 = static_cast< double >(val3);
23185   ecode4 = SWIG_AsVal_double(obj3, &val4);
23186   if (!SWIG_IsOK(ecode4)) {
23187     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_addVector" "', argument " "4"" of type '" "double""'");
23188   }
23189   arg4 = static_cast< double >(val4);
23190   result = (Hex::Vector *)(arg1)->addVector(arg2,arg3,arg4);
23191   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
23192   return resultobj;
23193 fail:
23194   return NULL;
23195 }
23196
23197
23198 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23199   PyObject *resultobj = 0;
23200   Hex::Document *arg1 = (Hex::Document *) 0 ;
23201   double arg2 ;
23202   double arg3 ;
23203   void *argp1 = 0 ;
23204   int res1 = 0 ;
23205   double val2 ;
23206   int ecode2 = 0 ;
23207   double val3 ;
23208   int ecode3 = 0 ;
23209   PyObject * obj0 = 0 ;
23210   PyObject * obj1 = 0 ;
23211   PyObject * obj2 = 0 ;
23212   Hex::Vector *result = 0 ;
23213
23214   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVector",&obj0,&obj1,&obj2)) SWIG_fail;
23215   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23216   if (!SWIG_IsOK(res1)) {
23217     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
23218   }
23219   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23220   ecode2 = SWIG_AsVal_double(obj1, &val2);
23221   if (!SWIG_IsOK(ecode2)) {
23222     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
23223   }
23224   arg2 = static_cast< double >(val2);
23225   ecode3 = SWIG_AsVal_double(obj2, &val3);
23226   if (!SWIG_IsOK(ecode3)) {
23227     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVector" "', argument " "3"" of type '" "double""'");
23228   }
23229   arg3 = static_cast< double >(val3);
23230   result = (Hex::Vector *)(arg1)->addVector(arg2,arg3);
23231   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
23232   return resultobj;
23233 fail:
23234   return NULL;
23235 }
23236
23237
23238 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23239   PyObject *resultobj = 0;
23240   Hex::Document *arg1 = (Hex::Document *) 0 ;
23241   double arg2 ;
23242   void *argp1 = 0 ;
23243   int res1 = 0 ;
23244   double val2 ;
23245   int ecode2 = 0 ;
23246   PyObject * obj0 = 0 ;
23247   PyObject * obj1 = 0 ;
23248   Hex::Vector *result = 0 ;
23249
23250   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVector",&obj0,&obj1)) SWIG_fail;
23251   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23252   if (!SWIG_IsOK(res1)) {
23253     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
23254   }
23255   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23256   ecode2 = SWIG_AsVal_double(obj1, &val2);
23257   if (!SWIG_IsOK(ecode2)) {
23258     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
23259   }
23260   arg2 = static_cast< double >(val2);
23261   result = (Hex::Vector *)(arg1)->addVector(arg2);
23262   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
23263   return resultobj;
23264 fail:
23265   return NULL;
23266 }
23267
23268
23269 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23270   PyObject *resultobj = 0;
23271   Hex::Document *arg1 = (Hex::Document *) 0 ;
23272   void *argp1 = 0 ;
23273   int res1 = 0 ;
23274   PyObject * obj0 = 0 ;
23275   Hex::Vector *result = 0 ;
23276
23277   if (!PyArg_ParseTuple(args,(char *)"O:Document_addVector",&obj0)) SWIG_fail;
23278   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23279   if (!SWIG_IsOK(res1)) {
23280     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
23281   }
23282   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23283   result = (Hex::Vector *)(arg1)->addVector();
23284   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
23285   return resultobj;
23286 fail:
23287   return NULL;
23288 }
23289
23290
23291 SWIGINTERN PyObject *_wrap_Document_addVector(PyObject *self, PyObject *args) {
23292   int argc;
23293   PyObject *argv[5];
23294   int ii;
23295
23296   if (!PyTuple_Check(args)) SWIG_fail;
23297   argc = (int)PyObject_Length(args);
23298   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
23299     argv[ii] = PyTuple_GET_ITEM(args,ii);
23300   }
23301   if (argc == 1) {
23302     int _v;
23303     void *vptr = 0;
23304     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
23305     _v = SWIG_CheckState(res);
23306     if (_v) {
23307       return _wrap_Document_addVector__SWIG_3(self, args);
23308     }
23309   }
23310   if (argc == 2) {
23311     int _v;
23312     void *vptr = 0;
23313     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
23314     _v = SWIG_CheckState(res);
23315     if (_v) {
23316       {
23317         int res = SWIG_AsVal_double(argv[1], NULL);
23318         _v = SWIG_CheckState(res);
23319       }
23320       if (_v) {
23321         return _wrap_Document_addVector__SWIG_2(self, args);
23322       }
23323     }
23324   }
23325   if (argc == 3) {
23326     int _v;
23327     void *vptr = 0;
23328     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
23329     _v = SWIG_CheckState(res);
23330     if (_v) {
23331       {
23332         int res = SWIG_AsVal_double(argv[1], NULL);
23333         _v = SWIG_CheckState(res);
23334       }
23335       if (_v) {
23336         {
23337           int res = SWIG_AsVal_double(argv[2], NULL);
23338           _v = SWIG_CheckState(res);
23339         }
23340         if (_v) {
23341           return _wrap_Document_addVector__SWIG_1(self, args);
23342         }
23343       }
23344     }
23345   }
23346   if (argc == 4) {
23347     int _v;
23348     void *vptr = 0;
23349     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
23350     _v = SWIG_CheckState(res);
23351     if (_v) {
23352       {
23353         int res = SWIG_AsVal_double(argv[1], NULL);
23354         _v = SWIG_CheckState(res);
23355       }
23356       if (_v) {
23357         {
23358           int res = SWIG_AsVal_double(argv[2], NULL);
23359           _v = SWIG_CheckState(res);
23360         }
23361         if (_v) {
23362           {
23363             int res = SWIG_AsVal_double(argv[3], NULL);
23364             _v = SWIG_CheckState(res);
23365           }
23366           if (_v) {
23367             return _wrap_Document_addVector__SWIG_0(self, args);
23368           }
23369         }
23370       }
23371     }
23372   }
23373
23374 fail:
23375   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addVector'.\n"
23376     "  Possible C/C++ prototypes are:\n"
23377     "    addVector(Hex::Document *,double,double,double)\n"
23378     "    addVector(Hex::Document *,double,double)\n"
23379     "    addVector(Hex::Document *,double)\n"
23380     "    addVector(Hex::Document *)\n");
23381   return NULL;
23382 }
23383
23384
23385 SWIGINTERN PyObject *_wrap_Document_addVectorVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23386   PyObject *resultobj = 0;
23387   Hex::Document *arg1 = (Hex::Document *) 0 ;
23388   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
23389   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23390   void *argp1 = 0 ;
23391   int res1 = 0 ;
23392   void *argp2 = 0 ;
23393   int res2 = 0 ;
23394   void *argp3 = 0 ;
23395   int res3 = 0 ;
23396   PyObject * obj0 = 0 ;
23397   PyObject * obj1 = 0 ;
23398   PyObject * obj2 = 0 ;
23399   Hex::Vector *result = 0 ;
23400
23401   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVectorVertices",&obj0,&obj1,&obj2)) SWIG_fail;
23402   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23403   if (!SWIG_IsOK(res1)) {
23404     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVectorVertices" "', argument " "1"" of type '" "Hex::Document *""'");
23405   }
23406   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23407   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23408   if (!SWIG_IsOK(res2)) {
23409     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addVectorVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
23410   }
23411   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
23412   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23413   if (!SWIG_IsOK(res3)) {
23414     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addVectorVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
23415   }
23416   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23417   result = (Hex::Vector *)(arg1)->addVectorVertices(arg2,arg3);
23418   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
23419   return resultobj;
23420 fail:
23421   return NULL;
23422 }
23423
23424
23425 SWIGINTERN PyObject *_wrap_Document_addLaw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23426   PyObject *resultobj = 0;
23427   Hex::Document *arg1 = (Hex::Document *) 0 ;
23428   char *arg2 = (char *) 0 ;
23429   int arg3 ;
23430   void *argp1 = 0 ;
23431   int res1 = 0 ;
23432   int res2 ;
23433   char *buf2 = 0 ;
23434   int alloc2 = 0 ;
23435   int val3 ;
23436   int ecode3 = 0 ;
23437   PyObject * obj0 = 0 ;
23438   PyObject * obj1 = 0 ;
23439   PyObject * obj2 = 0 ;
23440   Hex::Law *result = 0 ;
23441
23442   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaw",&obj0,&obj1,&obj2)) SWIG_fail;
23443   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23444   if (!SWIG_IsOK(res1)) {
23445     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaw" "', argument " "1"" of type '" "Hex::Document *""'");
23446   }
23447   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23448   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23449   if (!SWIG_IsOK(res2)) {
23450     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addLaw" "', argument " "2"" of type '" "char const *""'");
23451   }
23452   arg2 = reinterpret_cast< char * >(buf2);
23453   ecode3 = SWIG_AsVal_int(obj2, &val3);
23454   if (!SWIG_IsOK(ecode3)) {
23455     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addLaw" "', argument " "3"" of type '" "int""'");
23456   }
23457   arg3 = static_cast< int >(val3);
23458   result = (Hex::Law *)(arg1)->addLaw((char const *)arg2,arg3);
23459   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
23460   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23461   return resultobj;
23462 fail:
23463   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23464   return NULL;
23465 }
23466
23467
23468 SWIGINTERN PyObject *_wrap_Document_addLaws__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23469   PyObject *resultobj = 0;
23470   Hex::Document *arg1 = (Hex::Document *) 0 ;
23471   double arg2 ;
23472   bool arg3 ;
23473   void *argp1 = 0 ;
23474   int res1 = 0 ;
23475   double val2 ;
23476   int ecode2 = 0 ;
23477   bool val3 ;
23478   int ecode3 = 0 ;
23479   PyObject * obj0 = 0 ;
23480   PyObject * obj1 = 0 ;
23481   PyObject * obj2 = 0 ;
23482   int result;
23483
23484   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaws",&obj0,&obj1,&obj2)) SWIG_fail;
23485   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23486   if (!SWIG_IsOK(res1)) {
23487     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaws" "', argument " "1"" of type '" "Hex::Document *""'");
23488   }
23489   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23490   ecode2 = SWIG_AsVal_double(obj1, &val2);
23491   if (!SWIG_IsOK(ecode2)) {
23492     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addLaws" "', argument " "2"" of type '" "double""'");
23493   }
23494   arg2 = static_cast< double >(val2);
23495   ecode3 = SWIG_AsVal_bool(obj2, &val3);
23496   if (!SWIG_IsOK(ecode3)) {
23497     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addLaws" "', argument " "3"" of type '" "bool""'");
23498   }
23499   arg3 = static_cast< bool >(val3);
23500   result = (int)(arg1)->addLaws(arg2,arg3);
23501   resultobj = SWIG_From_int(static_cast< int >(result));
23502   return resultobj;
23503 fail:
23504   return NULL;
23505 }
23506
23507
23508 SWIGINTERN PyObject *_wrap_Document_addLaws__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23509   PyObject *resultobj = 0;
23510   Hex::Document *arg1 = (Hex::Document *) 0 ;
23511   double arg2 ;
23512   void *argp1 = 0 ;
23513   int res1 = 0 ;
23514   double val2 ;
23515   int ecode2 = 0 ;
23516   PyObject * obj0 = 0 ;
23517   PyObject * obj1 = 0 ;
23518   int result;
23519
23520   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaws",&obj0,&obj1)) SWIG_fail;
23521   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23522   if (!SWIG_IsOK(res1)) {
23523     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaws" "', argument " "1"" of type '" "Hex::Document *""'");
23524   }
23525   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23526   ecode2 = SWIG_AsVal_double(obj1, &val2);
23527   if (!SWIG_IsOK(ecode2)) {
23528     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addLaws" "', argument " "2"" of type '" "double""'");
23529   }
23530   arg2 = static_cast< double >(val2);
23531   result = (int)(arg1)->addLaws(arg2);
23532   resultobj = SWIG_From_int(static_cast< int >(result));
23533   return resultobj;
23534 fail:
23535   return NULL;
23536 }
23537
23538
23539 SWIGINTERN PyObject *_wrap_Document_addLaws(PyObject *self, PyObject *args) {
23540   int argc;
23541   PyObject *argv[4];
23542   int ii;
23543
23544   if (!PyTuple_Check(args)) SWIG_fail;
23545   argc = (int)PyObject_Length(args);
23546   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
23547     argv[ii] = PyTuple_GET_ITEM(args,ii);
23548   }
23549   if (argc == 2) {
23550     int _v;
23551     void *vptr = 0;
23552     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
23553     _v = SWIG_CheckState(res);
23554     if (_v) {
23555       {
23556         int res = SWIG_AsVal_double(argv[1], NULL);
23557         _v = SWIG_CheckState(res);
23558       }
23559       if (_v) {
23560         return _wrap_Document_addLaws__SWIG_1(self, args);
23561       }
23562     }
23563   }
23564   if (argc == 3) {
23565     int _v;
23566     void *vptr = 0;
23567     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
23568     _v = SWIG_CheckState(res);
23569     if (_v) {
23570       {
23571         int res = SWIG_AsVal_double(argv[1], NULL);
23572         _v = SWIG_CheckState(res);
23573       }
23574       if (_v) {
23575         {
23576           int res = SWIG_AsVal_bool(argv[2], NULL);
23577           _v = SWIG_CheckState(res);
23578         }
23579         if (_v) {
23580           return _wrap_Document_addLaws__SWIG_0(self, args);
23581         }
23582       }
23583     }
23584   }
23585
23586 fail:
23587   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addLaws'.\n"
23588     "  Possible C/C++ prototypes are:\n"
23589     "    addLaws(Hex::Document *,double,bool)\n"
23590     "    addLaws(Hex::Document *,double)\n");
23591   return NULL;
23592 }
23593
23594
23595 SWIGINTERN PyObject *_wrap_Document_addHexaGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23596   PyObject *resultobj = 0;
23597   Hex::Document *arg1 = (Hex::Document *) 0 ;
23598   cpchar arg2 = (cpchar) 0 ;
23599   void *argp1 = 0 ;
23600   int res1 = 0 ;
23601   int res2 ;
23602   char *buf2 = 0 ;
23603   int alloc2 = 0 ;
23604   PyObject * obj0 = 0 ;
23605   PyObject * obj1 = 0 ;
23606   Hex::Group *result = 0 ;
23607
23608   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaGroup",&obj0,&obj1)) SWIG_fail;
23609   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23610   if (!SWIG_IsOK(res1)) {
23611     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaGroup" "', argument " "1"" of type '" "Hex::Document *""'");
23612   }
23613   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23614   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23615   if (!SWIG_IsOK(res2)) {
23616     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaGroup" "', argument " "2"" of type '" "cpchar""'");
23617   }
23618   arg2 = reinterpret_cast< cpchar >(buf2);
23619   result = (Hex::Group *)(arg1)->addHexaGroup(arg2);
23620   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
23621   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23622   return resultobj;
23623 fail:
23624   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23625   return NULL;
23626 }
23627
23628
23629 SWIGINTERN PyObject *_wrap_Document_addQuadGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23630   PyObject *resultobj = 0;
23631   Hex::Document *arg1 = (Hex::Document *) 0 ;
23632   cpchar arg2 = (cpchar) 0 ;
23633   void *argp1 = 0 ;
23634   int res1 = 0 ;
23635   int res2 ;
23636   char *buf2 = 0 ;
23637   int alloc2 = 0 ;
23638   PyObject * obj0 = 0 ;
23639   PyObject * obj1 = 0 ;
23640   Hex::Group *result = 0 ;
23641
23642   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadGroup",&obj0,&obj1)) SWIG_fail;
23643   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23644   if (!SWIG_IsOK(res1)) {
23645     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadGroup" "', argument " "1"" of type '" "Hex::Document *""'");
23646   }
23647   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23648   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23649   if (!SWIG_IsOK(res2)) {
23650     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadGroup" "', argument " "2"" of type '" "cpchar""'");
23651   }
23652   arg2 = reinterpret_cast< cpchar >(buf2);
23653   result = (Hex::Group *)(arg1)->addQuadGroup(arg2);
23654   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
23655   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23656   return resultobj;
23657 fail:
23658   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23659   return NULL;
23660 }
23661
23662
23663 SWIGINTERN PyObject *_wrap_Document_addQuadNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23664   PyObject *resultobj = 0;
23665   Hex::Document *arg1 = (Hex::Document *) 0 ;
23666   cpchar arg2 = (cpchar) 0 ;
23667   void *argp1 = 0 ;
23668   int res1 = 0 ;
23669   int res2 ;
23670   char *buf2 = 0 ;
23671   int alloc2 = 0 ;
23672   PyObject * obj0 = 0 ;
23673   PyObject * obj1 = 0 ;
23674   Hex::Group *result = 0 ;
23675
23676   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadNodeGroup",&obj0,&obj1)) SWIG_fail;
23677   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23678   if (!SWIG_IsOK(res1)) {
23679     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
23680   }
23681   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23682   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23683   if (!SWIG_IsOK(res2)) {
23684     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadNodeGroup" "', argument " "2"" of type '" "cpchar""'");
23685   }
23686   arg2 = reinterpret_cast< cpchar >(buf2);
23687   result = (Hex::Group *)(arg1)->addQuadNodeGroup(arg2);
23688   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
23689   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23690   return resultobj;
23691 fail:
23692   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23693   return NULL;
23694 }
23695
23696
23697 SWIGINTERN PyObject *_wrap_Document_addHexaNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23698   PyObject *resultobj = 0;
23699   Hex::Document *arg1 = (Hex::Document *) 0 ;
23700   cpchar arg2 = (cpchar) 0 ;
23701   void *argp1 = 0 ;
23702   int res1 = 0 ;
23703   int res2 ;
23704   char *buf2 = 0 ;
23705   int alloc2 = 0 ;
23706   PyObject * obj0 = 0 ;
23707   PyObject * obj1 = 0 ;
23708   Hex::Group *result = 0 ;
23709
23710   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaNodeGroup",&obj0,&obj1)) SWIG_fail;
23711   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23712   if (!SWIG_IsOK(res1)) {
23713     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
23714   }
23715   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23716   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23717   if (!SWIG_IsOK(res2)) {
23718     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaNodeGroup" "', argument " "2"" of type '" "cpchar""'");
23719   }
23720   arg2 = reinterpret_cast< cpchar >(buf2);
23721   result = (Hex::Group *)(arg1)->addHexaNodeGroup(arg2);
23722   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
23723   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23724   return resultobj;
23725 fail:
23726   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23727   return NULL;
23728 }
23729
23730
23731 SWIGINTERN PyObject *_wrap_Document_addEdgeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23732   PyObject *resultobj = 0;
23733   Hex::Document *arg1 = (Hex::Document *) 0 ;
23734   cpchar arg2 = (cpchar) 0 ;
23735   void *argp1 = 0 ;
23736   int res1 = 0 ;
23737   int res2 ;
23738   char *buf2 = 0 ;
23739   int alloc2 = 0 ;
23740   PyObject * obj0 = 0 ;
23741   PyObject * obj1 = 0 ;
23742   Hex::Group *result = 0 ;
23743
23744   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeGroup",&obj0,&obj1)) SWIG_fail;
23745   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23746   if (!SWIG_IsOK(res1)) {
23747     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
23748   }
23749   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23750   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23751   if (!SWIG_IsOK(res2)) {
23752     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeGroup" "', argument " "2"" of type '" "cpchar""'");
23753   }
23754   arg2 = reinterpret_cast< cpchar >(buf2);
23755   result = (Hex::Group *)(arg1)->addEdgeGroup(arg2);
23756   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
23757   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23758   return resultobj;
23759 fail:
23760   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23761   return NULL;
23762 }
23763
23764
23765 SWIGINTERN PyObject *_wrap_Document_addEdgeNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23766   PyObject *resultobj = 0;
23767   Hex::Document *arg1 = (Hex::Document *) 0 ;
23768   cpchar arg2 = (cpchar) 0 ;
23769   void *argp1 = 0 ;
23770   int res1 = 0 ;
23771   int res2 ;
23772   char *buf2 = 0 ;
23773   int alloc2 = 0 ;
23774   PyObject * obj0 = 0 ;
23775   PyObject * obj1 = 0 ;
23776   Hex::Group *result = 0 ;
23777
23778   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeNodeGroup",&obj0,&obj1)) SWIG_fail;
23779   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23780   if (!SWIG_IsOK(res1)) {
23781     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
23782   }
23783   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23784   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23785   if (!SWIG_IsOK(res2)) {
23786     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeNodeGroup" "', argument " "2"" of type '" "cpchar""'");
23787   }
23788   arg2 = reinterpret_cast< cpchar >(buf2);
23789   result = (Hex::Group *)(arg1)->addEdgeNodeGroup(arg2);
23790   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
23791   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23792   return resultobj;
23793 fail:
23794   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23795   return NULL;
23796 }
23797
23798
23799 SWIGINTERN PyObject *_wrap_Document_addVertexNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23800   PyObject *resultobj = 0;
23801   Hex::Document *arg1 = (Hex::Document *) 0 ;
23802   cpchar arg2 = (cpchar) 0 ;
23803   void *argp1 = 0 ;
23804   int res1 = 0 ;
23805   int res2 ;
23806   char *buf2 = 0 ;
23807   int alloc2 = 0 ;
23808   PyObject * obj0 = 0 ;
23809   PyObject * obj1 = 0 ;
23810   Hex::Group *result = 0 ;
23811
23812   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertexNodeGroup",&obj0,&obj1)) SWIG_fail;
23813   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23814   if (!SWIG_IsOK(res1)) {
23815     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertexNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
23816   }
23817   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23818   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23819   if (!SWIG_IsOK(res2)) {
23820     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addVertexNodeGroup" "', argument " "2"" of type '" "cpchar""'");
23821   }
23822   arg2 = reinterpret_cast< cpchar >(buf2);
23823   result = (Hex::Group *)(arg1)->addVertexNodeGroup(arg2);
23824   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
23825   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23826   return resultobj;
23827 fail:
23828   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23829   return NULL;
23830 }
23831
23832
23833 SWIGINTERN PyObject *_wrap_Document_makeTranslation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23834   PyObject *resultobj = 0;
23835   Hex::Document *arg1 = (Hex::Document *) 0 ;
23836   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23837   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
23838   void *argp1 = 0 ;
23839   int res1 = 0 ;
23840   void *argp2 = 0 ;
23841   int res2 = 0 ;
23842   void *argp3 = 0 ;
23843   int res3 = 0 ;
23844   PyObject * obj0 = 0 ;
23845   PyObject * obj1 = 0 ;
23846   PyObject * obj2 = 0 ;
23847   Hex::Elements *result = 0 ;
23848
23849   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
23850   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23851   if (!SWIG_IsOK(res1)) {
23852     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeTranslation" "', argument " "1"" of type '" "Hex::Document *""'");
23853   }
23854   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23855   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
23856   if (!SWIG_IsOK(res2)) {
23857     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeTranslation" "', argument " "2"" of type '" "Hex::Elements *""'");
23858   }
23859   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23860   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
23861   if (!SWIG_IsOK(res3)) {
23862     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeTranslation" "', argument " "3"" of type '" "Hex::Vector *""'");
23863   }
23864   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
23865   result = (Hex::Elements *)(arg1)->makeTranslation(arg2,arg3);
23866   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
23867   return resultobj;
23868 fail:
23869   return NULL;
23870 }
23871
23872
23873 SWIGINTERN PyObject *_wrap_Document_makeScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23874   PyObject *resultobj = 0;
23875   Hex::Document *arg1 = (Hex::Document *) 0 ;
23876   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23877   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23878   double arg4 ;
23879   void *argp1 = 0 ;
23880   int res1 = 0 ;
23881   void *argp2 = 0 ;
23882   int res2 = 0 ;
23883   void *argp3 = 0 ;
23884   int res3 = 0 ;
23885   double val4 ;
23886   int ecode4 = 0 ;
23887   PyObject * obj0 = 0 ;
23888   PyObject * obj1 = 0 ;
23889   PyObject * obj2 = 0 ;
23890   PyObject * obj3 = 0 ;
23891   Hex::Elements *result = 0 ;
23892
23893   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23894   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23895   if (!SWIG_IsOK(res1)) {
23896     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeScale" "', argument " "1"" of type '" "Hex::Document *""'");
23897   }
23898   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23899   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
23900   if (!SWIG_IsOK(res2)) {
23901     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeScale" "', argument " "2"" of type '" "Hex::Elements *""'");
23902   }
23903   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23904   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23905   if (!SWIG_IsOK(res3)) {
23906     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeScale" "', argument " "3"" of type '" "Hex::Vertex *""'");
23907   }
23908   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23909   ecode4 = SWIG_AsVal_double(obj3, &val4);
23910   if (!SWIG_IsOK(ecode4)) {
23911     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeScale" "', argument " "4"" of type '" "double""'");
23912   }
23913   arg4 = static_cast< double >(val4);
23914   result = (Hex::Elements *)(arg1)->makeScale(arg2,arg3,arg4);
23915   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
23916   return resultobj;
23917 fail:
23918   return NULL;
23919 }
23920
23921
23922 SWIGINTERN PyObject *_wrap_Document_makeRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23923   PyObject *resultobj = 0;
23924   Hex::Document *arg1 = (Hex::Document *) 0 ;
23925   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23926   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23927   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
23928   double arg5 ;
23929   void *argp1 = 0 ;
23930   int res1 = 0 ;
23931   void *argp2 = 0 ;
23932   int res2 = 0 ;
23933   void *argp3 = 0 ;
23934   int res3 = 0 ;
23935   void *argp4 = 0 ;
23936   int res4 = 0 ;
23937   double val5 ;
23938   int ecode5 = 0 ;
23939   PyObject * obj0 = 0 ;
23940   PyObject * obj1 = 0 ;
23941   PyObject * obj2 = 0 ;
23942   PyObject * obj3 = 0 ;
23943   PyObject * obj4 = 0 ;
23944   Hex::Elements *result = 0 ;
23945
23946   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23947   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23948   if (!SWIG_IsOK(res1)) {
23949     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRotation" "', argument " "1"" of type '" "Hex::Document *""'");
23950   }
23951   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23952   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
23953   if (!SWIG_IsOK(res2)) {
23954     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRotation" "', argument " "2"" of type '" "Hex::Elements *""'");
23955   }
23956   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23957   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23958   if (!SWIG_IsOK(res3)) {
23959     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRotation" "', argument " "3"" of type '" "Hex::Vertex *""'");
23960   }
23961   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23962   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
23963   if (!SWIG_IsOK(res4)) {
23964     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRotation" "', argument " "4"" of type '" "Hex::Vector *""'");
23965   }
23966   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
23967   ecode5 = SWIG_AsVal_double(obj4, &val5);
23968   if (!SWIG_IsOK(ecode5)) {
23969     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeRotation" "', argument " "5"" of type '" "double""'");
23970   }
23971   arg5 = static_cast< double >(val5);
23972   result = (Hex::Elements *)(arg1)->makeRotation(arg2,arg3,arg4,arg5);
23973   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
23974   return resultobj;
23975 fail:
23976   return NULL;
23977 }
23978
23979
23980 SWIGINTERN PyObject *_wrap_Document_makeSymmetryPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23981   PyObject *resultobj = 0;
23982   Hex::Document *arg1 = (Hex::Document *) 0 ;
23983   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23984   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23985   void *argp1 = 0 ;
23986   int res1 = 0 ;
23987   void *argp2 = 0 ;
23988   int res2 = 0 ;
23989   void *argp3 = 0 ;
23990   int res3 = 0 ;
23991   PyObject * obj0 = 0 ;
23992   PyObject * obj1 = 0 ;
23993   PyObject * obj2 = 0 ;
23994   Hex::Elements *result = 0 ;
23995
23996   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
23997   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23998   if (!SWIG_IsOK(res1)) {
23999     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryPoint" "', argument " "1"" of type '" "Hex::Document *""'");
24000   }
24001   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24002   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
24003   if (!SWIG_IsOK(res2)) {
24004     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryPoint" "', argument " "2"" of type '" "Hex::Elements *""'");
24005   }
24006   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
24007   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24008   if (!SWIG_IsOK(res3)) {
24009     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryPoint" "', argument " "3"" of type '" "Hex::Vertex *""'");
24010   }
24011   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24012   result = (Hex::Elements *)(arg1)->makeSymmetryPoint(arg2,arg3);
24013   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
24014   return resultobj;
24015 fail:
24016   return NULL;
24017 }
24018
24019
24020 SWIGINTERN PyObject *_wrap_Document_makeSymmetryLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24021   PyObject *resultobj = 0;
24022   Hex::Document *arg1 = (Hex::Document *) 0 ;
24023   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
24024   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24025   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
24026   void *argp1 = 0 ;
24027   int res1 = 0 ;
24028   void *argp2 = 0 ;
24029   int res2 = 0 ;
24030   void *argp3 = 0 ;
24031   int res3 = 0 ;
24032   void *argp4 = 0 ;
24033   int res4 = 0 ;
24034   PyObject * obj0 = 0 ;
24035   PyObject * obj1 = 0 ;
24036   PyObject * obj2 = 0 ;
24037   PyObject * obj3 = 0 ;
24038   Hex::Elements *result = 0 ;
24039
24040   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24041   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24042   if (!SWIG_IsOK(res1)) {
24043     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryLine" "', argument " "1"" of type '" "Hex::Document *""'");
24044   }
24045   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24046   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
24047   if (!SWIG_IsOK(res2)) {
24048     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryLine" "', argument " "2"" of type '" "Hex::Elements *""'");
24049   }
24050   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
24051   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24052   if (!SWIG_IsOK(res3)) {
24053     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryLine" "', argument " "3"" of type '" "Hex::Vertex *""'");
24054   }
24055   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24056   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
24057   if (!SWIG_IsOK(res4)) {
24058     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSymmetryLine" "', argument " "4"" of type '" "Hex::Vector *""'");
24059   }
24060   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
24061   result = (Hex::Elements *)(arg1)->makeSymmetryLine(arg2,arg3,arg4);
24062   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
24063   return resultobj;
24064 fail:
24065   return NULL;
24066 }
24067
24068
24069 SWIGINTERN PyObject *_wrap_Document_makeSymmetryPlane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24070   PyObject *resultobj = 0;
24071   Hex::Document *arg1 = (Hex::Document *) 0 ;
24072   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
24073   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24074   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
24075   void *argp1 = 0 ;
24076   int res1 = 0 ;
24077   void *argp2 = 0 ;
24078   int res2 = 0 ;
24079   void *argp3 = 0 ;
24080   int res3 = 0 ;
24081   void *argp4 = 0 ;
24082   int res4 = 0 ;
24083   PyObject * obj0 = 0 ;
24084   PyObject * obj1 = 0 ;
24085   PyObject * obj2 = 0 ;
24086   PyObject * obj3 = 0 ;
24087   Hex::Elements *result = 0 ;
24088
24089   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24090   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24091   if (!SWIG_IsOK(res1)) {
24092     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryPlane" "', argument " "1"" of type '" "Hex::Document *""'");
24093   }
24094   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24095   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
24096   if (!SWIG_IsOK(res2)) {
24097     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryPlane" "', argument " "2"" of type '" "Hex::Elements *""'");
24098   }
24099   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
24100   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24101   if (!SWIG_IsOK(res3)) {
24102     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryPlane" "', argument " "3"" of type '" "Hex::Vertex *""'");
24103   }
24104   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24105   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
24106   if (!SWIG_IsOK(res4)) {
24107     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSymmetryPlane" "', argument " "4"" of type '" "Hex::Vector *""'");
24108   }
24109   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
24110   result = (Hex::Elements *)(arg1)->makeSymmetryPlane(arg2,arg3,arg4);
24111   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
24112   return resultobj;
24113 fail:
24114   return NULL;
24115 }
24116
24117
24118 SWIGINTERN PyObject *_wrap_Document_performTranslation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24119   PyObject *resultobj = 0;
24120   Hex::Document *arg1 = (Hex::Document *) 0 ;
24121   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
24122   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
24123   void *argp1 = 0 ;
24124   int res1 = 0 ;
24125   void *argp2 = 0 ;
24126   int res2 = 0 ;
24127   void *argp3 = 0 ;
24128   int res3 = 0 ;
24129   PyObject * obj0 = 0 ;
24130   PyObject * obj1 = 0 ;
24131   PyObject * obj2 = 0 ;
24132   int result;
24133
24134   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
24135   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24136   if (!SWIG_IsOK(res1)) {
24137     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performTranslation" "', argument " "1"" of type '" "Hex::Document *""'");
24138   }
24139   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24140   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
24141   if (!SWIG_IsOK(res2)) {
24142     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performTranslation" "', argument " "2"" of type '" "Hex::Elements *""'");
24143   }
24144   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
24145   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
24146   if (!SWIG_IsOK(res3)) {
24147     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performTranslation" "', argument " "3"" of type '" "Hex::Vector *""'");
24148   }
24149   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
24150   result = (int)(arg1)->performTranslation(arg2,arg3);
24151   resultobj = SWIG_From_int(static_cast< int >(result));
24152   return resultobj;
24153 fail:
24154   return NULL;
24155 }
24156
24157
24158 SWIGINTERN PyObject *_wrap_Document_performScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24159   PyObject *resultobj = 0;
24160   Hex::Document *arg1 = (Hex::Document *) 0 ;
24161   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
24162   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24163   double arg4 ;
24164   void *argp1 = 0 ;
24165   int res1 = 0 ;
24166   void *argp2 = 0 ;
24167   int res2 = 0 ;
24168   void *argp3 = 0 ;
24169   int res3 = 0 ;
24170   double val4 ;
24171   int ecode4 = 0 ;
24172   PyObject * obj0 = 0 ;
24173   PyObject * obj1 = 0 ;
24174   PyObject * obj2 = 0 ;
24175   PyObject * obj3 = 0 ;
24176   int result;
24177
24178   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24179   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24180   if (!SWIG_IsOK(res1)) {
24181     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performScale" "', argument " "1"" of type '" "Hex::Document *""'");
24182   }
24183   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24184   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
24185   if (!SWIG_IsOK(res2)) {
24186     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performScale" "', argument " "2"" of type '" "Hex::Elements *""'");
24187   }
24188   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
24189   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24190   if (!SWIG_IsOK(res3)) {
24191     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performScale" "', argument " "3"" of type '" "Hex::Vertex *""'");
24192   }
24193   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24194   ecode4 = SWIG_AsVal_double(obj3, &val4);
24195   if (!SWIG_IsOK(ecode4)) {
24196     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_performScale" "', argument " "4"" of type '" "double""'");
24197   }
24198   arg4 = static_cast< double >(val4);
24199   result = (int)(arg1)->performScale(arg2,arg3,arg4);
24200   resultobj = SWIG_From_int(static_cast< int >(result));
24201   return resultobj;
24202 fail:
24203   return NULL;
24204 }
24205
24206
24207 SWIGINTERN PyObject *_wrap_Document_performRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24208   PyObject *resultobj = 0;
24209   Hex::Document *arg1 = (Hex::Document *) 0 ;
24210   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
24211   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24212   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
24213   double arg5 ;
24214   void *argp1 = 0 ;
24215   int res1 = 0 ;
24216   void *argp2 = 0 ;
24217   int res2 = 0 ;
24218   void *argp3 = 0 ;
24219   int res3 = 0 ;
24220   void *argp4 = 0 ;
24221   int res4 = 0 ;
24222   double val5 ;
24223   int ecode5 = 0 ;
24224   PyObject * obj0 = 0 ;
24225   PyObject * obj1 = 0 ;
24226   PyObject * obj2 = 0 ;
24227   PyObject * obj3 = 0 ;
24228   PyObject * obj4 = 0 ;
24229   int result;
24230
24231   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_performRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24232   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24233   if (!SWIG_IsOK(res1)) {
24234     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performRotation" "', argument " "1"" of type '" "Hex::Document *""'");
24235   }
24236   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24237   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
24238   if (!SWIG_IsOK(res2)) {
24239     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performRotation" "', argument " "2"" of type '" "Hex::Elements *""'");
24240   }
24241   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
24242   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24243   if (!SWIG_IsOK(res3)) {
24244     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performRotation" "', argument " "3"" of type '" "Hex::Vertex *""'");
24245   }
24246   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24247   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
24248   if (!SWIG_IsOK(res4)) {
24249     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performRotation" "', argument " "4"" of type '" "Hex::Vector *""'");
24250   }
24251   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
24252   ecode5 = SWIG_AsVal_double(obj4, &val5);
24253   if (!SWIG_IsOK(ecode5)) {
24254     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_performRotation" "', argument " "5"" of type '" "double""'");
24255   }
24256   arg5 = static_cast< double >(val5);
24257   result = (int)(arg1)->performRotation(arg2,arg3,arg4,arg5);
24258   resultobj = SWIG_From_int(static_cast< int >(result));
24259   return resultobj;
24260 fail:
24261   return NULL;
24262 }
24263
24264
24265 SWIGINTERN PyObject *_wrap_Document_performSymmetryPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24266   PyObject *resultobj = 0;
24267   Hex::Document *arg1 = (Hex::Document *) 0 ;
24268   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
24269   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24270   void *argp1 = 0 ;
24271   int res1 = 0 ;
24272   void *argp2 = 0 ;
24273   int res2 = 0 ;
24274   void *argp3 = 0 ;
24275   int res3 = 0 ;
24276   PyObject * obj0 = 0 ;
24277   PyObject * obj1 = 0 ;
24278   PyObject * obj2 = 0 ;
24279   int result;
24280
24281   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
24282   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24283   if (!SWIG_IsOK(res1)) {
24284     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryPoint" "', argument " "1"" of type '" "Hex::Document *""'");
24285   }
24286   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24287   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
24288   if (!SWIG_IsOK(res2)) {
24289     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryPoint" "', argument " "2"" of type '" "Hex::Elements *""'");
24290   }
24291   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
24292   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24293   if (!SWIG_IsOK(res3)) {
24294     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryPoint" "', argument " "3"" of type '" "Hex::Vertex *""'");
24295   }
24296   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24297   result = (int)(arg1)->performSymmetryPoint(arg2,arg3);
24298   resultobj = SWIG_From_int(static_cast< int >(result));
24299   return resultobj;
24300 fail:
24301   return NULL;
24302 }
24303
24304
24305 SWIGINTERN PyObject *_wrap_Document_performSymmetryLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24306   PyObject *resultobj = 0;
24307   Hex::Document *arg1 = (Hex::Document *) 0 ;
24308   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
24309   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24310   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
24311   void *argp1 = 0 ;
24312   int res1 = 0 ;
24313   void *argp2 = 0 ;
24314   int res2 = 0 ;
24315   void *argp3 = 0 ;
24316   int res3 = 0 ;
24317   void *argp4 = 0 ;
24318   int res4 = 0 ;
24319   PyObject * obj0 = 0 ;
24320   PyObject * obj1 = 0 ;
24321   PyObject * obj2 = 0 ;
24322   PyObject * obj3 = 0 ;
24323   int result;
24324
24325   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24326   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24327   if (!SWIG_IsOK(res1)) {
24328     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryLine" "', argument " "1"" of type '" "Hex::Document *""'");
24329   }
24330   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24331   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
24332   if (!SWIG_IsOK(res2)) {
24333     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryLine" "', argument " "2"" of type '" "Hex::Elements *""'");
24334   }
24335   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
24336   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24337   if (!SWIG_IsOK(res3)) {
24338     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryLine" "', argument " "3"" of type '" "Hex::Vertex *""'");
24339   }
24340   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24341   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
24342   if (!SWIG_IsOK(res4)) {
24343     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performSymmetryLine" "', argument " "4"" of type '" "Hex::Vector *""'");
24344   }
24345   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
24346   result = (int)(arg1)->performSymmetryLine(arg2,arg3,arg4);
24347   resultobj = SWIG_From_int(static_cast< int >(result));
24348   return resultobj;
24349 fail:
24350   return NULL;
24351 }
24352
24353
24354 SWIGINTERN PyObject *_wrap_Document_performSymmetryPlane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24355   PyObject *resultobj = 0;
24356   Hex::Document *arg1 = (Hex::Document *) 0 ;
24357   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
24358   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24359   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
24360   void *argp1 = 0 ;
24361   int res1 = 0 ;
24362   void *argp2 = 0 ;
24363   int res2 = 0 ;
24364   void *argp3 = 0 ;
24365   int res3 = 0 ;
24366   void *argp4 = 0 ;
24367   int res4 = 0 ;
24368   PyObject * obj0 = 0 ;
24369   PyObject * obj1 = 0 ;
24370   PyObject * obj2 = 0 ;
24371   PyObject * obj3 = 0 ;
24372   int result;
24373
24374   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24375   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24376   if (!SWIG_IsOK(res1)) {
24377     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryPlane" "', argument " "1"" of type '" "Hex::Document *""'");
24378   }
24379   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24380   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
24381   if (!SWIG_IsOK(res2)) {
24382     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryPlane" "', argument " "2"" of type '" "Hex::Elements *""'");
24383   }
24384   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
24385   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24386   if (!SWIG_IsOK(res3)) {
24387     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryPlane" "', argument " "3"" of type '" "Hex::Vertex *""'");
24388   }
24389   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24390   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
24391   if (!SWIG_IsOK(res4)) {
24392     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performSymmetryPlane" "', argument " "4"" of type '" "Hex::Vector *""'");
24393   }
24394   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
24395   result = (int)(arg1)->performSymmetryPlane(arg2,arg3,arg4);
24396   resultobj = SWIG_From_int(static_cast< int >(result));
24397   return resultobj;
24398 fail:
24399   return NULL;
24400 }
24401
24402
24403 SWIGINTERN PyObject *_wrap_Document_disconnectQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24404   PyObject *resultobj = 0;
24405   Hex::Document *arg1 = (Hex::Document *) 0 ;
24406   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
24407   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
24408   void *argp1 = 0 ;
24409   int res1 = 0 ;
24410   void *argp2 = 0 ;
24411   int res2 = 0 ;
24412   void *argp3 = 0 ;
24413   int res3 = 0 ;
24414   PyObject * obj0 = 0 ;
24415   PyObject * obj1 = 0 ;
24416   PyObject * obj2 = 0 ;
24417   Hex::Elements *result = 0 ;
24418
24419   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectQuad",&obj0,&obj1,&obj2)) SWIG_fail;
24420   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24421   if (!SWIG_IsOK(res1)) {
24422     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24423   }
24424   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24425   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
24426   if (!SWIG_IsOK(res2)) {
24427     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectQuad" "', argument " "2"" of type '" "Hex::Hexa *""'");
24428   }
24429   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
24430   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
24431   if (!SWIG_IsOK(res3)) {
24432     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectQuad" "', argument " "3"" of type '" "Hex::Quad *""'");
24433   }
24434   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
24435   result = (Hex::Elements *)(arg1)->disconnectQuad(arg2,arg3);
24436   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
24437   return resultobj;
24438 fail:
24439   return NULL;
24440 }
24441
24442
24443 SWIGINTERN PyObject *_wrap_Document_disconnectEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24444   PyObject *resultobj = 0;
24445   Hex::Document *arg1 = (Hex::Document *) 0 ;
24446   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
24447   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
24448   void *argp1 = 0 ;
24449   int res1 = 0 ;
24450   void *argp2 = 0 ;
24451   int res2 = 0 ;
24452   void *argp3 = 0 ;
24453   int res3 = 0 ;
24454   PyObject * obj0 = 0 ;
24455   PyObject * obj1 = 0 ;
24456   PyObject * obj2 = 0 ;
24457   Hex::Elements *result = 0 ;
24458
24459   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdge",&obj0,&obj1,&obj2)) SWIG_fail;
24460   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24461   if (!SWIG_IsOK(res1)) {
24462     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24463   }
24464   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24465   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
24466   if (!SWIG_IsOK(res2)) {
24467     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectEdge" "', argument " "2"" of type '" "Hex::Hexa *""'");
24468   }
24469   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
24470   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
24471   if (!SWIG_IsOK(res3)) {
24472     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectEdge" "', argument " "3"" of type '" "Hex::Edge *""'");
24473   }
24474   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
24475   result = (Hex::Elements *)(arg1)->disconnectEdge(arg2,arg3);
24476   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
24477   return resultobj;
24478 fail:
24479   return NULL;
24480 }
24481
24482
24483 SWIGINTERN PyObject *_wrap_Document_disconnectVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24484   PyObject *resultobj = 0;
24485   Hex::Document *arg1 = (Hex::Document *) 0 ;
24486   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
24487   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24488   void *argp1 = 0 ;
24489   int res1 = 0 ;
24490   void *argp2 = 0 ;
24491   int res2 = 0 ;
24492   void *argp3 = 0 ;
24493   int res3 = 0 ;
24494   PyObject * obj0 = 0 ;
24495   PyObject * obj1 = 0 ;
24496   PyObject * obj2 = 0 ;
24497   Hex::Elements *result = 0 ;
24498
24499   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectVertex",&obj0,&obj1,&obj2)) SWIG_fail;
24500   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24501   if (!SWIG_IsOK(res1)) {
24502     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24503   }
24504   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24505   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
24506   if (!SWIG_IsOK(res2)) {
24507     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectVertex" "', argument " "2"" of type '" "Hex::Hexa *""'");
24508   }
24509   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
24510   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24511   if (!SWIG_IsOK(res3)) {
24512     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectVertex" "', argument " "3"" of type '" "Hex::Vertex *""'");
24513   }
24514   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24515   result = (Hex::Elements *)(arg1)->disconnectVertex(arg2,arg3);
24516   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
24517   return resultobj;
24518 fail:
24519   return NULL;
24520 }
24521
24522
24523 SWIGINTERN PyObject *_wrap_Document_disconnectEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24524   PyObject *resultobj = 0;
24525   Hex::Document *arg1 = (Hex::Document *) 0 ;
24526   Hex::Hexas arg2 ;
24527   Hex::Edges arg3 ;
24528   void *argp1 = 0 ;
24529   int res1 = 0 ;
24530   PyObject * obj0 = 0 ;
24531   PyObject * obj1 = 0 ;
24532   PyObject * obj2 = 0 ;
24533   Hex::Elements *result = 0 ;
24534
24535   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdges",&obj0,&obj1,&obj2)) SWIG_fail;
24536   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24537   if (!SWIG_IsOK(res1)) {
24538     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectEdges" "', argument " "1"" of type '" "Hex::Document *""'");
24539   }
24540   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24541   {
24542     std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
24543     int res = swig::asptr(obj1, &ptr);
24544     if (!SWIG_IsOK(res) || !ptr) {
24545       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "2"" of type '" "Hex::Hexas""'");
24546     }
24547     arg2 = *ptr;
24548     if (SWIG_IsNewObj(res)) delete ptr;
24549   }
24550   {
24551     std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
24552     int res = swig::asptr(obj2, &ptr);
24553     if (!SWIG_IsOK(res) || !ptr) {
24554       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "3"" of type '" "Hex::Edges""'");
24555     }
24556     arg3 = *ptr;
24557     if (SWIG_IsNewObj(res)) delete ptr;
24558   }
24559   result = (Hex::Elements *)(arg1)->disconnectEdges(arg2,arg3);
24560   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
24561   return resultobj;
24562 fail:
24563   return NULL;
24564 }
24565
24566
24567 SWIGINTERN PyObject *_wrap_Document_replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24568   PyObject *resultobj = 0;
24569   Hex::Document *arg1 = (Hex::Document *) 0 ;
24570   Hex::Quads arg2 ;
24571   Hex::Quads arg3 ;
24572   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
24573   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
24574   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
24575   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
24576   void *argp1 = 0 ;
24577   int res1 = 0 ;
24578   void *argp4 = 0 ;
24579   int res4 = 0 ;
24580   void *argp5 = 0 ;
24581   int res5 = 0 ;
24582   void *argp6 = 0 ;
24583   int res6 = 0 ;
24584   void *argp7 = 0 ;
24585   int res7 = 0 ;
24586   PyObject * obj0 = 0 ;
24587   PyObject * obj1 = 0 ;
24588   PyObject * obj2 = 0 ;
24589   PyObject * obj3 = 0 ;
24590   PyObject * obj4 = 0 ;
24591   PyObject * obj5 = 0 ;
24592   PyObject * obj6 = 0 ;
24593   Hex::Elements *result = 0 ;
24594
24595   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_replace",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24596   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24597   if (!SWIG_IsOK(res1)) {
24598     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_replace" "', argument " "1"" of type '" "Hex::Document *""'");
24599   }
24600   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24601   {
24602     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
24603     int res = swig::asptr(obj1, &ptr);
24604     if (!SWIG_IsOK(res) || !ptr) {
24605       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "2"" of type '" "Hex::Quads""'");
24606     }
24607     arg2 = *ptr;
24608     if (SWIG_IsNewObj(res)) delete ptr;
24609   }
24610   {
24611     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
24612     int res = swig::asptr(obj2, &ptr);
24613     if (!SWIG_IsOK(res) || !ptr) {
24614       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "3"" of type '" "Hex::Quads""'");
24615     }
24616     arg3 = *ptr;
24617     if (SWIG_IsNewObj(res)) delete ptr;
24618   }
24619   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24620   if (!SWIG_IsOK(res4)) {
24621     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_replace" "', argument " "4"" of type '" "Hex::Vertex *""'");
24622   }
24623   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
24624   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24625   if (!SWIG_IsOK(res5)) {
24626     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_replace" "', argument " "5"" of type '" "Hex::Vertex *""'");
24627   }
24628   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
24629   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24630   if (!SWIG_IsOK(res6)) {
24631     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_replace" "', argument " "6"" of type '" "Hex::Vertex *""'");
24632   }
24633   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
24634   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24635   if (!SWIG_IsOK(res7)) {
24636     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_replace" "', argument " "7"" of type '" "Hex::Vertex *""'");
24637   }
24638   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
24639   result = (Hex::Elements *)(arg1)->replace(arg2,arg3,arg4,arg5,arg6,arg7);
24640   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
24641   return resultobj;
24642 fail:
24643   return NULL;
24644 }
24645
24646
24647 SWIGINTERN PyObject *_wrap_Document_mergeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24648   PyObject *resultobj = 0;
24649   Hex::Document *arg1 = (Hex::Document *) 0 ;
24650   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24651   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24652   void *argp1 = 0 ;
24653   int res1 = 0 ;
24654   void *argp2 = 0 ;
24655   int res2 = 0 ;
24656   void *argp3 = 0 ;
24657   int res3 = 0 ;
24658   PyObject * obj0 = 0 ;
24659   PyObject * obj1 = 0 ;
24660   PyObject * obj2 = 0 ;
24661   int result;
24662
24663   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_mergeVertices",&obj0,&obj1,&obj2)) SWIG_fail;
24664   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24665   if (!SWIG_IsOK(res1)) {
24666     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeVertices" "', argument " "1"" of type '" "Hex::Document *""'");
24667   }
24668   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24669   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24670   if (!SWIG_IsOK(res2)) {
24671     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
24672   }
24673   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24674   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24675   if (!SWIG_IsOK(res3)) {
24676     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
24677   }
24678   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24679   result = (int)(arg1)->mergeVertices(arg2,arg3);
24680   resultobj = SWIG_From_int(static_cast< int >(result));
24681   return resultobj;
24682 fail:
24683   return NULL;
24684 }
24685
24686
24687 SWIGINTERN PyObject *_wrap_Document_mergeEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24688   PyObject *resultobj = 0;
24689   Hex::Document *arg1 = (Hex::Document *) 0 ;
24690   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
24691   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
24692   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
24693   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
24694   void *argp1 = 0 ;
24695   int res1 = 0 ;
24696   void *argp2 = 0 ;
24697   int res2 = 0 ;
24698   void *argp3 = 0 ;
24699   int res3 = 0 ;
24700   void *argp4 = 0 ;
24701   int res4 = 0 ;
24702   void *argp5 = 0 ;
24703   int res5 = 0 ;
24704   PyObject * obj0 = 0 ;
24705   PyObject * obj1 = 0 ;
24706   PyObject * obj2 = 0 ;
24707   PyObject * obj3 = 0 ;
24708   PyObject * obj4 = 0 ;
24709   int result;
24710
24711   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_mergeEdges",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24712   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24713   if (!SWIG_IsOK(res1)) {
24714     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeEdges" "', argument " "1"" of type '" "Hex::Document *""'");
24715   }
24716   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24717   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
24718   if (!SWIG_IsOK(res2)) {
24719     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeEdges" "', argument " "2"" of type '" "Hex::Edge *""'");
24720   }
24721   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
24722   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
24723   if (!SWIG_IsOK(res3)) {
24724     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeEdges" "', argument " "3"" of type '" "Hex::Edge *""'");
24725   }
24726   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
24727   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24728   if (!SWIG_IsOK(res4)) {
24729     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_mergeEdges" "', argument " "4"" of type '" "Hex::Vertex *""'");
24730   }
24731   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
24732   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24733   if (!SWIG_IsOK(res5)) {
24734     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_mergeEdges" "', argument " "5"" of type '" "Hex::Vertex *""'");
24735   }
24736   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
24737   result = (int)(arg1)->mergeEdges(arg2,arg3,arg4,arg5);
24738   resultobj = SWIG_From_int(static_cast< int >(result));
24739   return resultobj;
24740 fail:
24741   return NULL;
24742 }
24743
24744
24745 SWIGINTERN PyObject *_wrap_Document_mergeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24746   PyObject *resultobj = 0;
24747   Hex::Document *arg1 = (Hex::Document *) 0 ;
24748   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
24749   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
24750   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
24751   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
24752   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
24753   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
24754   void *argp1 = 0 ;
24755   int res1 = 0 ;
24756   void *argp2 = 0 ;
24757   int res2 = 0 ;
24758   void *argp3 = 0 ;
24759   int res3 = 0 ;
24760   void *argp4 = 0 ;
24761   int res4 = 0 ;
24762   void *argp5 = 0 ;
24763   int res5 = 0 ;
24764   void *argp6 = 0 ;
24765   int res6 = 0 ;
24766   void *argp7 = 0 ;
24767   int res7 = 0 ;
24768   PyObject * obj0 = 0 ;
24769   PyObject * obj1 = 0 ;
24770   PyObject * obj2 = 0 ;
24771   PyObject * obj3 = 0 ;
24772   PyObject * obj4 = 0 ;
24773   PyObject * obj5 = 0 ;
24774   PyObject * obj6 = 0 ;
24775   int result;
24776
24777   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_mergeQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24778   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24779   if (!SWIG_IsOK(res1)) {
24780     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
24781   }
24782   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24783   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
24784   if (!SWIG_IsOK(res2)) {
24785     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeQuads" "', argument " "2"" of type '" "Hex::Quad *""'");
24786   }
24787   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
24788   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
24789   if (!SWIG_IsOK(res3)) {
24790     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
24791   }
24792   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
24793   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24794   if (!SWIG_IsOK(res4)) {
24795     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_mergeQuads" "', argument " "4"" of type '" "Hex::Vertex *""'");
24796   }
24797   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
24798   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24799   if (!SWIG_IsOK(res5)) {
24800     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_mergeQuads" "', argument " "5"" of type '" "Hex::Vertex *""'");
24801   }
24802   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
24803   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24804   if (!SWIG_IsOK(res6)) {
24805     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_mergeQuads" "', argument " "6"" of type '" "Hex::Vertex *""'");
24806   }
24807   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
24808   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24809   if (!SWIG_IsOK(res7)) {
24810     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_mergeQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
24811   }
24812   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
24813   result = (int)(arg1)->mergeQuads(arg2,arg3,arg4,arg5,arg6,arg7);
24814   resultobj = SWIG_From_int(static_cast< int >(result));
24815   return resultobj;
24816 fail:
24817   return NULL;
24818 }
24819
24820
24821 SWIGINTERN PyObject *_wrap_Document_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24822   PyObject *resultobj = 0;
24823   Hex::Document *arg1 = (Hex::Document *) 0 ;
24824   void *argp1 = 0 ;
24825   int res1 = 0 ;
24826   PyObject * obj0 = 0 ;
24827
24828   if (!PyArg_ParseTuple(args,(char *)"O:Document_clearAssociation",&obj0)) SWIG_fail;
24829   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24830   if (!SWIG_IsOK(res1)) {
24831     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_clearAssociation" "', argument " "1"" of type '" "Hex::Document *""'");
24832   }
24833   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24834   (arg1)->clearAssociation();
24835   resultobj = SWIG_Py_Void();
24836   return resultobj;
24837 fail:
24838   return NULL;
24839 }
24840
24841
24842 SWIGINTERN PyObject *_wrap_Document_associateOpenedLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24843   PyObject *resultobj = 0;
24844   Hex::Document *arg1 = (Hex::Document *) 0 ;
24845   Hex::Edges arg2 ;
24846   Hex::NewShapes arg3 ;
24847   Hex::IntVector arg4 ;
24848   double arg5 ;
24849   double arg6 ;
24850   void *argp1 = 0 ;
24851   int res1 = 0 ;
24852   double val5 ;
24853   int ecode5 = 0 ;
24854   double val6 ;
24855   int ecode6 = 0 ;
24856   PyObject * obj0 = 0 ;
24857   PyObject * obj1 = 0 ;
24858   PyObject * obj2 = 0 ;
24859   PyObject * obj3 = 0 ;
24860   PyObject * obj4 = 0 ;
24861   PyObject * obj5 = 0 ;
24862   int result;
24863
24864   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_associateOpenedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
24865   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24866   if (!SWIG_IsOK(res1)) {
24867     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_associateOpenedLine" "', argument " "1"" of type '" "Hex::Document *""'");
24868   }
24869   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24870   {
24871     std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
24872     int res = swig::asptr(obj1, &ptr);
24873     if (!SWIG_IsOK(res) || !ptr) {
24874       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "2"" of type '" "Hex::Edges""'");
24875     }
24876     arg2 = *ptr;
24877     if (SWIG_IsNewObj(res)) delete ptr;
24878   }
24879   {
24880     std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
24881     int res = swig::asptr(obj2, &ptr);
24882     if (!SWIG_IsOK(res) || !ptr) {
24883       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "3"" of type '" "Hex::NewShapes""'");
24884     }
24885     arg3 = *ptr;
24886     if (SWIG_IsNewObj(res)) delete ptr;
24887   }
24888   {
24889     std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
24890     int res = swig::asptr(obj3, &ptr);
24891     if (!SWIG_IsOK(res) || !ptr) {
24892       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "4"" of type '" "Hex::IntVector""'");
24893     }
24894     arg4 = *ptr;
24895     if (SWIG_IsNewObj(res)) delete ptr;
24896   }
24897   ecode5 = SWIG_AsVal_double(obj4, &val5);
24898   if (!SWIG_IsOK(ecode5)) {
24899     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_associateOpenedLine" "', argument " "5"" of type '" "double""'");
24900   }
24901   arg5 = static_cast< double >(val5);
24902   ecode6 = SWIG_AsVal_double(obj5, &val6);
24903   if (!SWIG_IsOK(ecode6)) {
24904     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_associateOpenedLine" "', argument " "6"" of type '" "double""'");
24905   }
24906   arg6 = static_cast< double >(val6);
24907   result = (int)(arg1)->associateOpenedLine(arg2,arg3,arg4,arg5,arg6);
24908   resultobj = SWIG_From_int(static_cast< int >(result));
24909   return resultobj;
24910 fail:
24911   return NULL;
24912 }
24913
24914
24915 SWIGINTERN PyObject *_wrap_Document_associateClosedLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24916   PyObject *resultobj = 0;
24917   Hex::Document *arg1 = (Hex::Document *) 0 ;
24918   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24919   Hex::Edges arg3 ;
24920   Hex::NewShapes arg4 ;
24921   Hex::IntVector arg5 ;
24922   double arg6 ;
24923   bool arg7 ;
24924   void *argp1 = 0 ;
24925   int res1 = 0 ;
24926   void *argp2 = 0 ;
24927   int res2 = 0 ;
24928   double val6 ;
24929   int ecode6 = 0 ;
24930   bool val7 ;
24931   int ecode7 = 0 ;
24932   PyObject * obj0 = 0 ;
24933   PyObject * obj1 = 0 ;
24934   PyObject * obj2 = 0 ;
24935   PyObject * obj3 = 0 ;
24936   PyObject * obj4 = 0 ;
24937   PyObject * obj5 = 0 ;
24938   PyObject * obj6 = 0 ;
24939   int result;
24940
24941   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_associateClosedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24942   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24943   if (!SWIG_IsOK(res1)) {
24944     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_associateClosedLine" "', argument " "1"" of type '" "Hex::Document *""'");
24945   }
24946   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24947   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24948   if (!SWIG_IsOK(res2)) {
24949     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_associateClosedLine" "', argument " "2"" of type '" "Hex::Vertex *""'");
24950   }
24951   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24952   {
24953     std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
24954     int res = swig::asptr(obj2, &ptr);
24955     if (!SWIG_IsOK(res) || !ptr) {
24956       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "3"" of type '" "Hex::Edges""'");
24957     }
24958     arg3 = *ptr;
24959     if (SWIG_IsNewObj(res)) delete ptr;
24960   }
24961   {
24962     std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
24963     int res = swig::asptr(obj3, &ptr);
24964     if (!SWIG_IsOK(res) || !ptr) {
24965       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "4"" of type '" "Hex::NewShapes""'");
24966     }
24967     arg4 = *ptr;
24968     if (SWIG_IsNewObj(res)) delete ptr;
24969   }
24970   {
24971     std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
24972     int res = swig::asptr(obj4, &ptr);
24973     if (!SWIG_IsOK(res) || !ptr) {
24974       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "5"" of type '" "Hex::IntVector""'");
24975     }
24976     arg5 = *ptr;
24977     if (SWIG_IsNewObj(res)) delete ptr;
24978   }
24979   ecode6 = SWIG_AsVal_double(obj5, &val6);
24980   if (!SWIG_IsOK(ecode6)) {
24981     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_associateClosedLine" "', argument " "6"" of type '" "double""'");
24982   }
24983   arg6 = static_cast< double >(val6);
24984   ecode7 = SWIG_AsVal_bool(obj6, &val7);
24985   if (!SWIG_IsOK(ecode7)) {
24986     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_associateClosedLine" "', argument " "7"" of type '" "bool""'");
24987   }
24988   arg7 = static_cast< bool >(val7);
24989   result = (int)(arg1)->associateClosedLine(arg2,arg3,arg4,arg5,arg6,arg7);
24990   resultobj = SWIG_From_int(static_cast< int >(result));
24991   return resultobj;
24992 fail:
24993   return NULL;
24994 }
24995
24996
24997 SWIGINTERN PyObject *_wrap_Document_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24998   PyObject *resultobj = 0;
24999   Hex::Document *arg1 = (Hex::Document *) 0 ;
25000   void *argp1 = 0 ;
25001   int res1 = 0 ;
25002   PyObject * obj0 = 0 ;
25003   int result;
25004
25005   if (!PyArg_ParseTuple(args,(char *)"O:Document_countHexa",&obj0)) SWIG_fail;
25006   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25007   if (!SWIG_IsOK(res1)) {
25008     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25009   }
25010   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25011   result = (int)(arg1)->countHexa();
25012   resultobj = SWIG_From_int(static_cast< int >(result));
25013   return resultobj;
25014 fail:
25015   return NULL;
25016 }
25017
25018
25019 SWIGINTERN PyObject *_wrap_Document_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25020   PyObject *resultobj = 0;
25021   Hex::Document *arg1 = (Hex::Document *) 0 ;
25022   void *argp1 = 0 ;
25023   int res1 = 0 ;
25024   PyObject * obj0 = 0 ;
25025   int result;
25026
25027   if (!PyArg_ParseTuple(args,(char *)"O:Document_countQuad",&obj0)) SWIG_fail;
25028   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25029   if (!SWIG_IsOK(res1)) {
25030     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countQuad" "', argument " "1"" of type '" "Hex::Document *""'");
25031   }
25032   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25033   result = (int)(arg1)->countQuad();
25034   resultobj = SWIG_From_int(static_cast< int >(result));
25035   return resultobj;
25036 fail:
25037   return NULL;
25038 }
25039
25040
25041 SWIGINTERN PyObject *_wrap_Document_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25042   PyObject *resultobj = 0;
25043   Hex::Document *arg1 = (Hex::Document *) 0 ;
25044   void *argp1 = 0 ;
25045   int res1 = 0 ;
25046   PyObject * obj0 = 0 ;
25047   int result;
25048
25049   if (!PyArg_ParseTuple(args,(char *)"O:Document_countEdge",&obj0)) SWIG_fail;
25050   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25051   if (!SWIG_IsOK(res1)) {
25052     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countEdge" "', argument " "1"" of type '" "Hex::Document *""'");
25053   }
25054   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25055   result = (int)(arg1)->countEdge();
25056   resultobj = SWIG_From_int(static_cast< int >(result));
25057   return resultobj;
25058 fail:
25059   return NULL;
25060 }
25061
25062
25063 SWIGINTERN PyObject *_wrap_Document_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25064   PyObject *resultobj = 0;
25065   Hex::Document *arg1 = (Hex::Document *) 0 ;
25066   void *argp1 = 0 ;
25067   int res1 = 0 ;
25068   PyObject * obj0 = 0 ;
25069   int result;
25070
25071   if (!PyArg_ParseTuple(args,(char *)"O:Document_countVertex",&obj0)) SWIG_fail;
25072   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25073   if (!SWIG_IsOK(res1)) {
25074     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countVertex" "', argument " "1"" of type '" "Hex::Document *""'");
25075   }
25076   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25077   result = (int)(arg1)->countVertex();
25078   resultobj = SWIG_From_int(static_cast< int >(result));
25079   return resultobj;
25080 fail:
25081   return NULL;
25082 }
25083
25084
25085 SWIGINTERN PyObject *_wrap_Document_countVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25086   PyObject *resultobj = 0;
25087   Hex::Document *arg1 = (Hex::Document *) 0 ;
25088   void *argp1 = 0 ;
25089   int res1 = 0 ;
25090   PyObject * obj0 = 0 ;
25091   int result;
25092
25093   if (!PyArg_ParseTuple(args,(char *)"O:Document_countVector",&obj0)) SWIG_fail;
25094   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25095   if (!SWIG_IsOK(res1)) {
25096     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countVector" "', argument " "1"" of type '" "Hex::Document *""'");
25097   }
25098   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25099   result = (int)(arg1)->countVector();
25100   resultobj = SWIG_From_int(static_cast< int >(result));
25101   return resultobj;
25102 fail:
25103   return NULL;
25104 }
25105
25106
25107 SWIGINTERN PyObject *_wrap_Document_countGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25108   PyObject *resultobj = 0;
25109   Hex::Document *arg1 = (Hex::Document *) 0 ;
25110   void *argp1 = 0 ;
25111   int res1 = 0 ;
25112   PyObject * obj0 = 0 ;
25113   int result;
25114
25115   if (!PyArg_ParseTuple(args,(char *)"O:Document_countGroup",&obj0)) SWIG_fail;
25116   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25117   if (!SWIG_IsOK(res1)) {
25118     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countGroup" "', argument " "1"" of type '" "Hex::Document *""'");
25119   }
25120   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25121   result = (int)(arg1)->countGroup();
25122   resultobj = SWIG_From_int(static_cast< int >(result));
25123   return resultobj;
25124 fail:
25125   return NULL;
25126 }
25127
25128
25129 SWIGINTERN PyObject *_wrap_Document_countLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25130   PyObject *resultobj = 0;
25131   Hex::Document *arg1 = (Hex::Document *) 0 ;
25132   void *argp1 = 0 ;
25133   int res1 = 0 ;
25134   PyObject * obj0 = 0 ;
25135   int result;
25136
25137   if (!PyArg_ParseTuple(args,(char *)"O:Document_countLaw",&obj0)) SWIG_fail;
25138   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25139   if (!SWIG_IsOK(res1)) {
25140     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countLaw" "', argument " "1"" of type '" "Hex::Document *""'");
25141   }
25142   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25143   result = (int)(arg1)->countLaw();
25144   resultobj = SWIG_From_int(static_cast< int >(result));
25145   return resultobj;
25146 fail:
25147   return NULL;
25148 }
25149
25150
25151 SWIGINTERN PyObject *_wrap_Document_countPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25152   PyObject *resultobj = 0;
25153   Hex::Document *arg1 = (Hex::Document *) 0 ;
25154   void *argp1 = 0 ;
25155   int res1 = 0 ;
25156   PyObject * obj0 = 0 ;
25157   int result;
25158
25159   if (!PyArg_ParseTuple(args,(char *)"O:Document_countPropagation",&obj0)) SWIG_fail;
25160   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25161   if (!SWIG_IsOK(res1)) {
25162     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
25163   }
25164   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25165   result = (int)(arg1)->countPropagation();
25166   resultobj = SWIG_From_int(static_cast< int >(result));
25167   return resultobj;
25168 fail:
25169   return NULL;
25170 }
25171
25172
25173 SWIGINTERN PyObject *_wrap_Document_countShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25174   PyObject *resultobj = 0;
25175   Hex::Document *arg1 = (Hex::Document *) 0 ;
25176   void *argp1 = 0 ;
25177   int res1 = 0 ;
25178   PyObject * obj0 = 0 ;
25179   int result;
25180
25181   if (!PyArg_ParseTuple(args,(char *)"O:Document_countShape",&obj0)) SWIG_fail;
25182   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25183   if (!SWIG_IsOK(res1)) {
25184     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countShape" "', argument " "1"" of type '" "Hex::Document *""'");
25185   }
25186   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25187   result = (int)(arg1)->countShape();
25188   resultobj = SWIG_From_int(static_cast< int >(result));
25189   return resultobj;
25190 fail:
25191   return NULL;
25192 }
25193
25194
25195 SWIGINTERN PyObject *_wrap_Document_countUsedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25196   PyObject *resultobj = 0;
25197   Hex::Document *arg1 = (Hex::Document *) 0 ;
25198   void *argp1 = 0 ;
25199   int res1 = 0 ;
25200   PyObject * obj0 = 0 ;
25201   int result;
25202
25203   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedHexa",&obj0)) SWIG_fail;
25204   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25205   if (!SWIG_IsOK(res1)) {
25206     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25207   }
25208   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25209   result = (int)(arg1)->countUsedHexa();
25210   resultobj = SWIG_From_int(static_cast< int >(result));
25211   return resultobj;
25212 fail:
25213   return NULL;
25214 }
25215
25216
25217 SWIGINTERN PyObject *_wrap_Document_countUsedQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25218   PyObject *resultobj = 0;
25219   Hex::Document *arg1 = (Hex::Document *) 0 ;
25220   void *argp1 = 0 ;
25221   int res1 = 0 ;
25222   PyObject * obj0 = 0 ;
25223   int result;
25224
25225   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedQuad",&obj0)) SWIG_fail;
25226   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25227   if (!SWIG_IsOK(res1)) {
25228     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedQuad" "', argument " "1"" of type '" "Hex::Document *""'");
25229   }
25230   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25231   result = (int)(arg1)->countUsedQuad();
25232   resultobj = SWIG_From_int(static_cast< int >(result));
25233   return resultobj;
25234 fail:
25235   return NULL;
25236 }
25237
25238
25239 SWIGINTERN PyObject *_wrap_Document_countUsedEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25240   PyObject *resultobj = 0;
25241   Hex::Document *arg1 = (Hex::Document *) 0 ;
25242   void *argp1 = 0 ;
25243   int res1 = 0 ;
25244   PyObject * obj0 = 0 ;
25245   int result;
25246
25247   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedEdge",&obj0)) SWIG_fail;
25248   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25249   if (!SWIG_IsOK(res1)) {
25250     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedEdge" "', argument " "1"" of type '" "Hex::Document *""'");
25251   }
25252   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25253   result = (int)(arg1)->countUsedEdge();
25254   resultobj = SWIG_From_int(static_cast< int >(result));
25255   return resultobj;
25256 fail:
25257   return NULL;
25258 }
25259
25260
25261 SWIGINTERN PyObject *_wrap_Document_countUsedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25262   PyObject *resultobj = 0;
25263   Hex::Document *arg1 = (Hex::Document *) 0 ;
25264   void *argp1 = 0 ;
25265   int res1 = 0 ;
25266   PyObject * obj0 = 0 ;
25267   int result;
25268
25269   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedVertex",&obj0)) SWIG_fail;
25270   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25271   if (!SWIG_IsOK(res1)) {
25272     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedVertex" "', argument " "1"" of type '" "Hex::Document *""'");
25273   }
25274   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25275   result = (int)(arg1)->countUsedVertex();
25276   resultobj = SWIG_From_int(static_cast< int >(result));
25277   return resultobj;
25278 fail:
25279   return NULL;
25280 }
25281
25282
25283 SWIGINTERN PyObject *_wrap_Document_getHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25284   PyObject *resultobj = 0;
25285   Hex::Document *arg1 = (Hex::Document *) 0 ;
25286   int arg2 ;
25287   void *argp1 = 0 ;
25288   int res1 = 0 ;
25289   int val2 ;
25290   int ecode2 = 0 ;
25291   PyObject * obj0 = 0 ;
25292   PyObject * obj1 = 0 ;
25293   Hex::Hexa *result = 0 ;
25294
25295   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getHexa",&obj0,&obj1)) SWIG_fail;
25296   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25297   if (!SWIG_IsOK(res1)) {
25298     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25299   }
25300   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25301   ecode2 = SWIG_AsVal_int(obj1, &val2);
25302   if (!SWIG_IsOK(ecode2)) {
25303     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getHexa" "', argument " "2"" of type '" "int""'");
25304   }
25305   arg2 = static_cast< int >(val2);
25306   result = (Hex::Hexa *)(arg1)->getHexa(arg2);
25307   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25308   return resultobj;
25309 fail:
25310   return NULL;
25311 }
25312
25313
25314 SWIGINTERN PyObject *_wrap_Document_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25315   PyObject *resultobj = 0;
25316   Hex::Document *arg1 = (Hex::Document *) 0 ;
25317   int arg2 ;
25318   void *argp1 = 0 ;
25319   int res1 = 0 ;
25320   int val2 ;
25321   int ecode2 = 0 ;
25322   PyObject * obj0 = 0 ;
25323   PyObject * obj1 = 0 ;
25324   Hex::Quad *result = 0 ;
25325
25326   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getQuad",&obj0,&obj1)) SWIG_fail;
25327   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25328   if (!SWIG_IsOK(res1)) {
25329     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getQuad" "', argument " "1"" of type '" "Hex::Document *""'");
25330   }
25331   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25332   ecode2 = SWIG_AsVal_int(obj1, &val2);
25333   if (!SWIG_IsOK(ecode2)) {
25334     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getQuad" "', argument " "2"" of type '" "int""'");
25335   }
25336   arg2 = static_cast< int >(val2);
25337   result = (Hex::Quad *)(arg1)->getQuad(arg2);
25338   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
25339   return resultobj;
25340 fail:
25341   return NULL;
25342 }
25343
25344
25345 SWIGINTERN PyObject *_wrap_Document_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25346   PyObject *resultobj = 0;
25347   Hex::Document *arg1 = (Hex::Document *) 0 ;
25348   int arg2 ;
25349   void *argp1 = 0 ;
25350   int res1 = 0 ;
25351   int val2 ;
25352   int ecode2 = 0 ;
25353   PyObject * obj0 = 0 ;
25354   PyObject * obj1 = 0 ;
25355   Hex::Edge *result = 0 ;
25356
25357   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getEdge",&obj0,&obj1)) SWIG_fail;
25358   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25359   if (!SWIG_IsOK(res1)) {
25360     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getEdge" "', argument " "1"" of type '" "Hex::Document *""'");
25361   }
25362   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25363   ecode2 = SWIG_AsVal_int(obj1, &val2);
25364   if (!SWIG_IsOK(ecode2)) {
25365     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getEdge" "', argument " "2"" of type '" "int""'");
25366   }
25367   arg2 = static_cast< int >(val2);
25368   result = (Hex::Edge *)(arg1)->getEdge(arg2);
25369   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
25370   return resultobj;
25371 fail:
25372   return NULL;
25373 }
25374
25375
25376 SWIGINTERN PyObject *_wrap_Document_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25377   PyObject *resultobj = 0;
25378   Hex::Document *arg1 = (Hex::Document *) 0 ;
25379   int arg2 ;
25380   void *argp1 = 0 ;
25381   int res1 = 0 ;
25382   int val2 ;
25383   int ecode2 = 0 ;
25384   PyObject * obj0 = 0 ;
25385   PyObject * obj1 = 0 ;
25386   Hex::Vertex *result = 0 ;
25387
25388   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVertex",&obj0,&obj1)) SWIG_fail;
25389   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25390   if (!SWIG_IsOK(res1)) {
25391     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getVertex" "', argument " "1"" of type '" "Hex::Document *""'");
25392   }
25393   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25394   ecode2 = SWIG_AsVal_int(obj1, &val2);
25395   if (!SWIG_IsOK(ecode2)) {
25396     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getVertex" "', argument " "2"" of type '" "int""'");
25397   }
25398   arg2 = static_cast< int >(val2);
25399   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
25400   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25401   return resultobj;
25402 fail:
25403   return NULL;
25404 }
25405
25406
25407 SWIGINTERN PyObject *_wrap_Document_getUsedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25408   PyObject *resultobj = 0;
25409   Hex::Document *arg1 = (Hex::Document *) 0 ;
25410   int arg2 ;
25411   void *argp1 = 0 ;
25412   int res1 = 0 ;
25413   int val2 ;
25414   int ecode2 = 0 ;
25415   PyObject * obj0 = 0 ;
25416   PyObject * obj1 = 0 ;
25417   Hex::Hexa *result = 0 ;
25418
25419   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedHexa",&obj0,&obj1)) SWIG_fail;
25420   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25421   if (!SWIG_IsOK(res1)) {
25422     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25423   }
25424   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25425   ecode2 = SWIG_AsVal_int(obj1, &val2);
25426   if (!SWIG_IsOK(ecode2)) {
25427     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedHexa" "', argument " "2"" of type '" "int""'");
25428   }
25429   arg2 = static_cast< int >(val2);
25430   result = (Hex::Hexa *)(arg1)->getUsedHexa(arg2);
25431   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25432   return resultobj;
25433 fail:
25434   return NULL;
25435 }
25436
25437
25438 SWIGINTERN PyObject *_wrap_Document_getUsedQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25439   PyObject *resultobj = 0;
25440   Hex::Document *arg1 = (Hex::Document *) 0 ;
25441   int arg2 ;
25442   void *argp1 = 0 ;
25443   int res1 = 0 ;
25444   int val2 ;
25445   int ecode2 = 0 ;
25446   PyObject * obj0 = 0 ;
25447   PyObject * obj1 = 0 ;
25448   Hex::Quad *result = 0 ;
25449
25450   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedQuad",&obj0,&obj1)) SWIG_fail;
25451   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25452   if (!SWIG_IsOK(res1)) {
25453     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedQuad" "', argument " "1"" of type '" "Hex::Document *""'");
25454   }
25455   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25456   ecode2 = SWIG_AsVal_int(obj1, &val2);
25457   if (!SWIG_IsOK(ecode2)) {
25458     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedQuad" "', argument " "2"" of type '" "int""'");
25459   }
25460   arg2 = static_cast< int >(val2);
25461   result = (Hex::Quad *)(arg1)->getUsedQuad(arg2);
25462   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
25463   return resultobj;
25464 fail:
25465   return NULL;
25466 }
25467
25468
25469 SWIGINTERN PyObject *_wrap_Document_getUsedEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25470   PyObject *resultobj = 0;
25471   Hex::Document *arg1 = (Hex::Document *) 0 ;
25472   int arg2 ;
25473   void *argp1 = 0 ;
25474   int res1 = 0 ;
25475   int val2 ;
25476   int ecode2 = 0 ;
25477   PyObject * obj0 = 0 ;
25478   PyObject * obj1 = 0 ;
25479   Hex::Edge *result = 0 ;
25480
25481   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedEdge",&obj0,&obj1)) SWIG_fail;
25482   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25483   if (!SWIG_IsOK(res1)) {
25484     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedEdge" "', argument " "1"" of type '" "Hex::Document *""'");
25485   }
25486   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25487   ecode2 = SWIG_AsVal_int(obj1, &val2);
25488   if (!SWIG_IsOK(ecode2)) {
25489     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedEdge" "', argument " "2"" of type '" "int""'");
25490   }
25491   arg2 = static_cast< int >(val2);
25492   result = (Hex::Edge *)(arg1)->getUsedEdge(arg2);
25493   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
25494   return resultobj;
25495 fail:
25496   return NULL;
25497 }
25498
25499
25500 SWIGINTERN PyObject *_wrap_Document_getUsedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25501   PyObject *resultobj = 0;
25502   Hex::Document *arg1 = (Hex::Document *) 0 ;
25503   int arg2 ;
25504   void *argp1 = 0 ;
25505   int res1 = 0 ;
25506   int val2 ;
25507   int ecode2 = 0 ;
25508   PyObject * obj0 = 0 ;
25509   PyObject * obj1 = 0 ;
25510   Hex::Vertex *result = 0 ;
25511
25512   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedVertex",&obj0,&obj1)) SWIG_fail;
25513   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25514   if (!SWIG_IsOK(res1)) {
25515     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedVertex" "', argument " "1"" of type '" "Hex::Document *""'");
25516   }
25517   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25518   ecode2 = SWIG_AsVal_int(obj1, &val2);
25519   if (!SWIG_IsOK(ecode2)) {
25520     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedVertex" "', argument " "2"" of type '" "int""'");
25521   }
25522   arg2 = static_cast< int >(val2);
25523   result = (Hex::Vertex *)(arg1)->getUsedVertex(arg2);
25524   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25525   return resultobj;
25526 fail:
25527   return NULL;
25528 }
25529
25530
25531 SWIGINTERN PyObject *_wrap_Document_getVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25532   PyObject *resultobj = 0;
25533   Hex::Document *arg1 = (Hex::Document *) 0 ;
25534   int arg2 ;
25535   void *argp1 = 0 ;
25536   int res1 = 0 ;
25537   int val2 ;
25538   int ecode2 = 0 ;
25539   PyObject * obj0 = 0 ;
25540   PyObject * obj1 = 0 ;
25541   Hex::Vector *result = 0 ;
25542
25543   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVector",&obj0,&obj1)) SWIG_fail;
25544   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25545   if (!SWIG_IsOK(res1)) {
25546     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getVector" "', argument " "1"" of type '" "Hex::Document *""'");
25547   }
25548   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25549   ecode2 = SWIG_AsVal_int(obj1, &val2);
25550   if (!SWIG_IsOK(ecode2)) {
25551     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getVector" "', argument " "2"" of type '" "int""'");
25552   }
25553   arg2 = static_cast< int >(val2);
25554   result = (Hex::Vector *)(arg1)->getVector(arg2);
25555   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
25556   return resultobj;
25557 fail:
25558   return NULL;
25559 }
25560
25561
25562 SWIGINTERN PyObject *_wrap_Document_getShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25563   PyObject *resultobj = 0;
25564   Hex::Document *arg1 = (Hex::Document *) 0 ;
25565   int arg2 ;
25566   void *argp1 = 0 ;
25567   int res1 = 0 ;
25568   int val2 ;
25569   int ecode2 = 0 ;
25570   PyObject * obj0 = 0 ;
25571   PyObject * obj1 = 0 ;
25572   Hex::NewShape *result = 0 ;
25573
25574   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getShape",&obj0,&obj1)) SWIG_fail;
25575   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25576   if (!SWIG_IsOK(res1)) {
25577     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getShape" "', argument " "1"" of type '" "Hex::Document *""'");
25578   }
25579   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25580   ecode2 = SWIG_AsVal_int(obj1, &val2);
25581   if (!SWIG_IsOK(ecode2)) {
25582     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getShape" "', argument " "2"" of type '" "int""'");
25583   }
25584   arg2 = static_cast< int >(val2);
25585   result = (Hex::NewShape *)(arg1)->getShape(arg2);
25586   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 |  0 );
25587   return resultobj;
25588 fail:
25589   return NULL;
25590 }
25591
25592
25593 SWIGINTERN PyObject *_wrap_Document_getGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25594   PyObject *resultobj = 0;
25595   Hex::Document *arg1 = (Hex::Document *) 0 ;
25596   int arg2 ;
25597   void *argp1 = 0 ;
25598   int res1 = 0 ;
25599   int val2 ;
25600   int ecode2 = 0 ;
25601   PyObject * obj0 = 0 ;
25602   PyObject * obj1 = 0 ;
25603   Hex::Group *result = 0 ;
25604
25605   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getGroup",&obj0,&obj1)) SWIG_fail;
25606   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25607   if (!SWIG_IsOK(res1)) {
25608     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getGroup" "', argument " "1"" of type '" "Hex::Document *""'");
25609   }
25610   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25611   ecode2 = SWIG_AsVal_int(obj1, &val2);
25612   if (!SWIG_IsOK(ecode2)) {
25613     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getGroup" "', argument " "2"" of type '" "int""'");
25614   }
25615   arg2 = static_cast< int >(val2);
25616   result = (Hex::Group *)(arg1)->getGroup(arg2);
25617   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
25618   return resultobj;
25619 fail:
25620   return NULL;
25621 }
25622
25623
25624 SWIGINTERN PyObject *_wrap_Document_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25625   PyObject *resultobj = 0;
25626   Hex::Document *arg1 = (Hex::Document *) 0 ;
25627   int arg2 ;
25628   void *argp1 = 0 ;
25629   int res1 = 0 ;
25630   int val2 ;
25631   int ecode2 = 0 ;
25632   PyObject * obj0 = 0 ;
25633   PyObject * obj1 = 0 ;
25634   Hex::Law *result = 0 ;
25635
25636   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getLaw",&obj0,&obj1)) SWIG_fail;
25637   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25638   if (!SWIG_IsOK(res1)) {
25639     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getLaw" "', argument " "1"" of type '" "Hex::Document *""'");
25640   }
25641   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25642   ecode2 = SWIG_AsVal_int(obj1, &val2);
25643   if (!SWIG_IsOK(ecode2)) {
25644     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getLaw" "', argument " "2"" of type '" "int""'");
25645   }
25646   arg2 = static_cast< int >(val2);
25647   result = (Hex::Law *)(arg1)->getLaw(arg2);
25648   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
25649   return resultobj;
25650 fail:
25651   return NULL;
25652 }
25653
25654
25655 SWIGINTERN PyObject *_wrap_Document_getPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25656   PyObject *resultobj = 0;
25657   Hex::Document *arg1 = (Hex::Document *) 0 ;
25658   int arg2 ;
25659   void *argp1 = 0 ;
25660   int res1 = 0 ;
25661   int val2 ;
25662   int ecode2 = 0 ;
25663   PyObject * obj0 = 0 ;
25664   PyObject * obj1 = 0 ;
25665   Hex::Propagation *result = 0 ;
25666
25667   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getPropagation",&obj0,&obj1)) SWIG_fail;
25668   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25669   if (!SWIG_IsOK(res1)) {
25670     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
25671   }
25672   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25673   ecode2 = SWIG_AsVal_int(obj1, &val2);
25674   if (!SWIG_IsOK(ecode2)) {
25675     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getPropagation" "', argument " "2"" of type '" "int""'");
25676   }
25677   arg2 = static_cast< int >(val2);
25678   result = (Hex::Propagation *)(arg1)->getPropagation(arg2);
25679   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, 0 |  0 );
25680   return resultobj;
25681 fail:
25682   return NULL;
25683 }
25684
25685
25686 SWIGINTERN PyObject *_wrap_Document_getFirstExplicitShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25687   PyObject *resultobj = 0;
25688   Hex::Document *arg1 = (Hex::Document *) 0 ;
25689   void *argp1 = 0 ;
25690   int res1 = 0 ;
25691   PyObject * obj0 = 0 ;
25692   cpchar result;
25693
25694   if (!PyArg_ParseTuple(args,(char *)"O:Document_getFirstExplicitShape",&obj0)) SWIG_fail;
25695   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25696   if (!SWIG_IsOK(res1)) {
25697     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getFirstExplicitShape" "', argument " "1"" of type '" "Hex::Document *""'");
25698   }
25699   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25700   result = (cpchar)(arg1)->getFirstExplicitShape();
25701   resultobj = SWIG_FromCharPtr((const char *)result);
25702   return resultobj;
25703 fail:
25704   return NULL;
25705 }
25706
25707
25708 SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25709   PyObject *resultobj = 0;
25710   Hex::Document *arg1 = (Hex::Document *) 0 ;
25711   double arg2 ;
25712   double arg3 ;
25713   double arg4 ;
25714   void *argp1 = 0 ;
25715   int res1 = 0 ;
25716   double val2 ;
25717   int ecode2 = 0 ;
25718   double val3 ;
25719   int ecode3 = 0 ;
25720   double val4 ;
25721   int ecode4 = 0 ;
25722   PyObject * obj0 = 0 ;
25723   PyObject * obj1 = 0 ;
25724   PyObject * obj2 = 0 ;
25725   PyObject * obj3 = 0 ;
25726   Hex::Vertex *result = 0 ;
25727
25728   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_findVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25729   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25730   if (!SWIG_IsOK(res1)) {
25731     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
25732   }
25733   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25734   ecode2 = SWIG_AsVal_double(obj1, &val2);
25735   if (!SWIG_IsOK(ecode2)) {
25736     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "double""'");
25737   }
25738   arg2 = static_cast< double >(val2);
25739   ecode3 = SWIG_AsVal_double(obj2, &val3);
25740   if (!SWIG_IsOK(ecode3)) {
25741     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_findVertex" "', argument " "3"" of type '" "double""'");
25742   }
25743   arg3 = static_cast< double >(val3);
25744   ecode4 = SWIG_AsVal_double(obj3, &val4);
25745   if (!SWIG_IsOK(ecode4)) {
25746     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_findVertex" "', argument " "4"" of type '" "double""'");
25747   }
25748   arg4 = static_cast< double >(val4);
25749   result = (Hex::Vertex *)(arg1)->findVertex(arg2,arg3,arg4);
25750   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25751   return resultobj;
25752 fail:
25753   return NULL;
25754 }
25755
25756
25757 SWIGINTERN PyObject *_wrap_Document_findEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25758   PyObject *resultobj = 0;
25759   Hex::Document *arg1 = (Hex::Document *) 0 ;
25760   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25761   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
25762   void *argp1 = 0 ;
25763   int res1 = 0 ;
25764   void *argp2 = 0 ;
25765   int res2 = 0 ;
25766   void *argp3 = 0 ;
25767   int res3 = 0 ;
25768   PyObject * obj0 = 0 ;
25769   PyObject * obj1 = 0 ;
25770   PyObject * obj2 = 0 ;
25771   Hex::Edge *result = 0 ;
25772
25773   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findEdge",&obj0,&obj1,&obj2)) SWIG_fail;
25774   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25775   if (!SWIG_IsOK(res1)) {
25776     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findEdge" "', argument " "1"" of type '" "Hex::Document *""'");
25777   }
25778   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25779   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25780   if (!SWIG_IsOK(res2)) {
25781     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findEdge" "', argument " "2"" of type '" "Hex::Vertex *""'");
25782   }
25783   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25784   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25785   if (!SWIG_IsOK(res3)) {
25786     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findEdge" "', argument " "3"" of type '" "Hex::Vertex *""'");
25787   }
25788   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
25789   result = (Hex::Edge *)(arg1)->findEdge(arg2,arg3);
25790   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
25791   return resultobj;
25792 fail:
25793   return NULL;
25794 }
25795
25796
25797 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25798   PyObject *resultobj = 0;
25799   Hex::Document *arg1 = (Hex::Document *) 0 ;
25800   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25801   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
25802   void *argp1 = 0 ;
25803   int res1 = 0 ;
25804   void *argp2 = 0 ;
25805   int res2 = 0 ;
25806   void *argp3 = 0 ;
25807   int res3 = 0 ;
25808   PyObject * obj0 = 0 ;
25809   PyObject * obj1 = 0 ;
25810   PyObject * obj2 = 0 ;
25811   Hex::Quad *result = 0 ;
25812
25813   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
25814   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25815   if (!SWIG_IsOK(res1)) {
25816     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
25817   }
25818   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25819   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25820   if (!SWIG_IsOK(res2)) {
25821     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Vertex *""'");
25822   }
25823   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25824   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25825   if (!SWIG_IsOK(res3)) {
25826     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
25827   }
25828   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
25829   result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
25830   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
25831   return resultobj;
25832 fail:
25833   return NULL;
25834 }
25835
25836
25837 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25838   PyObject *resultobj = 0;
25839   Hex::Document *arg1 = (Hex::Document *) 0 ;
25840   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
25841   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
25842   void *argp1 = 0 ;
25843   int res1 = 0 ;
25844   void *argp2 = 0 ;
25845   int res2 = 0 ;
25846   void *argp3 = 0 ;
25847   int res3 = 0 ;
25848   PyObject * obj0 = 0 ;
25849   PyObject * obj1 = 0 ;
25850   PyObject * obj2 = 0 ;
25851   Hex::Quad *result = 0 ;
25852
25853   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
25854   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25855   if (!SWIG_IsOK(res1)) {
25856     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
25857   }
25858   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25859   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
25860   if (!SWIG_IsOK(res2)) {
25861     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Edge *""'");
25862   }
25863   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
25864   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
25865   if (!SWIG_IsOK(res3)) {
25866     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Edge *""'");
25867   }
25868   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
25869   result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
25870   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
25871   return resultobj;
25872 fail:
25873   return NULL;
25874 }
25875
25876
25877 SWIGINTERN PyObject *_wrap_Document_findQuad(PyObject *self, PyObject *args) {
25878   int argc;
25879   PyObject *argv[4];
25880   int ii;
25881
25882   if (!PyTuple_Check(args)) SWIG_fail;
25883   argc = (int)PyObject_Length(args);
25884   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
25885     argv[ii] = PyTuple_GET_ITEM(args,ii);
25886   }
25887   if (argc == 3) {
25888     int _v;
25889     void *vptr = 0;
25890     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25891     _v = SWIG_CheckState(res);
25892     if (_v) {
25893       void *vptr = 0;
25894       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
25895       _v = SWIG_CheckState(res);
25896       if (_v) {
25897         void *vptr = 0;
25898         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
25899         _v = SWIG_CheckState(res);
25900         if (_v) {
25901           return _wrap_Document_findQuad__SWIG_0(self, args);
25902         }
25903       }
25904     }
25905   }
25906   if (argc == 3) {
25907     int _v;
25908     void *vptr = 0;
25909     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25910     _v = SWIG_CheckState(res);
25911     if (_v) {
25912       void *vptr = 0;
25913       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Edge, 0);
25914       _v = SWIG_CheckState(res);
25915       if (_v) {
25916         void *vptr = 0;
25917         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
25918         _v = SWIG_CheckState(res);
25919         if (_v) {
25920           return _wrap_Document_findQuad__SWIG_1(self, args);
25921         }
25922       }
25923     }
25924   }
25925
25926 fail:
25927   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_findQuad'.\n"
25928     "  Possible C/C++ prototypes are:\n"
25929     "    findQuad(Hex::Document *,Hex::Vertex *,Hex::Vertex *)\n"
25930     "    findQuad(Hex::Document *,Hex::Edge *,Hex::Edge *)\n");
25931   return NULL;
25932 }
25933
25934
25935 SWIGINTERN PyObject *_wrap_Document_findHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25936   PyObject *resultobj = 0;
25937   Hex::Document *arg1 = (Hex::Document *) 0 ;
25938   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25939   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
25940   void *argp1 = 0 ;
25941   int res1 = 0 ;
25942   void *argp2 = 0 ;
25943   int res2 = 0 ;
25944   void *argp3 = 0 ;
25945   int res3 = 0 ;
25946   PyObject * obj0 = 0 ;
25947   PyObject * obj1 = 0 ;
25948   PyObject * obj2 = 0 ;
25949   Hex::Hexa *result = 0 ;
25950
25951   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findHexa",&obj0,&obj1,&obj2)) SWIG_fail;
25952   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25953   if (!SWIG_IsOK(res1)) {
25954     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25955   }
25956   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25957   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25958   if (!SWIG_IsOK(res2)) {
25959     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findHexa" "', argument " "2"" of type '" "Hex::Vertex *""'");
25960   }
25961   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25962   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25963   if (!SWIG_IsOK(res3)) {
25964     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findHexa" "', argument " "3"" of type '" "Hex::Vertex *""'");
25965   }
25966   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
25967   result = (Hex::Hexa *)(arg1)->findHexa(arg2,arg3);
25968   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25969   return resultobj;
25970 fail:
25971   return NULL;
25972 }
25973
25974
25975 SWIGINTERN PyObject *_wrap_Document_findGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25976   PyObject *resultobj = 0;
25977   Hex::Document *arg1 = (Hex::Document *) 0 ;
25978   cpchar arg2 = (cpchar) 0 ;
25979   void *argp1 = 0 ;
25980   int res1 = 0 ;
25981   int res2 ;
25982   char *buf2 = 0 ;
25983   int alloc2 = 0 ;
25984   PyObject * obj0 = 0 ;
25985   PyObject * obj1 = 0 ;
25986   Hex::Group *result = 0 ;
25987
25988   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findGroup",&obj0,&obj1)) SWIG_fail;
25989   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25990   if (!SWIG_IsOK(res1)) {
25991     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findGroup" "', argument " "1"" of type '" "Hex::Document *""'");
25992   }
25993   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25994   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25995   if (!SWIG_IsOK(res2)) {
25996     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findGroup" "', argument " "2"" of type '" "cpchar""'");
25997   }
25998   arg2 = reinterpret_cast< cpchar >(buf2);
25999   result = (Hex::Group *)(arg1)->findGroup(arg2);
26000   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
26001   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26002   return resultobj;
26003 fail:
26004   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26005   return NULL;
26006 }
26007
26008
26009 SWIGINTERN PyObject *_wrap_Document_findLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26010   PyObject *resultobj = 0;
26011   Hex::Document *arg1 = (Hex::Document *) 0 ;
26012   cpchar arg2 = (cpchar) 0 ;
26013   void *argp1 = 0 ;
26014   int res1 = 0 ;
26015   int res2 ;
26016   char *buf2 = 0 ;
26017   int alloc2 = 0 ;
26018   PyObject * obj0 = 0 ;
26019   PyObject * obj1 = 0 ;
26020   Hex::Law *result = 0 ;
26021
26022   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findLaw",&obj0,&obj1)) SWIG_fail;
26023   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26024   if (!SWIG_IsOK(res1)) {
26025     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findLaw" "', argument " "1"" of type '" "Hex::Document *""'");
26026   }
26027   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26028   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26029   if (!SWIG_IsOK(res2)) {
26030     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findLaw" "', argument " "2"" of type '" "cpchar""'");
26031   }
26032   arg2 = reinterpret_cast< cpchar >(buf2);
26033   result = (Hex::Law *)(arg1)->findLaw(arg2);
26034   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
26035   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26036   return resultobj;
26037 fail:
26038   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26039   return NULL;
26040 }
26041
26042
26043 SWIGINTERN PyObject *_wrap_Document_findPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26044   PyObject *resultobj = 0;
26045   Hex::Document *arg1 = (Hex::Document *) 0 ;
26046   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
26047   void *argp1 = 0 ;
26048   int res1 = 0 ;
26049   void *argp2 = 0 ;
26050   int res2 = 0 ;
26051   PyObject * obj0 = 0 ;
26052   PyObject * obj1 = 0 ;
26053   Hex::Propagation *result = 0 ;
26054
26055   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findPropagation",&obj0,&obj1)) SWIG_fail;
26056   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26057   if (!SWIG_IsOK(res1)) {
26058     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
26059   }
26060   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26061   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
26062   if (!SWIG_IsOK(res2)) {
26063     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findPropagation" "', argument " "2"" of type '" "Hex::Edge *""'");
26064   }
26065   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
26066   result = (Hex::Propagation *)(arg1)->findPropagation(arg2);
26067   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, 0 |  0 );
26068   return resultobj;
26069 fail:
26070   return NULL;
26071 }
26072
26073
26074 SWIGINTERN PyObject *_wrap_Document_removeHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26075   PyObject *resultobj = 0;
26076   Hex::Document *arg1 = (Hex::Document *) 0 ;
26077   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
26078   void *argp1 = 0 ;
26079   int res1 = 0 ;
26080   void *argp2 = 0 ;
26081   int res2 = 0 ;
26082   PyObject * obj0 = 0 ;
26083   PyObject * obj1 = 0 ;
26084   int result;
26085
26086   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeHexa",&obj0,&obj1)) SWIG_fail;
26087   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26088   if (!SWIG_IsOK(res1)) {
26089     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeHexa" "', argument " "1"" of type '" "Hex::Document *""'");
26090   }
26091   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26092   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
26093   if (!SWIG_IsOK(res2)) {
26094     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
26095   }
26096   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
26097   result = (int)(arg1)->removeHexa(arg2);
26098   resultobj = SWIG_From_int(static_cast< int >(result));
26099   return resultobj;
26100 fail:
26101   return NULL;
26102 }
26103
26104
26105 SWIGINTERN PyObject *_wrap_Document_removeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26106   PyObject *resultobj = 0;
26107   Hex::Document *arg1 = (Hex::Document *) 0 ;
26108   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
26109   void *argp1 = 0 ;
26110   int res1 = 0 ;
26111   void *argp2 = 0 ;
26112   int res2 = 0 ;
26113   PyObject * obj0 = 0 ;
26114   PyObject * obj1 = 0 ;
26115   int result;
26116
26117   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeQuad",&obj0,&obj1)) SWIG_fail;
26118   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26119   if (!SWIG_IsOK(res1)) {
26120     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
26121   }
26122   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26123   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
26124   if (!SWIG_IsOK(res2)) {
26125     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
26126   }
26127   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
26128   result = (int)(arg1)->removeQuad(arg2);
26129   resultobj = SWIG_From_int(static_cast< int >(result));
26130   return resultobj;
26131 fail:
26132   return NULL;
26133 }
26134
26135
26136 SWIGINTERN PyObject *_wrap_Document_removeConnectedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26137   PyObject *resultobj = 0;
26138   Hex::Document *arg1 = (Hex::Document *) 0 ;
26139   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
26140   void *argp1 = 0 ;
26141   int res1 = 0 ;
26142   void *argp2 = 0 ;
26143   int res2 = 0 ;
26144   PyObject * obj0 = 0 ;
26145   PyObject * obj1 = 0 ;
26146   int result;
26147
26148   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeConnectedHexa",&obj0,&obj1)) SWIG_fail;
26149   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26150   if (!SWIG_IsOK(res1)) {
26151     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeConnectedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
26152   }
26153   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26154   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
26155   if (!SWIG_IsOK(res2)) {
26156     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeConnectedHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
26157   }
26158   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
26159   result = (int)(arg1)->removeConnectedHexa(arg2);
26160   resultobj = SWIG_From_int(static_cast< int >(result));
26161   return resultobj;
26162 fail:
26163   return NULL;
26164 }
26165
26166
26167 SWIGINTERN PyObject *_wrap_Document_removeElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26168   PyObject *resultobj = 0;
26169   Hex::Document *arg1 = (Hex::Document *) 0 ;
26170   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26171   void *argp1 = 0 ;
26172   int res1 = 0 ;
26173   void *argp2 = 0 ;
26174   int res2 = 0 ;
26175   PyObject * obj0 = 0 ;
26176   PyObject * obj1 = 0 ;
26177   int result;
26178
26179   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeElements",&obj0,&obj1)) SWIG_fail;
26180   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26181   if (!SWIG_IsOK(res1)) {
26182     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeElements" "', argument " "1"" of type '" "Hex::Document *""'");
26183   }
26184   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26185   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26186   if (!SWIG_IsOK(res2)) {
26187     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeElements" "', argument " "2"" of type '" "Hex::Elements *""'");
26188   }
26189   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26190   result = (int)(arg1)->removeElements(arg2);
26191   resultobj = SWIG_From_int(static_cast< int >(result));
26192   return resultobj;
26193 fail:
26194   return NULL;
26195 }
26196
26197
26198 SWIGINTERN PyObject *_wrap_Document_removeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26199   PyObject *resultobj = 0;
26200   Hex::Document *arg1 = (Hex::Document *) 0 ;
26201   Hex::Group *arg2 = (Hex::Group *) 0 ;
26202   void *argp1 = 0 ;
26203   int res1 = 0 ;
26204   void *argp2 = 0 ;
26205   int res2 = 0 ;
26206   PyObject * obj0 = 0 ;
26207   PyObject * obj1 = 0 ;
26208   int result;
26209
26210   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeGroup",&obj0,&obj1)) SWIG_fail;
26211   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26212   if (!SWIG_IsOK(res1)) {
26213     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
26214   }
26215   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26216   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Group, 0 |  0 );
26217   if (!SWIG_IsOK(res2)) {
26218     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeGroup" "', argument " "2"" of type '" "Hex::Group *""'");
26219   }
26220   arg2 = reinterpret_cast< Hex::Group * >(argp2);
26221   result = (int)(arg1)->removeGroup(arg2);
26222   resultobj = SWIG_From_int(static_cast< int >(result));
26223   return resultobj;
26224 fail:
26225   return NULL;
26226 }
26227
26228
26229 SWIGINTERN PyObject *_wrap_Document_removeLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26230   PyObject *resultobj = 0;
26231   Hex::Document *arg1 = (Hex::Document *) 0 ;
26232   Hex::Law *arg2 = (Hex::Law *) 0 ;
26233   void *argp1 = 0 ;
26234   int res1 = 0 ;
26235   void *argp2 = 0 ;
26236   int res2 = 0 ;
26237   PyObject * obj0 = 0 ;
26238   PyObject * obj1 = 0 ;
26239   int result;
26240
26241   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeLaw",&obj0,&obj1)) SWIG_fail;
26242   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26243   if (!SWIG_IsOK(res1)) {
26244     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeLaw" "', argument " "1"" of type '" "Hex::Document *""'");
26245   }
26246   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26247   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
26248   if (!SWIG_IsOK(res2)) {
26249     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeLaw" "', argument " "2"" of type '" "Hex::Law *""'");
26250   }
26251   arg2 = reinterpret_cast< Hex::Law * >(argp2);
26252   result = (int)(arg1)->removeLaw(arg2);
26253   resultobj = SWIG_From_int(static_cast< int >(result));
26254   return resultobj;
26255 fail:
26256   return NULL;
26257 }
26258
26259
26260 SWIGINTERN PyObject *_wrap_Document_makeCartesianTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26261   PyObject *resultobj = 0;
26262   Hex::Document *arg1 = (Hex::Document *) 0 ;
26263   int arg2 ;
26264   int arg3 ;
26265   int arg4 ;
26266   void *argp1 = 0 ;
26267   int res1 = 0 ;
26268   int val2 ;
26269   int ecode2 = 0 ;
26270   int val3 ;
26271   int ecode3 = 0 ;
26272   int val4 ;
26273   int ecode4 = 0 ;
26274   PyObject * obj0 = 0 ;
26275   PyObject * obj1 = 0 ;
26276   PyObject * obj2 = 0 ;
26277   PyObject * obj3 = 0 ;
26278   Hex::Elements *result = 0 ;
26279
26280   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCartesianTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26281   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26282   if (!SWIG_IsOK(res1)) {
26283     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianTop" "', argument " "1"" of type '" "Hex::Document *""'");
26284   }
26285   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26286   ecode2 = SWIG_AsVal_int(obj1, &val2);
26287   if (!SWIG_IsOK(ecode2)) {
26288     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCartesianTop" "', argument " "2"" of type '" "int""'");
26289   }
26290   arg2 = static_cast< int >(val2);
26291   ecode3 = SWIG_AsVal_int(obj2, &val3);
26292   if (!SWIG_IsOK(ecode3)) {
26293     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCartesianTop" "', argument " "3"" of type '" "int""'");
26294   }
26295   arg3 = static_cast< int >(val3);
26296   ecode4 = SWIG_AsVal_int(obj3, &val4);
26297   if (!SWIG_IsOK(ecode4)) {
26298     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCartesianTop" "', argument " "4"" of type '" "int""'");
26299   }
26300   arg4 = static_cast< int >(val4);
26301   result = (Hex::Elements *)(arg1)->makeCartesianTop(arg2,arg3,arg4);
26302   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26303   return resultobj;
26304 fail:
26305   return NULL;
26306 }
26307
26308
26309 SWIGINTERN PyObject *_wrap_Document_makeCartesianUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26310   PyObject *resultobj = 0;
26311   Hex::Document *arg1 = (Hex::Document *) 0 ;
26312   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26313   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26314   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26315   Hex::Vector *arg5 = (Hex::Vector *) 0 ;
26316   double arg6 ;
26317   double arg7 ;
26318   double arg8 ;
26319   int arg9 ;
26320   int arg10 ;
26321   int arg11 ;
26322   void *argp1 = 0 ;
26323   int res1 = 0 ;
26324   void *argp2 = 0 ;
26325   int res2 = 0 ;
26326   void *argp3 = 0 ;
26327   int res3 = 0 ;
26328   void *argp4 = 0 ;
26329   int res4 = 0 ;
26330   void *argp5 = 0 ;
26331   int res5 = 0 ;
26332   double val6 ;
26333   int ecode6 = 0 ;
26334   double val7 ;
26335   int ecode7 = 0 ;
26336   double val8 ;
26337   int ecode8 = 0 ;
26338   int val9 ;
26339   int ecode9 = 0 ;
26340   int val10 ;
26341   int ecode10 = 0 ;
26342   int val11 ;
26343   int ecode11 = 0 ;
26344   PyObject * obj0 = 0 ;
26345   PyObject * obj1 = 0 ;
26346   PyObject * obj2 = 0 ;
26347   PyObject * obj3 = 0 ;
26348   PyObject * obj4 = 0 ;
26349   PyObject * obj5 = 0 ;
26350   PyObject * obj6 = 0 ;
26351   PyObject * obj7 = 0 ;
26352   PyObject * obj8 = 0 ;
26353   PyObject * obj9 = 0 ;
26354   PyObject * obj10 = 0 ;
26355   Hex::Elements *result = 0 ;
26356
26357   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCartesianUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
26358   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26359   if (!SWIG_IsOK(res1)) {
26360     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianUni" "', argument " "1"" of type '" "Hex::Document *""'");
26361   }
26362   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26363   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26364   if (!SWIG_IsOK(res2)) {
26365     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesianUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26366   }
26367   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26368   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26369   if (!SWIG_IsOK(res3)) {
26370     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesianUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26371   }
26372   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26373   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26374   if (!SWIG_IsOK(res4)) {
26375     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesianUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26376   }
26377   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26378   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26379   if (!SWIG_IsOK(res5)) {
26380     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesianUni" "', argument " "5"" of type '" "Hex::Vector *""'");
26381   }
26382   arg5 = reinterpret_cast< Hex::Vector * >(argp5);
26383   ecode6 = SWIG_AsVal_double(obj5, &val6);
26384   if (!SWIG_IsOK(ecode6)) {
26385     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCartesianUni" "', argument " "6"" of type '" "double""'");
26386   }
26387   arg6 = static_cast< double >(val6);
26388   ecode7 = SWIG_AsVal_double(obj6, &val7);
26389   if (!SWIG_IsOK(ecode7)) {
26390     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCartesianUni" "', argument " "7"" of type '" "double""'");
26391   }
26392   arg7 = static_cast< double >(val7);
26393   ecode8 = SWIG_AsVal_double(obj7, &val8);
26394   if (!SWIG_IsOK(ecode8)) {
26395     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCartesianUni" "', argument " "8"" of type '" "double""'");
26396   }
26397   arg8 = static_cast< double >(val8);
26398   ecode9 = SWIG_AsVal_int(obj8, &val9);
26399   if (!SWIG_IsOK(ecode9)) {
26400     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCartesianUni" "', argument " "9"" of type '" "int""'");
26401   }
26402   arg9 = static_cast< int >(val9);
26403   ecode10 = SWIG_AsVal_int(obj9, &val10);
26404   if (!SWIG_IsOK(ecode10)) {
26405     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCartesianUni" "', argument " "10"" of type '" "int""'");
26406   }
26407   arg10 = static_cast< int >(val10);
26408   ecode11 = SWIG_AsVal_int(obj10, &val11);
26409   if (!SWIG_IsOK(ecode11)) {
26410     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCartesianUni" "', argument " "11"" of type '" "int""'");
26411   }
26412   arg11 = static_cast< int >(val11);
26413   result = (Hex::Elements *)(arg1)->makeCartesianUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26414   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26415   return resultobj;
26416 fail:
26417   return NULL;
26418 }
26419
26420
26421 SWIGINTERN PyObject *_wrap_Document_makeCartesian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26422   PyObject *resultobj = 0;
26423   Hex::Document *arg1 = (Hex::Document *) 0 ;
26424   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26425   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26426   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26427   Hex::Vector *arg5 = (Hex::Vector *) 0 ;
26428   Hex::RealVector arg6 ;
26429   Hex::RealVector arg7 ;
26430   Hex::RealVector arg8 ;
26431   void *argp1 = 0 ;
26432   int res1 = 0 ;
26433   void *argp2 = 0 ;
26434   int res2 = 0 ;
26435   void *argp3 = 0 ;
26436   int res3 = 0 ;
26437   void *argp4 = 0 ;
26438   int res4 = 0 ;
26439   void *argp5 = 0 ;
26440   int res5 = 0 ;
26441   PyObject * obj0 = 0 ;
26442   PyObject * obj1 = 0 ;
26443   PyObject * obj2 = 0 ;
26444   PyObject * obj3 = 0 ;
26445   PyObject * obj4 = 0 ;
26446   PyObject * obj5 = 0 ;
26447   PyObject * obj6 = 0 ;
26448   PyObject * obj7 = 0 ;
26449   Hex::Elements *result = 0 ;
26450
26451   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_makeCartesian",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
26452   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26453   if (!SWIG_IsOK(res1)) {
26454     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesian" "', argument " "1"" of type '" "Hex::Document *""'");
26455   }
26456   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26457   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26458   if (!SWIG_IsOK(res2)) {
26459     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesian" "', argument " "2"" of type '" "Hex::Vertex *""'");
26460   }
26461   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26462   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26463   if (!SWIG_IsOK(res3)) {
26464     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesian" "', argument " "3"" of type '" "Hex::Vector *""'");
26465   }
26466   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26467   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26468   if (!SWIG_IsOK(res4)) {
26469     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesian" "', argument " "4"" of type '" "Hex::Vector *""'");
26470   }
26471   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26472   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26473   if (!SWIG_IsOK(res5)) {
26474     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesian" "', argument " "5"" of type '" "Hex::Vector *""'");
26475   }
26476   arg5 = reinterpret_cast< Hex::Vector * >(argp5);
26477   {
26478     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
26479     int res = swig::asptr(obj5, &ptr);
26480     if (!SWIG_IsOK(res) || !ptr) {
26481       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "6"" of type '" "Hex::RealVector""'");
26482     }
26483     arg6 = *ptr;
26484     if (SWIG_IsNewObj(res)) delete ptr;
26485   }
26486   {
26487     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
26488     int res = swig::asptr(obj6, &ptr);
26489     if (!SWIG_IsOK(res) || !ptr) {
26490       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "7"" of type '" "Hex::RealVector""'");
26491     }
26492     arg7 = *ptr;
26493     if (SWIG_IsNewObj(res)) delete ptr;
26494   }
26495   {
26496     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
26497     int res = swig::asptr(obj7, &ptr);
26498     if (!SWIG_IsOK(res) || !ptr) {
26499       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "8"" of type '" "Hex::RealVector""'");
26500     }
26501     arg8 = *ptr;
26502     if (SWIG_IsNewObj(res)) delete ptr;
26503   }
26504   result = (Hex::Elements *)(arg1)->makeCartesian(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
26505   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26506   return resultobj;
26507 fail:
26508   return NULL;
26509 }
26510
26511
26512 SWIGINTERN PyObject *_wrap_Document_makeCylinderTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26513   PyObject *resultobj = 0;
26514   Hex::Document *arg1 = (Hex::Document *) 0 ;
26515   int arg2 ;
26516   int arg3 ;
26517   int arg4 ;
26518   void *argp1 = 0 ;
26519   int res1 = 0 ;
26520   int val2 ;
26521   int ecode2 = 0 ;
26522   int val3 ;
26523   int ecode3 = 0 ;
26524   int val4 ;
26525   int ecode4 = 0 ;
26526   PyObject * obj0 = 0 ;
26527   PyObject * obj1 = 0 ;
26528   PyObject * obj2 = 0 ;
26529   PyObject * obj3 = 0 ;
26530   Hex::Elements *result = 0 ;
26531
26532   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCylinderTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26533   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26534   if (!SWIG_IsOK(res1)) {
26535     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderTop" "', argument " "1"" of type '" "Hex::Document *""'");
26536   }
26537   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26538   ecode2 = SWIG_AsVal_int(obj1, &val2);
26539   if (!SWIG_IsOK(ecode2)) {
26540     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCylinderTop" "', argument " "2"" of type '" "int""'");
26541   }
26542   arg2 = static_cast< int >(val2);
26543   ecode3 = SWIG_AsVal_int(obj2, &val3);
26544   if (!SWIG_IsOK(ecode3)) {
26545     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCylinderTop" "', argument " "3"" of type '" "int""'");
26546   }
26547   arg3 = static_cast< int >(val3);
26548   ecode4 = SWIG_AsVal_int(obj3, &val4);
26549   if (!SWIG_IsOK(ecode4)) {
26550     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinderTop" "', argument " "4"" of type '" "int""'");
26551   }
26552   arg4 = static_cast< int >(val4);
26553   result = (Hex::Elements *)(arg1)->makeCylinderTop(arg2,arg3,arg4);
26554   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26555   return resultobj;
26556 fail:
26557   return NULL;
26558 }
26559
26560
26561 SWIGINTERN PyObject *_wrap_Document_makeCylinderUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26562   PyObject *resultobj = 0;
26563   Hex::Document *arg1 = (Hex::Document *) 0 ;
26564   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26565   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26566   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26567   double arg5 ;
26568   double arg6 ;
26569   double arg7 ;
26570   double arg8 ;
26571   int arg9 ;
26572   int arg10 ;
26573   int arg11 ;
26574   void *argp1 = 0 ;
26575   int res1 = 0 ;
26576   void *argp2 = 0 ;
26577   int res2 = 0 ;
26578   void *argp3 = 0 ;
26579   int res3 = 0 ;
26580   void *argp4 = 0 ;
26581   int res4 = 0 ;
26582   double val5 ;
26583   int ecode5 = 0 ;
26584   double val6 ;
26585   int ecode6 = 0 ;
26586   double val7 ;
26587   int ecode7 = 0 ;
26588   double val8 ;
26589   int ecode8 = 0 ;
26590   int val9 ;
26591   int ecode9 = 0 ;
26592   int val10 ;
26593   int ecode10 = 0 ;
26594   int val11 ;
26595   int ecode11 = 0 ;
26596   PyObject * obj0 = 0 ;
26597   PyObject * obj1 = 0 ;
26598   PyObject * obj2 = 0 ;
26599   PyObject * obj3 = 0 ;
26600   PyObject * obj4 = 0 ;
26601   PyObject * obj5 = 0 ;
26602   PyObject * obj6 = 0 ;
26603   PyObject * obj7 = 0 ;
26604   PyObject * obj8 = 0 ;
26605   PyObject * obj9 = 0 ;
26606   PyObject * obj10 = 0 ;
26607   Hex::Elements *result = 0 ;
26608
26609   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCylinderUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
26610   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26611   if (!SWIG_IsOK(res1)) {
26612     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderUni" "', argument " "1"" of type '" "Hex::Document *""'");
26613   }
26614   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26615   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26616   if (!SWIG_IsOK(res2)) {
26617     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinderUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26618   }
26619   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26620   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26621   if (!SWIG_IsOK(res3)) {
26622     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinderUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26623   }
26624   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26625   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26626   if (!SWIG_IsOK(res4)) {
26627     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinderUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26628   }
26629   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26630   ecode5 = SWIG_AsVal_double(obj4, &val5);
26631   if (!SWIG_IsOK(ecode5)) {
26632     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinderUni" "', argument " "5"" of type '" "double""'");
26633   }
26634   arg5 = static_cast< double >(val5);
26635   ecode6 = SWIG_AsVal_double(obj5, &val6);
26636   if (!SWIG_IsOK(ecode6)) {
26637     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCylinderUni" "', argument " "6"" of type '" "double""'");
26638   }
26639   arg6 = static_cast< double >(val6);
26640   ecode7 = SWIG_AsVal_double(obj6, &val7);
26641   if (!SWIG_IsOK(ecode7)) {
26642     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCylinderUni" "', argument " "7"" of type '" "double""'");
26643   }
26644   arg7 = static_cast< double >(val7);
26645   ecode8 = SWIG_AsVal_double(obj7, &val8);
26646   if (!SWIG_IsOK(ecode8)) {
26647     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinderUni" "', argument " "8"" of type '" "double""'");
26648   }
26649   arg8 = static_cast< double >(val8);
26650   ecode9 = SWIG_AsVal_int(obj8, &val9);
26651   if (!SWIG_IsOK(ecode9)) {
26652     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinderUni" "', argument " "9"" of type '" "int""'");
26653   }
26654   arg9 = static_cast< int >(val9);
26655   ecode10 = SWIG_AsVal_int(obj9, &val10);
26656   if (!SWIG_IsOK(ecode10)) {
26657     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCylinderUni" "', argument " "10"" of type '" "int""'");
26658   }
26659   arg10 = static_cast< int >(val10);
26660   ecode11 = SWIG_AsVal_int(obj10, &val11);
26661   if (!SWIG_IsOK(ecode11)) {
26662     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCylinderUni" "', argument " "11"" of type '" "int""'");
26663   }
26664   arg11 = static_cast< int >(val11);
26665   result = (Hex::Elements *)(arg1)->makeCylinderUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26666   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26667   return resultobj;
26668 fail:
26669   return NULL;
26670 }
26671
26672
26673 SWIGINTERN PyObject *_wrap_Document_makeCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26674   PyObject *resultobj = 0;
26675   Hex::Document *arg1 = (Hex::Document *) 0 ;
26676   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26677   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26678   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26679   Hex::RealVector arg5 ;
26680   Hex::RealVector arg6 ;
26681   Hex::RealVector arg7 ;
26682   void *argp1 = 0 ;
26683   int res1 = 0 ;
26684   void *argp2 = 0 ;
26685   int res2 = 0 ;
26686   void *argp3 = 0 ;
26687   int res3 = 0 ;
26688   void *argp4 = 0 ;
26689   int res4 = 0 ;
26690   PyObject * obj0 = 0 ;
26691   PyObject * obj1 = 0 ;
26692   PyObject * obj2 = 0 ;
26693   PyObject * obj3 = 0 ;
26694   PyObject * obj4 = 0 ;
26695   PyObject * obj5 = 0 ;
26696   PyObject * obj6 = 0 ;
26697   Hex::Elements *result = 0 ;
26698
26699   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeCylinder",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26700   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26701   if (!SWIG_IsOK(res1)) {
26702     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
26703   }
26704   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26705   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26706   if (!SWIG_IsOK(res2)) {
26707     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinder" "', argument " "2"" of type '" "Hex::Vertex *""'");
26708   }
26709   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26710   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26711   if (!SWIG_IsOK(res3)) {
26712     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinder" "', argument " "3"" of type '" "Hex::Vector *""'");
26713   }
26714   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26715   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26716   if (!SWIG_IsOK(res4)) {
26717     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinder" "', argument " "4"" of type '" "Hex::Vector *""'");
26718   }
26719   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26720   {
26721     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
26722     int res = swig::asptr(obj4, &ptr);
26723     if (!SWIG_IsOK(res) || !ptr) {
26724       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "5"" of type '" "Hex::RealVector""'");
26725     }
26726     arg5 = *ptr;
26727     if (SWIG_IsNewObj(res)) delete ptr;
26728   }
26729   {
26730     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
26731     int res = swig::asptr(obj5, &ptr);
26732     if (!SWIG_IsOK(res) || !ptr) {
26733       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "6"" of type '" "Hex::RealVector""'");
26734     }
26735     arg6 = *ptr;
26736     if (SWIG_IsNewObj(res)) delete ptr;
26737   }
26738   {
26739     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
26740     int res = swig::asptr(obj6, &ptr);
26741     if (!SWIG_IsOK(res) || !ptr) {
26742       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "7"" of type '" "Hex::RealVector""'");
26743     }
26744     arg7 = *ptr;
26745     if (SWIG_IsNewObj(res)) delete ptr;
26746   }
26747   result = (Hex::Elements *)(arg1)->makeCylinder(arg2,arg3,arg4,arg5,arg6,arg7);
26748   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26749   return resultobj;
26750 fail:
26751   return NULL;
26752 }
26753
26754
26755 SWIGINTERN PyObject *_wrap_Document_makePipeTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26756   PyObject *resultobj = 0;
26757   Hex::Document *arg1 = (Hex::Document *) 0 ;
26758   int arg2 ;
26759   int arg3 ;
26760   int arg4 ;
26761   void *argp1 = 0 ;
26762   int res1 = 0 ;
26763   int val2 ;
26764   int ecode2 = 0 ;
26765   int val3 ;
26766   int ecode3 = 0 ;
26767   int val4 ;
26768   int ecode4 = 0 ;
26769   PyObject * obj0 = 0 ;
26770   PyObject * obj1 = 0 ;
26771   PyObject * obj2 = 0 ;
26772   PyObject * obj3 = 0 ;
26773   Hex::Elements *result = 0 ;
26774
26775   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makePipeTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26776   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26777   if (!SWIG_IsOK(res1)) {
26778     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeTop" "', argument " "1"" of type '" "Hex::Document *""'");
26779   }
26780   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26781   ecode2 = SWIG_AsVal_int(obj1, &val2);
26782   if (!SWIG_IsOK(ecode2)) {
26783     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makePipeTop" "', argument " "2"" of type '" "int""'");
26784   }
26785   arg2 = static_cast< int >(val2);
26786   ecode3 = SWIG_AsVal_int(obj2, &val3);
26787   if (!SWIG_IsOK(ecode3)) {
26788     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makePipeTop" "', argument " "3"" of type '" "int""'");
26789   }
26790   arg3 = static_cast< int >(val3);
26791   ecode4 = SWIG_AsVal_int(obj3, &val4);
26792   if (!SWIG_IsOK(ecode4)) {
26793     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipeTop" "', argument " "4"" of type '" "int""'");
26794   }
26795   arg4 = static_cast< int >(val4);
26796   result = (Hex::Elements *)(arg1)->makePipeTop(arg2,arg3,arg4);
26797   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26798   return resultobj;
26799 fail:
26800   return NULL;
26801 }
26802
26803
26804 SWIGINTERN PyObject *_wrap_Document_makePipeUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26805   PyObject *resultobj = 0;
26806   Hex::Document *arg1 = (Hex::Document *) 0 ;
26807   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26808   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26809   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26810   double arg5 ;
26811   double arg6 ;
26812   double arg7 ;
26813   double arg8 ;
26814   int arg9 ;
26815   int arg10 ;
26816   int arg11 ;
26817   void *argp1 = 0 ;
26818   int res1 = 0 ;
26819   void *argp2 = 0 ;
26820   int res2 = 0 ;
26821   void *argp3 = 0 ;
26822   int res3 = 0 ;
26823   void *argp4 = 0 ;
26824   int res4 = 0 ;
26825   double val5 ;
26826   int ecode5 = 0 ;
26827   double val6 ;
26828   int ecode6 = 0 ;
26829   double val7 ;
26830   int ecode7 = 0 ;
26831   double val8 ;
26832   int ecode8 = 0 ;
26833   int val9 ;
26834   int ecode9 = 0 ;
26835   int val10 ;
26836   int ecode10 = 0 ;
26837   int val11 ;
26838   int ecode11 = 0 ;
26839   PyObject * obj0 = 0 ;
26840   PyObject * obj1 = 0 ;
26841   PyObject * obj2 = 0 ;
26842   PyObject * obj3 = 0 ;
26843   PyObject * obj4 = 0 ;
26844   PyObject * obj5 = 0 ;
26845   PyObject * obj6 = 0 ;
26846   PyObject * obj7 = 0 ;
26847   PyObject * obj8 = 0 ;
26848   PyObject * obj9 = 0 ;
26849   PyObject * obj10 = 0 ;
26850   Hex::Elements *result = 0 ;
26851
26852   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipeUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
26853   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26854   if (!SWIG_IsOK(res1)) {
26855     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeUni" "', argument " "1"" of type '" "Hex::Document *""'");
26856   }
26857   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26858   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26859   if (!SWIG_IsOK(res2)) {
26860     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipeUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26861   }
26862   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26863   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26864   if (!SWIG_IsOK(res3)) {
26865     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipeUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26866   }
26867   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26868   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26869   if (!SWIG_IsOK(res4)) {
26870     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipeUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26871   }
26872   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26873   ecode5 = SWIG_AsVal_double(obj4, &val5);
26874   if (!SWIG_IsOK(ecode5)) {
26875     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipeUni" "', argument " "5"" of type '" "double""'");
26876   }
26877   arg5 = static_cast< double >(val5);
26878   ecode6 = SWIG_AsVal_double(obj5, &val6);
26879   if (!SWIG_IsOK(ecode6)) {
26880     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipeUni" "', argument " "6"" of type '" "double""'");
26881   }
26882   arg6 = static_cast< double >(val6);
26883   ecode7 = SWIG_AsVal_double(obj6, &val7);
26884   if (!SWIG_IsOK(ecode7)) {
26885     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makePipeUni" "', argument " "7"" of type '" "double""'");
26886   }
26887   arg7 = static_cast< double >(val7);
26888   ecode8 = SWIG_AsVal_double(obj7, &val8);
26889   if (!SWIG_IsOK(ecode8)) {
26890     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makePipeUni" "', argument " "8"" of type '" "double""'");
26891   }
26892   arg8 = static_cast< double >(val8);
26893   ecode9 = SWIG_AsVal_int(obj8, &val9);
26894   if (!SWIG_IsOK(ecode9)) {
26895     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipeUni" "', argument " "9"" of type '" "int""'");
26896   }
26897   arg9 = static_cast< int >(val9);
26898   ecode10 = SWIG_AsVal_int(obj9, &val10);
26899   if (!SWIG_IsOK(ecode10)) {
26900     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipeUni" "', argument " "10"" of type '" "int""'");
26901   }
26902   arg10 = static_cast< int >(val10);
26903   ecode11 = SWIG_AsVal_int(obj10, &val11);
26904   if (!SWIG_IsOK(ecode11)) {
26905     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipeUni" "', argument " "11"" of type '" "int""'");
26906   }
26907   arg11 = static_cast< int >(val11);
26908   result = (Hex::Elements *)(arg1)->makePipeUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26909   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26910   return resultobj;
26911 fail:
26912   return NULL;
26913 }
26914
26915
26916 SWIGINTERN PyObject *_wrap_Document_makePipe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26917   PyObject *resultobj = 0;
26918   Hex::Document *arg1 = (Hex::Document *) 0 ;
26919   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26920   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26921   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26922   Hex::RealVector arg5 ;
26923   Hex::RealVector arg6 ;
26924   Hex::RealVector arg7 ;
26925   void *argp1 = 0 ;
26926   int res1 = 0 ;
26927   void *argp2 = 0 ;
26928   int res2 = 0 ;
26929   void *argp3 = 0 ;
26930   int res3 = 0 ;
26931   void *argp4 = 0 ;
26932   int res4 = 0 ;
26933   PyObject * obj0 = 0 ;
26934   PyObject * obj1 = 0 ;
26935   PyObject * obj2 = 0 ;
26936   PyObject * obj3 = 0 ;
26937   PyObject * obj4 = 0 ;
26938   PyObject * obj5 = 0 ;
26939   PyObject * obj6 = 0 ;
26940   Hex::Elements *result = 0 ;
26941
26942   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makePipe",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26943   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26944   if (!SWIG_IsOK(res1)) {
26945     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipe" "', argument " "1"" of type '" "Hex::Document *""'");
26946   }
26947   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26948   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26949   if (!SWIG_IsOK(res2)) {
26950     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipe" "', argument " "2"" of type '" "Hex::Vertex *""'");
26951   }
26952   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26953   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26954   if (!SWIG_IsOK(res3)) {
26955     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipe" "', argument " "3"" of type '" "Hex::Vector *""'");
26956   }
26957   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26958   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26959   if (!SWIG_IsOK(res4)) {
26960     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipe" "', argument " "4"" of type '" "Hex::Vector *""'");
26961   }
26962   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26963   {
26964     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
26965     int res = swig::asptr(obj4, &ptr);
26966     if (!SWIG_IsOK(res) || !ptr) {
26967       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "5"" of type '" "Hex::RealVector""'");
26968     }
26969     arg5 = *ptr;
26970     if (SWIG_IsNewObj(res)) delete ptr;
26971   }
26972   {
26973     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
26974     int res = swig::asptr(obj5, &ptr);
26975     if (!SWIG_IsOK(res) || !ptr) {
26976       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "6"" of type '" "Hex::RealVector""'");
26977     }
26978     arg6 = *ptr;
26979     if (SWIG_IsNewObj(res)) delete ptr;
26980   }
26981   {
26982     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
26983     int res = swig::asptr(obj6, &ptr);
26984     if (!SWIG_IsOK(res) || !ptr) {
26985       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "7"" of type '" "Hex::RealVector""'");
26986     }
26987     arg7 = *ptr;
26988     if (SWIG_IsNewObj(res)) delete ptr;
26989   }
26990   result = (Hex::Elements *)(arg1)->makePipe(arg2,arg3,arg4,arg5,arg6,arg7);
26991   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26992   return resultobj;
26993 fail:
26994   return NULL;
26995 }
26996
26997
26998 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26999   PyObject *resultobj = 0;
27000   Hex::Document *arg1 = (Hex::Document *) 0 ;
27001   int arg2 ;
27002   int arg3 ;
27003   void *argp1 = 0 ;
27004   int res1 = 0 ;
27005   int val2 ;
27006   int ecode2 = 0 ;
27007   int val3 ;
27008   int ecode3 = 0 ;
27009   PyObject * obj0 = 0 ;
27010   PyObject * obj1 = 0 ;
27011   PyObject * obj2 = 0 ;
27012   Hex::Elements *result = 0 ;
27013
27014   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSphericalTop",&obj0,&obj1,&obj2)) SWIG_fail;
27015   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27016   if (!SWIG_IsOK(res1)) {
27017     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
27018   }
27019   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27020   ecode2 = SWIG_AsVal_int(obj1, &val2);
27021   if (!SWIG_IsOK(ecode2)) {
27022     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
27023   }
27024   arg2 = static_cast< int >(val2);
27025   ecode3 = SWIG_AsVal_int(obj2, &val3);
27026   if (!SWIG_IsOK(ecode3)) {
27027     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphericalTop" "', argument " "3"" of type '" "int""'");
27028   }
27029   arg3 = static_cast< int >(val3);
27030   result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2,arg3);
27031   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27032   return resultobj;
27033 fail:
27034   return NULL;
27035 }
27036
27037
27038 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27039   PyObject *resultobj = 0;
27040   Hex::Document *arg1 = (Hex::Document *) 0 ;
27041   int arg2 ;
27042   void *argp1 = 0 ;
27043   int res1 = 0 ;
27044   int val2 ;
27045   int ecode2 = 0 ;
27046   PyObject * obj0 = 0 ;
27047   PyObject * obj1 = 0 ;
27048   Hex::Elements *result = 0 ;
27049
27050   if (!PyArg_ParseTuple(args,(char *)"OO:Document_makeSphericalTop",&obj0,&obj1)) SWIG_fail;
27051   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27052   if (!SWIG_IsOK(res1)) {
27053     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
27054   }
27055   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27056   ecode2 = SWIG_AsVal_int(obj1, &val2);
27057   if (!SWIG_IsOK(ecode2)) {
27058     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
27059   }
27060   arg2 = static_cast< int >(val2);
27061   result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2);
27062   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27063   return resultobj;
27064 fail:
27065   return NULL;
27066 }
27067
27068
27069 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop(PyObject *self, PyObject *args) {
27070   int argc;
27071   PyObject *argv[4];
27072   int ii;
27073
27074   if (!PyTuple_Check(args)) SWIG_fail;
27075   argc = (int)PyObject_Length(args);
27076   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
27077     argv[ii] = PyTuple_GET_ITEM(args,ii);
27078   }
27079   if (argc == 2) {
27080     int _v;
27081     void *vptr = 0;
27082     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
27083     _v = SWIG_CheckState(res);
27084     if (_v) {
27085       {
27086         int res = SWIG_AsVal_int(argv[1], NULL);
27087         _v = SWIG_CheckState(res);
27088       }
27089       if (_v) {
27090         return _wrap_Document_makeSphericalTop__SWIG_1(self, args);
27091       }
27092     }
27093   }
27094   if (argc == 3) {
27095     int _v;
27096     void *vptr = 0;
27097     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
27098     _v = SWIG_CheckState(res);
27099     if (_v) {
27100       {
27101         int res = SWIG_AsVal_int(argv[1], NULL);
27102         _v = SWIG_CheckState(res);
27103       }
27104       if (_v) {
27105         {
27106           int res = SWIG_AsVal_int(argv[2], NULL);
27107           _v = SWIG_CheckState(res);
27108         }
27109         if (_v) {
27110           return _wrap_Document_makeSphericalTop__SWIG_0(self, args);
27111         }
27112       }
27113     }
27114   }
27115
27116 fail:
27117   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSphericalTop'.\n"
27118     "  Possible C/C++ prototypes are:\n"
27119     "    makeSphericalTop(Hex::Document *,int,int)\n"
27120     "    makeSphericalTop(Hex::Document *,int)\n");
27121   return NULL;
27122 }
27123
27124
27125 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27126   PyObject *resultobj = 0;
27127   Hex::Document *arg1 = (Hex::Document *) 0 ;
27128   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27129   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27130   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27131   double arg5 ;
27132   int arg6 ;
27133   int arg7 ;
27134   void *argp1 = 0 ;
27135   int res1 = 0 ;
27136   void *argp2 = 0 ;
27137   int res2 = 0 ;
27138   void *argp3 = 0 ;
27139   int res3 = 0 ;
27140   void *argp4 = 0 ;
27141   int res4 = 0 ;
27142   double val5 ;
27143   int ecode5 = 0 ;
27144   int val6 ;
27145   int ecode6 = 0 ;
27146   int val7 ;
27147   int ecode7 = 0 ;
27148   PyObject * obj0 = 0 ;
27149   PyObject * obj1 = 0 ;
27150   PyObject * obj2 = 0 ;
27151   PyObject * obj3 = 0 ;
27152   PyObject * obj4 = 0 ;
27153   PyObject * obj5 = 0 ;
27154   PyObject * obj6 = 0 ;
27155   Hex::Elements *result = 0 ;
27156
27157   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
27158   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27159   if (!SWIG_IsOK(res1)) {
27160     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
27161   }
27162   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27163   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27164   if (!SWIG_IsOK(res2)) {
27165     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
27166   }
27167   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27168   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27169   if (!SWIG_IsOK(res3)) {
27170     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
27171   }
27172   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27173   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27174   if (!SWIG_IsOK(res4)) {
27175     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
27176   }
27177   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27178   ecode5 = SWIG_AsVal_double(obj4, &val5);
27179   if (!SWIG_IsOK(ecode5)) {
27180     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
27181   }
27182   arg5 = static_cast< double >(val5);
27183   ecode6 = SWIG_AsVal_int(obj5, &val6);
27184   if (!SWIG_IsOK(ecode6)) {
27185     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
27186   }
27187   arg6 = static_cast< int >(val6);
27188   ecode7 = SWIG_AsVal_int(obj6, &val7);
27189   if (!SWIG_IsOK(ecode7)) {
27190     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphericalUni" "', argument " "7"" of type '" "int""'");
27191   }
27192   arg7 = static_cast< int >(val7);
27193   result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6,arg7);
27194   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27195   return resultobj;
27196 fail:
27197   return NULL;
27198 }
27199
27200
27201 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27202   PyObject *resultobj = 0;
27203   Hex::Document *arg1 = (Hex::Document *) 0 ;
27204   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27205   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27206   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27207   double arg5 ;
27208   int arg6 ;
27209   void *argp1 = 0 ;
27210   int res1 = 0 ;
27211   void *argp2 = 0 ;
27212   int res2 = 0 ;
27213   void *argp3 = 0 ;
27214   int res3 = 0 ;
27215   void *argp4 = 0 ;
27216   int res4 = 0 ;
27217   double val5 ;
27218   int ecode5 = 0 ;
27219   int val6 ;
27220   int ecode6 = 0 ;
27221   PyObject * obj0 = 0 ;
27222   PyObject * obj1 = 0 ;
27223   PyObject * obj2 = 0 ;
27224   PyObject * obj3 = 0 ;
27225   PyObject * obj4 = 0 ;
27226   PyObject * obj5 = 0 ;
27227   Hex::Elements *result = 0 ;
27228
27229   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27230   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27231   if (!SWIG_IsOK(res1)) {
27232     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
27233   }
27234   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27235   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27236   if (!SWIG_IsOK(res2)) {
27237     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
27238   }
27239   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27240   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27241   if (!SWIG_IsOK(res3)) {
27242     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
27243   }
27244   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27245   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27246   if (!SWIG_IsOK(res4)) {
27247     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
27248   }
27249   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27250   ecode5 = SWIG_AsVal_double(obj4, &val5);
27251   if (!SWIG_IsOK(ecode5)) {
27252     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
27253   }
27254   arg5 = static_cast< double >(val5);
27255   ecode6 = SWIG_AsVal_int(obj5, &val6);
27256   if (!SWIG_IsOK(ecode6)) {
27257     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
27258   }
27259   arg6 = static_cast< int >(val6);
27260   result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6);
27261   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27262   return resultobj;
27263 fail:
27264   return NULL;
27265 }
27266
27267
27268 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni(PyObject *self, PyObject *args) {
27269   int argc;
27270   PyObject *argv[8];
27271   int ii;
27272
27273   if (!PyTuple_Check(args)) SWIG_fail;
27274   argc = (int)PyObject_Length(args);
27275   for (ii = 0; (ii < argc) && (ii < 7); ii++) {
27276     argv[ii] = PyTuple_GET_ITEM(args,ii);
27277   }
27278   if (argc == 6) {
27279     int _v;
27280     void *vptr = 0;
27281     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
27282     _v = SWIG_CheckState(res);
27283     if (_v) {
27284       void *vptr = 0;
27285       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
27286       _v = SWIG_CheckState(res);
27287       if (_v) {
27288         void *vptr = 0;
27289         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
27290         _v = SWIG_CheckState(res);
27291         if (_v) {
27292           void *vptr = 0;
27293           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
27294           _v = SWIG_CheckState(res);
27295           if (_v) {
27296             {
27297               int res = SWIG_AsVal_double(argv[4], NULL);
27298               _v = SWIG_CheckState(res);
27299             }
27300             if (_v) {
27301               {
27302                 int res = SWIG_AsVal_int(argv[5], NULL);
27303                 _v = SWIG_CheckState(res);
27304               }
27305               if (_v) {
27306                 return _wrap_Document_makeSphericalUni__SWIG_1(self, args);
27307               }
27308             }
27309           }
27310         }
27311       }
27312     }
27313   }
27314   if (argc == 7) {
27315     int _v;
27316     void *vptr = 0;
27317     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
27318     _v = SWIG_CheckState(res);
27319     if (_v) {
27320       void *vptr = 0;
27321       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
27322       _v = SWIG_CheckState(res);
27323       if (_v) {
27324         void *vptr = 0;
27325         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
27326         _v = SWIG_CheckState(res);
27327         if (_v) {
27328           void *vptr = 0;
27329           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
27330           _v = SWIG_CheckState(res);
27331           if (_v) {
27332             {
27333               int res = SWIG_AsVal_double(argv[4], NULL);
27334               _v = SWIG_CheckState(res);
27335             }
27336             if (_v) {
27337               {
27338                 int res = SWIG_AsVal_int(argv[5], NULL);
27339                 _v = SWIG_CheckState(res);
27340               }
27341               if (_v) {
27342                 {
27343                   int res = SWIG_AsVal_int(argv[6], NULL);
27344                   _v = SWIG_CheckState(res);
27345                 }
27346                 if (_v) {
27347                   return _wrap_Document_makeSphericalUni__SWIG_0(self, args);
27348                 }
27349               }
27350             }
27351           }
27352         }
27353       }
27354     }
27355   }
27356
27357 fail:
27358   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSphericalUni'.\n"
27359     "  Possible C/C++ prototypes are:\n"
27360     "    makeSphericalUni(Hex::Document *,Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int,int)\n"
27361     "    makeSphericalUni(Hex::Document *,Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int)\n");
27362   return NULL;
27363 }
27364
27365
27366 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27367   PyObject *resultobj = 0;
27368   Hex::Document *arg1 = (Hex::Document *) 0 ;
27369   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27370   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27371   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27372   Hex::RealVector arg5 ;
27373   int arg6 ;
27374   void *argp1 = 0 ;
27375   int res1 = 0 ;
27376   void *argp2 = 0 ;
27377   int res2 = 0 ;
27378   void *argp3 = 0 ;
27379   int res3 = 0 ;
27380   void *argp4 = 0 ;
27381   int res4 = 0 ;
27382   int val6 ;
27383   int ecode6 = 0 ;
27384   PyObject * obj0 = 0 ;
27385   PyObject * obj1 = 0 ;
27386   PyObject * obj2 = 0 ;
27387   PyObject * obj3 = 0 ;
27388   PyObject * obj4 = 0 ;
27389   PyObject * obj5 = 0 ;
27390   Hex::Elements *result = 0 ;
27391
27392   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27393   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27394   if (!SWIG_IsOK(res1)) {
27395     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
27396   }
27397   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27398   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27399   if (!SWIG_IsOK(res2)) {
27400     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
27401   }
27402   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27403   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27404   if (!SWIG_IsOK(res3)) {
27405     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
27406   }
27407   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27408   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27409   if (!SWIG_IsOK(res4)) {
27410     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
27411   }
27412   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27413   {
27414     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
27415     int res = swig::asptr(obj4, &ptr);
27416     if (!SWIG_IsOK(res) || !ptr) {
27417       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
27418     }
27419     arg5 = *ptr;
27420     if (SWIG_IsNewObj(res)) delete ptr;
27421   }
27422   ecode6 = SWIG_AsVal_int(obj5, &val6);
27423   if (!SWIG_IsOK(ecode6)) {
27424     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSpherical" "', argument " "6"" of type '" "int""'");
27425   }
27426   arg6 = static_cast< int >(val6);
27427   result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5,arg6);
27428   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27429   return resultobj;
27430 fail:
27431   return NULL;
27432 }
27433
27434
27435 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27436   PyObject *resultobj = 0;
27437   Hex::Document *arg1 = (Hex::Document *) 0 ;
27438   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27439   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27440   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27441   Hex::RealVector arg5 ;
27442   void *argp1 = 0 ;
27443   int res1 = 0 ;
27444   void *argp2 = 0 ;
27445   int res2 = 0 ;
27446   void *argp3 = 0 ;
27447   int res3 = 0 ;
27448   void *argp4 = 0 ;
27449   int res4 = 0 ;
27450   PyObject * obj0 = 0 ;
27451   PyObject * obj1 = 0 ;
27452   PyObject * obj2 = 0 ;
27453   PyObject * obj3 = 0 ;
27454   PyObject * obj4 = 0 ;
27455   Hex::Elements *result = 0 ;
27456
27457   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27458   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27459   if (!SWIG_IsOK(res1)) {
27460     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
27461   }
27462   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27463   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27464   if (!SWIG_IsOK(res2)) {
27465     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
27466   }
27467   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27468   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27469   if (!SWIG_IsOK(res3)) {
27470     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
27471   }
27472   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27473   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27474   if (!SWIG_IsOK(res4)) {
27475     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
27476   }
27477   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27478   {
27479     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
27480     int res = swig::asptr(obj4, &ptr);
27481     if (!SWIG_IsOK(res) || !ptr) {
27482       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
27483     }
27484     arg5 = *ptr;
27485     if (SWIG_IsNewObj(res)) delete ptr;
27486   }
27487   result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5);
27488   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27489   return resultobj;
27490 fail:
27491   return NULL;
27492 }
27493
27494
27495 SWIGINTERN PyObject *_wrap_Document_makeSpherical(PyObject *self, PyObject *args) {
27496   int argc;
27497   PyObject *argv[7];
27498   int ii;
27499
27500   if (!PyTuple_Check(args)) SWIG_fail;
27501   argc = (int)PyObject_Length(args);
27502   for (ii = 0; (ii < argc) && (ii < 6); ii++) {
27503     argv[ii] = PyTuple_GET_ITEM(args,ii);
27504   }
27505   if (argc == 5) {
27506     int _v;
27507     void *vptr = 0;
27508     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
27509     _v = SWIG_CheckState(res);
27510     if (_v) {
27511       void *vptr = 0;
27512       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
27513       _v = SWIG_CheckState(res);
27514       if (_v) {
27515         void *vptr = 0;
27516         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
27517         _v = SWIG_CheckState(res);
27518         if (_v) {
27519           void *vptr = 0;
27520           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
27521           _v = SWIG_CheckState(res);
27522           if (_v) {
27523             int res = swig::asptr(argv[4], (std::vector<double,std::allocator< double > >**)(0));
27524             _v = SWIG_CheckState(res);
27525             if (_v) {
27526               return _wrap_Document_makeSpherical__SWIG_1(self, args);
27527             }
27528           }
27529         }
27530       }
27531     }
27532   }
27533   if (argc == 6) {
27534     int _v;
27535     void *vptr = 0;
27536     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
27537     _v = SWIG_CheckState(res);
27538     if (_v) {
27539       void *vptr = 0;
27540       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
27541       _v = SWIG_CheckState(res);
27542       if (_v) {
27543         void *vptr = 0;
27544         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
27545         _v = SWIG_CheckState(res);
27546         if (_v) {
27547           void *vptr = 0;
27548           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
27549           _v = SWIG_CheckState(res);
27550           if (_v) {
27551             int res = swig::asptr(argv[4], (std::vector<double,std::allocator< double > >**)(0));
27552             _v = SWIG_CheckState(res);
27553             if (_v) {
27554               {
27555                 int res = SWIG_AsVal_int(argv[5], NULL);
27556                 _v = SWIG_CheckState(res);
27557               }
27558               if (_v) {
27559                 return _wrap_Document_makeSpherical__SWIG_0(self, args);
27560               }
27561             }
27562           }
27563         }
27564       }
27565     }
27566   }
27567
27568 fail:
27569   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSpherical'.\n"
27570     "  Possible C/C++ prototypes are:\n"
27571     "    makeSpherical(Hex::Document *,Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector,int)\n"
27572     "    makeSpherical(Hex::Document *,Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector)\n");
27573   return NULL;
27574 }
27575
27576
27577 SWIGINTERN PyObject *_wrap_Document_makeSphereTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27578   PyObject *resultobj = 0;
27579   Hex::Document *arg1 = (Hex::Document *) 0 ;
27580   int arg2 ;
27581   int arg3 ;
27582   int arg4 ;
27583   void *argp1 = 0 ;
27584   int res1 = 0 ;
27585   int val2 ;
27586   int ecode2 = 0 ;
27587   int val3 ;
27588   int ecode3 = 0 ;
27589   int val4 ;
27590   int ecode4 = 0 ;
27591   PyObject * obj0 = 0 ;
27592   PyObject * obj1 = 0 ;
27593   PyObject * obj2 = 0 ;
27594   PyObject * obj3 = 0 ;
27595   Hex::Elements *result = 0 ;
27596
27597   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSphereTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27598   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27599   if (!SWIG_IsOK(res1)) {
27600     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereTop" "', argument " "1"" of type '" "Hex::Document *""'");
27601   }
27602   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27603   ecode2 = SWIG_AsVal_int(obj1, &val2);
27604   if (!SWIG_IsOK(ecode2)) {
27605     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphereTop" "', argument " "2"" of type '" "int""'");
27606   }
27607   arg2 = static_cast< int >(val2);
27608   ecode3 = SWIG_AsVal_int(obj2, &val3);
27609   if (!SWIG_IsOK(ecode3)) {
27610     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphereTop" "', argument " "3"" of type '" "int""'");
27611   }
27612   arg3 = static_cast< int >(val3);
27613   ecode4 = SWIG_AsVal_int(obj3, &val4);
27614   if (!SWIG_IsOK(ecode4)) {
27615     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeSphereTop" "', argument " "4"" of type '" "int""'");
27616   }
27617   arg4 = static_cast< int >(val4);
27618   result = (Hex::Elements *)(arg1)->makeSphereTop(arg2,arg3,arg4);
27619   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27620   return resultobj;
27621 fail:
27622   return NULL;
27623 }
27624
27625
27626 SWIGINTERN PyObject *_wrap_Document_makeSphereUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27627   PyObject *resultobj = 0;
27628   Hex::Document *arg1 = (Hex::Document *) 0 ;
27629   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27630   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27631   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27632   double arg5 ;
27633   double arg6 ;
27634   double arg7 ;
27635   Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
27636   int arg9 ;
27637   int arg10 ;
27638   int arg11 ;
27639   void *argp1 = 0 ;
27640   int res1 = 0 ;
27641   void *argp2 = 0 ;
27642   int res2 = 0 ;
27643   void *argp3 = 0 ;
27644   int res3 = 0 ;
27645   void *argp4 = 0 ;
27646   int res4 = 0 ;
27647   double val5 ;
27648   int ecode5 = 0 ;
27649   double val6 ;
27650   int ecode6 = 0 ;
27651   double val7 ;
27652   int ecode7 = 0 ;
27653   void *argp8 = 0 ;
27654   int res8 = 0 ;
27655   int val9 ;
27656   int ecode9 = 0 ;
27657   int val10 ;
27658   int ecode10 = 0 ;
27659   int val11 ;
27660   int ecode11 = 0 ;
27661   PyObject * obj0 = 0 ;
27662   PyObject * obj1 = 0 ;
27663   PyObject * obj2 = 0 ;
27664   PyObject * obj3 = 0 ;
27665   PyObject * obj4 = 0 ;
27666   PyObject * obj5 = 0 ;
27667   PyObject * obj6 = 0 ;
27668   PyObject * obj7 = 0 ;
27669   PyObject * obj8 = 0 ;
27670   PyObject * obj9 = 0 ;
27671   PyObject * obj10 = 0 ;
27672   Hex::Elements *result = 0 ;
27673
27674   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeSphereUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
27675   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27676   if (!SWIG_IsOK(res1)) {
27677     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereUni" "', argument " "1"" of type '" "Hex::Document *""'");
27678   }
27679   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27680   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27681   if (!SWIG_IsOK(res2)) {
27682     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphereUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
27683   }
27684   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27685   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27686   if (!SWIG_IsOK(res3)) {
27687     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphereUni" "', argument " "3"" of type '" "Hex::Vector *""'");
27688   }
27689   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27690   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27691   if (!SWIG_IsOK(res4)) {
27692     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphereUni" "', argument " "4"" of type '" "Hex::Vector *""'");
27693   }
27694   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27695   ecode5 = SWIG_AsVal_double(obj4, &val5);
27696   if (!SWIG_IsOK(ecode5)) {
27697     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphereUni" "', argument " "5"" of type '" "double""'");
27698   }
27699   arg5 = static_cast< double >(val5);
27700   ecode6 = SWIG_AsVal_double(obj5, &val6);
27701   if (!SWIG_IsOK(ecode6)) {
27702     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphereUni" "', argument " "6"" of type '" "double""'");
27703   }
27704   arg6 = static_cast< double >(val6);
27705   ecode7 = SWIG_AsVal_double(obj6, &val7);
27706   if (!SWIG_IsOK(ecode7)) {
27707     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphereUni" "', argument " "7"" of type '" "double""'");
27708   }
27709   arg7 = static_cast< double >(val7);
27710   res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27711   if (!SWIG_IsOK(res8)) {
27712     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makeSphereUni" "', argument " "8"" of type '" "Hex::Vertex *""'");
27713   }
27714   arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
27715   ecode9 = SWIG_AsVal_int(obj8, &val9);
27716   if (!SWIG_IsOK(ecode9)) {
27717     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeSphereUni" "', argument " "9"" of type '" "int""'");
27718   }
27719   arg9 = static_cast< int >(val9);
27720   ecode10 = SWIG_AsVal_int(obj9, &val10);
27721   if (!SWIG_IsOK(ecode10)) {
27722     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeSphereUni" "', argument " "10"" of type '" "int""'");
27723   }
27724   arg10 = static_cast< int >(val10);
27725   ecode11 = SWIG_AsVal_int(obj10, &val11);
27726   if (!SWIG_IsOK(ecode11)) {
27727     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeSphereUni" "', argument " "11"" of type '" "int""'");
27728   }
27729   arg11 = static_cast< int >(val11);
27730   result = (Hex::Elements *)(arg1)->makeSphereUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
27731   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27732   return resultobj;
27733 fail:
27734   return NULL;
27735 }
27736
27737
27738 SWIGINTERN PyObject *_wrap_Document_makeSphere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27739   PyObject *resultobj = 0;
27740   Hex::Document *arg1 = (Hex::Document *) 0 ;
27741   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27742   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27743   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27744   Hex::RealVector arg5 ;
27745   Hex::RealVector arg6 ;
27746   Hex::RealVector arg7 ;
27747   void *argp1 = 0 ;
27748   int res1 = 0 ;
27749   void *argp2 = 0 ;
27750   int res2 = 0 ;
27751   void *argp3 = 0 ;
27752   int res3 = 0 ;
27753   void *argp4 = 0 ;
27754   int res4 = 0 ;
27755   PyObject * obj0 = 0 ;
27756   PyObject * obj1 = 0 ;
27757   PyObject * obj2 = 0 ;
27758   PyObject * obj3 = 0 ;
27759   PyObject * obj4 = 0 ;
27760   PyObject * obj5 = 0 ;
27761   PyObject * obj6 = 0 ;
27762   Hex::Elements *result = 0 ;
27763
27764   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphere",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
27765   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27766   if (!SWIG_IsOK(res1)) {
27767     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphere" "', argument " "1"" of type '" "Hex::Document *""'");
27768   }
27769   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27770   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27771   if (!SWIG_IsOK(res2)) {
27772     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphere" "', argument " "2"" of type '" "Hex::Vertex *""'");
27773   }
27774   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27775   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27776   if (!SWIG_IsOK(res3)) {
27777     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphere" "', argument " "3"" of type '" "Hex::Vector *""'");
27778   }
27779   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27780   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27781   if (!SWIG_IsOK(res4)) {
27782     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphere" "', argument " "4"" of type '" "Hex::Vector *""'");
27783   }
27784   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27785   {
27786     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
27787     int res = swig::asptr(obj4, &ptr);
27788     if (!SWIG_IsOK(res) || !ptr) {
27789       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "5"" of type '" "Hex::RealVector""'");
27790     }
27791     arg5 = *ptr;
27792     if (SWIG_IsNewObj(res)) delete ptr;
27793   }
27794   {
27795     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
27796     int res = swig::asptr(obj5, &ptr);
27797     if (!SWIG_IsOK(res) || !ptr) {
27798       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "6"" of type '" "Hex::RealVector""'");
27799     }
27800     arg6 = *ptr;
27801     if (SWIG_IsNewObj(res)) delete ptr;
27802   }
27803   {
27804     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
27805     int res = swig::asptr(obj6, &ptr);
27806     if (!SWIG_IsOK(res) || !ptr) {
27807       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "7"" of type '" "Hex::RealVector""'");
27808     }
27809     arg7 = *ptr;
27810     if (SWIG_IsNewObj(res)) delete ptr;
27811   }
27812   result = (Hex::Elements *)(arg1)->makeSphere(arg2,arg3,arg4,arg5,arg6,arg7);
27813   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27814   return resultobj;
27815 fail:
27816   return NULL;
27817 }
27818
27819
27820 SWIGINTERN PyObject *_wrap_Document_makeRindTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27821   PyObject *resultobj = 0;
27822   Hex::Document *arg1 = (Hex::Document *) 0 ;
27823   int arg2 ;
27824   int arg3 ;
27825   int arg4 ;
27826   void *argp1 = 0 ;
27827   int res1 = 0 ;
27828   int val2 ;
27829   int ecode2 = 0 ;
27830   int val3 ;
27831   int ecode3 = 0 ;
27832   int val4 ;
27833   int ecode4 = 0 ;
27834   PyObject * obj0 = 0 ;
27835   PyObject * obj1 = 0 ;
27836   PyObject * obj2 = 0 ;
27837   PyObject * obj3 = 0 ;
27838   Hex::Elements *result = 0 ;
27839
27840   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeRindTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27841   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27842   if (!SWIG_IsOK(res1)) {
27843     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindTop" "', argument " "1"" of type '" "Hex::Document *""'");
27844   }
27845   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27846   ecode2 = SWIG_AsVal_int(obj1, &val2);
27847   if (!SWIG_IsOK(ecode2)) {
27848     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeRindTop" "', argument " "2"" of type '" "int""'");
27849   }
27850   arg2 = static_cast< int >(val2);
27851   ecode3 = SWIG_AsVal_int(obj2, &val3);
27852   if (!SWIG_IsOK(ecode3)) {
27853     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeRindTop" "', argument " "3"" of type '" "int""'");
27854   }
27855   arg3 = static_cast< int >(val3);
27856   ecode4 = SWIG_AsVal_int(obj3, &val4);
27857   if (!SWIG_IsOK(ecode4)) {
27858     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeRindTop" "', argument " "4"" of type '" "int""'");
27859   }
27860   arg4 = static_cast< int >(val4);
27861   result = (Hex::Elements *)(arg1)->makeRindTop(arg2,arg3,arg4);
27862   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27863   return resultobj;
27864 fail:
27865   return NULL;
27866 }
27867
27868
27869 SWIGINTERN PyObject *_wrap_Document_makeRindUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27870   PyObject *resultobj = 0;
27871   Hex::Document *arg1 = (Hex::Document *) 0 ;
27872   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27873   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27874   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27875   double arg5 ;
27876   double arg6 ;
27877   double arg7 ;
27878   double arg8 ;
27879   Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
27880   int arg10 ;
27881   int arg11 ;
27882   int arg12 ;
27883   void *argp1 = 0 ;
27884   int res1 = 0 ;
27885   void *argp2 = 0 ;
27886   int res2 = 0 ;
27887   void *argp3 = 0 ;
27888   int res3 = 0 ;
27889   void *argp4 = 0 ;
27890   int res4 = 0 ;
27891   double val5 ;
27892   int ecode5 = 0 ;
27893   double val6 ;
27894   int ecode6 = 0 ;
27895   double val7 ;
27896   int ecode7 = 0 ;
27897   double val8 ;
27898   int ecode8 = 0 ;
27899   void *argp9 = 0 ;
27900   int res9 = 0 ;
27901   int val10 ;
27902   int ecode10 = 0 ;
27903   int val11 ;
27904   int ecode11 = 0 ;
27905   int val12 ;
27906   int ecode12 = 0 ;
27907   PyObject * obj0 = 0 ;
27908   PyObject * obj1 = 0 ;
27909   PyObject * obj2 = 0 ;
27910   PyObject * obj3 = 0 ;
27911   PyObject * obj4 = 0 ;
27912   PyObject * obj5 = 0 ;
27913   PyObject * obj6 = 0 ;
27914   PyObject * obj7 = 0 ;
27915   PyObject * obj8 = 0 ;
27916   PyObject * obj9 = 0 ;
27917   PyObject * obj10 = 0 ;
27918   PyObject * obj11 = 0 ;
27919   Hex::Elements *result = 0 ;
27920
27921   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Document_makeRindUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
27922   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27923   if (!SWIG_IsOK(res1)) {
27924     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindUni" "', argument " "1"" of type '" "Hex::Document *""'");
27925   }
27926   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27927   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27928   if (!SWIG_IsOK(res2)) {
27929     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRindUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
27930   }
27931   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27932   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27933   if (!SWIG_IsOK(res3)) {
27934     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRindUni" "', argument " "3"" of type '" "Hex::Vector *""'");
27935   }
27936   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27937   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27938   if (!SWIG_IsOK(res4)) {
27939     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRindUni" "', argument " "4"" of type '" "Hex::Vector *""'");
27940   }
27941   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27942   ecode5 = SWIG_AsVal_double(obj4, &val5);
27943   if (!SWIG_IsOK(ecode5)) {
27944     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeRindUni" "', argument " "5"" of type '" "double""'");
27945   }
27946   arg5 = static_cast< double >(val5);
27947   ecode6 = SWIG_AsVal_double(obj5, &val6);
27948   if (!SWIG_IsOK(ecode6)) {
27949     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeRindUni" "', argument " "6"" of type '" "double""'");
27950   }
27951   arg6 = static_cast< double >(val6);
27952   ecode7 = SWIG_AsVal_double(obj6, &val7);
27953   if (!SWIG_IsOK(ecode7)) {
27954     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeRindUni" "', argument " "7"" of type '" "double""'");
27955   }
27956   arg7 = static_cast< double >(val7);
27957   ecode8 = SWIG_AsVal_double(obj7, &val8);
27958   if (!SWIG_IsOK(ecode8)) {
27959     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeRindUni" "', argument " "8"" of type '" "double""'");
27960   }
27961   arg8 = static_cast< double >(val8);
27962   res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27963   if (!SWIG_IsOK(res9)) {
27964     SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Document_makeRindUni" "', argument " "9"" of type '" "Hex::Vertex *""'");
27965   }
27966   arg9 = reinterpret_cast< Hex::Vertex * >(argp9);
27967   ecode10 = SWIG_AsVal_int(obj9, &val10);
27968   if (!SWIG_IsOK(ecode10)) {
27969     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeRindUni" "', argument " "10"" of type '" "int""'");
27970   }
27971   arg10 = static_cast< int >(val10);
27972   ecode11 = SWIG_AsVal_int(obj10, &val11);
27973   if (!SWIG_IsOK(ecode11)) {
27974     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeRindUni" "', argument " "11"" of type '" "int""'");
27975   }
27976   arg11 = static_cast< int >(val11);
27977   ecode12 = SWIG_AsVal_int(obj11, &val12);
27978   if (!SWIG_IsOK(ecode12)) {
27979     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Document_makeRindUni" "', argument " "12"" of type '" "int""'");
27980   }
27981   arg12 = static_cast< int >(val12);
27982   result = (Hex::Elements *)(arg1)->makeRindUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
27983   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27984   return resultobj;
27985 fail:
27986   return NULL;
27987 }
27988
27989
27990 SWIGINTERN PyObject *_wrap_Document_makeRind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27991   PyObject *resultobj = 0;
27992   Hex::Document *arg1 = (Hex::Document *) 0 ;
27993   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27994   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27995   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27996   Hex::RealVector arg5 ;
27997   Hex::RealVector arg6 ;
27998   Hex::RealVector arg7 ;
27999   void *argp1 = 0 ;
28000   int res1 = 0 ;
28001   void *argp2 = 0 ;
28002   int res2 = 0 ;
28003   void *argp3 = 0 ;
28004   int res3 = 0 ;
28005   void *argp4 = 0 ;
28006   int res4 = 0 ;
28007   PyObject * obj0 = 0 ;
28008   PyObject * obj1 = 0 ;
28009   PyObject * obj2 = 0 ;
28010   PyObject * obj3 = 0 ;
28011   PyObject * obj4 = 0 ;
28012   PyObject * obj5 = 0 ;
28013   PyObject * obj6 = 0 ;
28014   Hex::Elements *result = 0 ;
28015
28016   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeRind",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
28017   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28018   if (!SWIG_IsOK(res1)) {
28019     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRind" "', argument " "1"" of type '" "Hex::Document *""'");
28020   }
28021   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28022   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28023   if (!SWIG_IsOK(res2)) {
28024     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRind" "', argument " "2"" of type '" "Hex::Vertex *""'");
28025   }
28026   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28027   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28028   if (!SWIG_IsOK(res3)) {
28029     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRind" "', argument " "3"" of type '" "Hex::Vector *""'");
28030   }
28031   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28032   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28033   if (!SWIG_IsOK(res4)) {
28034     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRind" "', argument " "4"" of type '" "Hex::Vector *""'");
28035   }
28036   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
28037   {
28038     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
28039     int res = swig::asptr(obj4, &ptr);
28040     if (!SWIG_IsOK(res) || !ptr) {
28041       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "5"" of type '" "Hex::RealVector""'");
28042     }
28043     arg5 = *ptr;
28044     if (SWIG_IsNewObj(res)) delete ptr;
28045   }
28046   {
28047     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
28048     int res = swig::asptr(obj5, &ptr);
28049     if (!SWIG_IsOK(res) || !ptr) {
28050       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "6"" of type '" "Hex::RealVector""'");
28051     }
28052     arg6 = *ptr;
28053     if (SWIG_IsNewObj(res)) delete ptr;
28054   }
28055   {
28056     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
28057     int res = swig::asptr(obj6, &ptr);
28058     if (!SWIG_IsOK(res) || !ptr) {
28059       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "7"" of type '" "Hex::RealVector""'");
28060     }
28061     arg7 = *ptr;
28062     if (SWIG_IsNewObj(res)) delete ptr;
28063   }
28064   result = (Hex::Elements *)(arg1)->makeRind(arg2,arg3,arg4,arg5,arg6,arg7);
28065   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28066   return resultobj;
28067 fail:
28068   return NULL;
28069 }
28070
28071
28072 SWIGINTERN PyObject *_wrap_Document_makeCylinders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28073   PyObject *resultobj = 0;
28074   Hex::Document *arg1 = (Hex::Document *) 0 ;
28075   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28076   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28077   double arg4 ;
28078   double arg5 ;
28079   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
28080   Hex::Vector *arg7 = (Hex::Vector *) 0 ;
28081   double arg8 ;
28082   double arg9 ;
28083   void *argp1 = 0 ;
28084   int res1 = 0 ;
28085   void *argp2 = 0 ;
28086   int res2 = 0 ;
28087   void *argp3 = 0 ;
28088   int res3 = 0 ;
28089   double val4 ;
28090   int ecode4 = 0 ;
28091   double val5 ;
28092   int ecode5 = 0 ;
28093   void *argp6 = 0 ;
28094   int res6 = 0 ;
28095   void *argp7 = 0 ;
28096   int res7 = 0 ;
28097   double val8 ;
28098   int ecode8 = 0 ;
28099   double val9 ;
28100   int ecode9 = 0 ;
28101   PyObject * obj0 = 0 ;
28102   PyObject * obj1 = 0 ;
28103   PyObject * obj2 = 0 ;
28104   PyObject * obj3 = 0 ;
28105   PyObject * obj4 = 0 ;
28106   PyObject * obj5 = 0 ;
28107   PyObject * obj6 = 0 ;
28108   PyObject * obj7 = 0 ;
28109   PyObject * obj8 = 0 ;
28110   Hex::BiCylinder *result = 0 ;
28111
28112   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_makeCylinders",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
28113   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28114   if (!SWIG_IsOK(res1)) {
28115     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinders" "', argument " "1"" of type '" "Hex::Document *""'");
28116   }
28117   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28118   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28119   if (!SWIG_IsOK(res2)) {
28120     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinders" "', argument " "2"" of type '" "Hex::Vertex *""'");
28121   }
28122   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28123   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28124   if (!SWIG_IsOK(res3)) {
28125     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinders" "', argument " "3"" of type '" "Hex::Vector *""'");
28126   }
28127   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28128   ecode4 = SWIG_AsVal_double(obj3, &val4);
28129   if (!SWIG_IsOK(ecode4)) {
28130     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinders" "', argument " "4"" of type '" "double""'");
28131   }
28132   arg4 = static_cast< double >(val4);
28133   ecode5 = SWIG_AsVal_double(obj4, &val5);
28134   if (!SWIG_IsOK(ecode5)) {
28135     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinders" "', argument " "5"" of type '" "double""'");
28136   }
28137   arg5 = static_cast< double >(val5);
28138   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28139   if (!SWIG_IsOK(res6)) {
28140     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_makeCylinders" "', argument " "6"" of type '" "Hex::Vertex *""'");
28141   }
28142   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
28143   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28144   if (!SWIG_IsOK(res7)) {
28145     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makeCylinders" "', argument " "7"" of type '" "Hex::Vector *""'");
28146   }
28147   arg7 = reinterpret_cast< Hex::Vector * >(argp7);
28148   ecode8 = SWIG_AsVal_double(obj7, &val8);
28149   if (!SWIG_IsOK(ecode8)) {
28150     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinders" "', argument " "8"" of type '" "double""'");
28151   }
28152   arg8 = static_cast< double >(val8);
28153   ecode9 = SWIG_AsVal_double(obj8, &val9);
28154   if (!SWIG_IsOK(ecode9)) {
28155     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinders" "', argument " "9"" of type '" "double""'");
28156   }
28157   arg9 = static_cast< double >(val9);
28158   result = (Hex::BiCylinder *)(arg1)->makeCylinders(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
28159   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
28160   return resultobj;
28161 fail:
28162   return NULL;
28163 }
28164
28165
28166 SWIGINTERN PyObject *_wrap_Document_makePipes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28167   PyObject *resultobj = 0;
28168   Hex::Document *arg1 = (Hex::Document *) 0 ;
28169   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28170   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28171   double arg4 ;
28172   double arg5 ;
28173   double arg6 ;
28174   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
28175   Hex::Vector *arg8 = (Hex::Vector *) 0 ;
28176   double arg9 ;
28177   double arg10 ;
28178   double arg11 ;
28179   void *argp1 = 0 ;
28180   int res1 = 0 ;
28181   void *argp2 = 0 ;
28182   int res2 = 0 ;
28183   void *argp3 = 0 ;
28184   int res3 = 0 ;
28185   double val4 ;
28186   int ecode4 = 0 ;
28187   double val5 ;
28188   int ecode5 = 0 ;
28189   double val6 ;
28190   int ecode6 = 0 ;
28191   void *argp7 = 0 ;
28192   int res7 = 0 ;
28193   void *argp8 = 0 ;
28194   int res8 = 0 ;
28195   double val9 ;
28196   int ecode9 = 0 ;
28197   double val10 ;
28198   int ecode10 = 0 ;
28199   double val11 ;
28200   int ecode11 = 0 ;
28201   PyObject * obj0 = 0 ;
28202   PyObject * obj1 = 0 ;
28203   PyObject * obj2 = 0 ;
28204   PyObject * obj3 = 0 ;
28205   PyObject * obj4 = 0 ;
28206   PyObject * obj5 = 0 ;
28207   PyObject * obj6 = 0 ;
28208   PyObject * obj7 = 0 ;
28209   PyObject * obj8 = 0 ;
28210   PyObject * obj9 = 0 ;
28211   PyObject * obj10 = 0 ;
28212   Hex::BiCylinder *result = 0 ;
28213
28214   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
28215   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28216   if (!SWIG_IsOK(res1)) {
28217     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipes" "', argument " "1"" of type '" "Hex::Document *""'");
28218   }
28219   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28220   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28221   if (!SWIG_IsOK(res2)) {
28222     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipes" "', argument " "2"" of type '" "Hex::Vertex *""'");
28223   }
28224   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28225   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28226   if (!SWIG_IsOK(res3)) {
28227     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipes" "', argument " "3"" of type '" "Hex::Vector *""'");
28228   }
28229   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28230   ecode4 = SWIG_AsVal_double(obj3, &val4);
28231   if (!SWIG_IsOK(ecode4)) {
28232     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipes" "', argument " "4"" of type '" "double""'");
28233   }
28234   arg4 = static_cast< double >(val4);
28235   ecode5 = SWIG_AsVal_double(obj4, &val5);
28236   if (!SWIG_IsOK(ecode5)) {
28237     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipes" "', argument " "5"" of type '" "double""'");
28238   }
28239   arg5 = static_cast< double >(val5);
28240   ecode6 = SWIG_AsVal_double(obj5, &val6);
28241   if (!SWIG_IsOK(ecode6)) {
28242     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipes" "', argument " "6"" of type '" "double""'");
28243   }
28244   arg6 = static_cast< double >(val6);
28245   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28246   if (!SWIG_IsOK(res7)) {
28247     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makePipes" "', argument " "7"" of type '" "Hex::Vertex *""'");
28248   }
28249   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
28250   res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28251   if (!SWIG_IsOK(res8)) {
28252     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makePipes" "', argument " "8"" of type '" "Hex::Vector *""'");
28253   }
28254   arg8 = reinterpret_cast< Hex::Vector * >(argp8);
28255   ecode9 = SWIG_AsVal_double(obj8, &val9);
28256   if (!SWIG_IsOK(ecode9)) {
28257     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipes" "', argument " "9"" of type '" "double""'");
28258   }
28259   arg9 = static_cast< double >(val9);
28260   ecode10 = SWIG_AsVal_double(obj9, &val10);
28261   if (!SWIG_IsOK(ecode10)) {
28262     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipes" "', argument " "10"" of type '" "double""'");
28263   }
28264   arg10 = static_cast< double >(val10);
28265   ecode11 = SWIG_AsVal_double(obj10, &val11);
28266   if (!SWIG_IsOK(ecode11)) {
28267     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipes" "', argument " "11"" of type '" "double""'");
28268   }
28269   arg11 = static_cast< double >(val11);
28270   result = (Hex::BiCylinder *)(arg1)->makePipes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
28271   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
28272   return resultobj;
28273 fail:
28274   return NULL;
28275 }
28276
28277
28278 SWIGINTERN PyObject *_wrap_Document_extrudeQuadTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28279   PyObject *resultobj = 0;
28280   Hex::Document *arg1 = (Hex::Document *) 0 ;
28281   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
28282   int arg3 ;
28283   void *argp1 = 0 ;
28284   int res1 = 0 ;
28285   void *argp2 = 0 ;
28286   int res2 = 0 ;
28287   int val3 ;
28288   int ecode3 = 0 ;
28289   PyObject * obj0 = 0 ;
28290   PyObject * obj1 = 0 ;
28291   PyObject * obj2 = 0 ;
28292   Hex::Elements *result = 0 ;
28293
28294   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadTop",&obj0,&obj1,&obj2)) SWIG_fail;
28295   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28296   if (!SWIG_IsOK(res1)) {
28297     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadTop" "', argument " "1"" of type '" "Hex::Document *""'");
28298   }
28299   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28300   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28301   if (!SWIG_IsOK(res2)) {
28302     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadTop" "', argument " "2"" of type '" "Hex::Quad *""'");
28303   }
28304   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
28305   ecode3 = SWIG_AsVal_int(obj2, &val3);
28306   if (!SWIG_IsOK(ecode3)) {
28307     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadTop" "', argument " "3"" of type '" "int""'");
28308   }
28309   arg3 = static_cast< int >(val3);
28310   result = (Hex::Elements *)(arg1)->extrudeQuadTop(arg2,arg3);
28311   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28312   return resultobj;
28313 fail:
28314   return NULL;
28315 }
28316
28317
28318 SWIGINTERN PyObject *_wrap_Document_extrudeQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28319   PyObject *resultobj = 0;
28320   Hex::Document *arg1 = (Hex::Document *) 0 ;
28321   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
28322   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28323   double arg4 ;
28324   int arg5 ;
28325   void *argp1 = 0 ;
28326   int res1 = 0 ;
28327   void *argp2 = 0 ;
28328   int res2 = 0 ;
28329   void *argp3 = 0 ;
28330   int res3 = 0 ;
28331   double val4 ;
28332   int ecode4 = 0 ;
28333   int val5 ;
28334   int ecode5 = 0 ;
28335   PyObject * obj0 = 0 ;
28336   PyObject * obj1 = 0 ;
28337   PyObject * obj2 = 0 ;
28338   PyObject * obj3 = 0 ;
28339   PyObject * obj4 = 0 ;
28340   Hex::Elements *result = 0 ;
28341
28342   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28343   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28344   if (!SWIG_IsOK(res1)) {
28345     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
28346   }
28347   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28348   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28349   if (!SWIG_IsOK(res2)) {
28350     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
28351   }
28352   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
28353   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28354   if (!SWIG_IsOK(res3)) {
28355     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadUni" "', argument " "3"" of type '" "Hex::Vector *""'");
28356   }
28357   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28358   ecode4 = SWIG_AsVal_double(obj3, &val4);
28359   if (!SWIG_IsOK(ecode4)) {
28360     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadUni" "', argument " "4"" of type '" "double""'");
28361   }
28362   arg4 = static_cast< double >(val4);
28363   ecode5 = SWIG_AsVal_int(obj4, &val5);
28364   if (!SWIG_IsOK(ecode5)) {
28365     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadUni" "', argument " "5"" of type '" "int""'");
28366   }
28367   arg5 = static_cast< int >(val5);
28368   result = (Hex::Elements *)(arg1)->extrudeQuadUni(arg2,arg3,arg4,arg5);
28369   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28370   return resultobj;
28371 fail:
28372   return NULL;
28373 }
28374
28375
28376 SWIGINTERN PyObject *_wrap_Document_extrudeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28377   PyObject *resultobj = 0;
28378   Hex::Document *arg1 = (Hex::Document *) 0 ;
28379   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
28380   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28381   Hex::RealVector arg4 ;
28382   void *argp1 = 0 ;
28383   int res1 = 0 ;
28384   void *argp2 = 0 ;
28385   int res2 = 0 ;
28386   void *argp3 = 0 ;
28387   int res3 = 0 ;
28388   PyObject * obj0 = 0 ;
28389   PyObject * obj1 = 0 ;
28390   PyObject * obj2 = 0 ;
28391   PyObject * obj3 = 0 ;
28392   Hex::Elements *result = 0 ;
28393
28394   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28395   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28396   if (!SWIG_IsOK(res1)) {
28397     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
28398   }
28399   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28400   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28401   if (!SWIG_IsOK(res2)) {
28402     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
28403   }
28404   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
28405   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28406   if (!SWIG_IsOK(res3)) {
28407     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuad" "', argument " "3"" of type '" "Hex::Vector *""'");
28408   }
28409   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28410   {
28411     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
28412     int res = swig::asptr(obj3, &ptr);
28413     if (!SWIG_IsOK(res) || !ptr) {
28414       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuad" "', argument " "4"" of type '" "Hex::RealVector""'");
28415     }
28416     arg4 = *ptr;
28417     if (SWIG_IsNewObj(res)) delete ptr;
28418   }
28419   result = (Hex::Elements *)(arg1)->extrudeQuad(arg2,arg3,arg4);
28420   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28421   return resultobj;
28422 fail:
28423   return NULL;
28424 }
28425
28426
28427 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28428   PyObject *resultobj = 0;
28429   Hex::Document *arg1 = (Hex::Document *) 0 ;
28430   Hex::Quads arg2 ;
28431   int arg3 ;
28432   void *argp1 = 0 ;
28433   int res1 = 0 ;
28434   int val3 ;
28435   int ecode3 = 0 ;
28436   PyObject * obj0 = 0 ;
28437   PyObject * obj1 = 0 ;
28438   PyObject * obj2 = 0 ;
28439   Hex::Elements *result = 0 ;
28440
28441   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadsTop",&obj0,&obj1,&obj2)) SWIG_fail;
28442   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28443   if (!SWIG_IsOK(res1)) {
28444     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsTop" "', argument " "1"" of type '" "Hex::Document *""'");
28445   }
28446   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28447   {
28448     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
28449     int res = swig::asptr(obj1, &ptr);
28450     if (!SWIG_IsOK(res) || !ptr) {
28451       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsTop" "', argument " "2"" of type '" "Hex::Quads""'");
28452     }
28453     arg2 = *ptr;
28454     if (SWIG_IsNewObj(res)) delete ptr;
28455   }
28456   ecode3 = SWIG_AsVal_int(obj2, &val3);
28457   if (!SWIG_IsOK(ecode3)) {
28458     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadsTop" "', argument " "3"" of type '" "int""'");
28459   }
28460   arg3 = static_cast< int >(val3);
28461   result = (Hex::Elements *)(arg1)->extrudeQuadsTop(arg2,arg3);
28462   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28463   return resultobj;
28464 fail:
28465   return NULL;
28466 }
28467
28468
28469 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28470   PyObject *resultobj = 0;
28471   Hex::Document *arg1 = (Hex::Document *) 0 ;
28472   Hex::Quads arg2 ;
28473   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28474   double arg4 ;
28475   int arg5 ;
28476   void *argp1 = 0 ;
28477   int res1 = 0 ;
28478   void *argp3 = 0 ;
28479   int res3 = 0 ;
28480   double val4 ;
28481   int ecode4 = 0 ;
28482   int val5 ;
28483   int ecode5 = 0 ;
28484   PyObject * obj0 = 0 ;
28485   PyObject * obj1 = 0 ;
28486   PyObject * obj2 = 0 ;
28487   PyObject * obj3 = 0 ;
28488   PyObject * obj4 = 0 ;
28489   Hex::Elements *result = 0 ;
28490
28491   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28492   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28493   if (!SWIG_IsOK(res1)) {
28494     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
28495   }
28496   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28497   {
28498     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
28499     int res = swig::asptr(obj1, &ptr);
28500     if (!SWIG_IsOK(res) || !ptr) {
28501       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
28502     }
28503     arg2 = *ptr;
28504     if (SWIG_IsNewObj(res)) delete ptr;
28505   }
28506   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28507   if (!SWIG_IsOK(res3)) {
28508     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadsUni" "', argument " "3"" of type '" "Hex::Vector *""'");
28509   }
28510   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28511   ecode4 = SWIG_AsVal_double(obj3, &val4);
28512   if (!SWIG_IsOK(ecode4)) {
28513     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadsUni" "', argument " "4"" of type '" "double""'");
28514   }
28515   arg4 = static_cast< double >(val4);
28516   ecode5 = SWIG_AsVal_int(obj4, &val5);
28517   if (!SWIG_IsOK(ecode5)) {
28518     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadsUni" "', argument " "5"" of type '" "int""'");
28519   }
28520   arg5 = static_cast< int >(val5);
28521   result = (Hex::Elements *)(arg1)->extrudeQuadsUni(arg2,arg3,arg4,arg5);
28522   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28523   return resultobj;
28524 fail:
28525   return NULL;
28526 }
28527
28528
28529 SWIGINTERN PyObject *_wrap_Document_extrudeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28530   PyObject *resultobj = 0;
28531   Hex::Document *arg1 = (Hex::Document *) 0 ;
28532   Hex::Quads arg2 ;
28533   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28534   Hex::RealVector arg4 ;
28535   void *argp1 = 0 ;
28536   int res1 = 0 ;
28537   void *argp3 = 0 ;
28538   int res3 = 0 ;
28539   PyObject * obj0 = 0 ;
28540   PyObject * obj1 = 0 ;
28541   PyObject * obj2 = 0 ;
28542   PyObject * obj3 = 0 ;
28543   Hex::Elements *result = 0 ;
28544
28545   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28546   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28547   if (!SWIG_IsOK(res1)) {
28548     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
28549   }
28550   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28551   {
28552     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
28553     int res = swig::asptr(obj1, &ptr);
28554     if (!SWIG_IsOK(res) || !ptr) {
28555       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "2"" of type '" "Hex::Quads""'");
28556     }
28557     arg2 = *ptr;
28558     if (SWIG_IsNewObj(res)) delete ptr;
28559   }
28560   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28561   if (!SWIG_IsOK(res3)) {
28562     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuads" "', argument " "3"" of type '" "Hex::Vector *""'");
28563   }
28564   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28565   {
28566     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
28567     int res = swig::asptr(obj3, &ptr);
28568     if (!SWIG_IsOK(res) || !ptr) {
28569       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "4"" of type '" "Hex::RealVector""'");
28570     }
28571     arg4 = *ptr;
28572     if (SWIG_IsNewObj(res)) delete ptr;
28573   }
28574   result = (Hex::Elements *)(arg1)->extrudeQuads(arg2,arg3,arg4);
28575   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28576   return resultobj;
28577 fail:
28578   return NULL;
28579 }
28580
28581
28582 SWIGINTERN PyObject *_wrap_Document_revolutionQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28583   PyObject *resultobj = 0;
28584   Hex::Document *arg1 = (Hex::Document *) 0 ;
28585   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
28586   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
28587   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
28588   double arg5 ;
28589   int arg6 ;
28590   void *argp1 = 0 ;
28591   int res1 = 0 ;
28592   void *argp2 = 0 ;
28593   int res2 = 0 ;
28594   void *argp3 = 0 ;
28595   int res3 = 0 ;
28596   void *argp4 = 0 ;
28597   int res4 = 0 ;
28598   double val5 ;
28599   int ecode5 = 0 ;
28600   int val6 ;
28601   int ecode6 = 0 ;
28602   PyObject * obj0 = 0 ;
28603   PyObject * obj1 = 0 ;
28604   PyObject * obj2 = 0 ;
28605   PyObject * obj3 = 0 ;
28606   PyObject * obj4 = 0 ;
28607   PyObject * obj5 = 0 ;
28608   Hex::Elements *result = 0 ;
28609
28610   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
28611   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28612   if (!SWIG_IsOK(res1)) {
28613     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
28614   }
28615   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28616   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28617   if (!SWIG_IsOK(res2)) {
28618     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
28619   }
28620   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
28621   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28622   if (!SWIG_IsOK(res3)) {
28623     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
28624   }
28625   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
28626   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28627   if (!SWIG_IsOK(res4)) {
28628     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadUni" "', argument " "4"" of type '" "Hex::Vector *""'");
28629   }
28630   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
28631   ecode5 = SWIG_AsVal_double(obj4, &val5);
28632   if (!SWIG_IsOK(ecode5)) {
28633     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadUni" "', argument " "5"" of type '" "double""'");
28634   }
28635   arg5 = static_cast< double >(val5);
28636   ecode6 = SWIG_AsVal_int(obj5, &val6);
28637   if (!SWIG_IsOK(ecode6)) {
28638     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadUni" "', argument " "6"" of type '" "int""'");
28639   }
28640   arg6 = static_cast< int >(val6);
28641   result = (Hex::Elements *)(arg1)->revolutionQuadUni(arg2,arg3,arg4,arg5,arg6);
28642   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28643   return resultobj;
28644 fail:
28645   return NULL;
28646 }
28647
28648
28649 SWIGINTERN PyObject *_wrap_Document_revolutionQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28650   PyObject *resultobj = 0;
28651   Hex::Document *arg1 = (Hex::Document *) 0 ;
28652   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
28653   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
28654   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
28655   Hex::RealVector arg5 ;
28656   void *argp1 = 0 ;
28657   int res1 = 0 ;
28658   void *argp2 = 0 ;
28659   int res2 = 0 ;
28660   void *argp3 = 0 ;
28661   int res3 = 0 ;
28662   void *argp4 = 0 ;
28663   int res4 = 0 ;
28664   PyObject * obj0 = 0 ;
28665   PyObject * obj1 = 0 ;
28666   PyObject * obj2 = 0 ;
28667   PyObject * obj3 = 0 ;
28668   PyObject * obj4 = 0 ;
28669   Hex::Elements *result = 0 ;
28670
28671   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28672   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28673   if (!SWIG_IsOK(res1)) {
28674     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuad" "', argument " "1"" of type '" "Hex::Document *""'");
28675   }
28676   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28677   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28678   if (!SWIG_IsOK(res2)) {
28679     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
28680   }
28681   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
28682   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28683   if (!SWIG_IsOK(res3)) {
28684     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
28685   }
28686   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
28687   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28688   if (!SWIG_IsOK(res4)) {
28689     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuad" "', argument " "4"" of type '" "Hex::Vector *""'");
28690   }
28691   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
28692   {
28693     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
28694     int res = swig::asptr(obj4, &ptr);
28695     if (!SWIG_IsOK(res) || !ptr) {
28696       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuad" "', argument " "5"" of type '" "Hex::RealVector""'");
28697     }
28698     arg5 = *ptr;
28699     if (SWIG_IsNewObj(res)) delete ptr;
28700   }
28701   result = (Hex::Elements *)(arg1)->revolutionQuad(arg2,arg3,arg4,arg5);
28702   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28703   return resultobj;
28704 fail:
28705   return NULL;
28706 }
28707
28708
28709 SWIGINTERN PyObject *_wrap_Document_revolutionQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28710   PyObject *resultobj = 0;
28711   Hex::Document *arg1 = (Hex::Document *) 0 ;
28712   Hex::Quads arg2 ;
28713   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
28714   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
28715   double arg5 ;
28716   int arg6 ;
28717   void *argp1 = 0 ;
28718   int res1 = 0 ;
28719   void *argp3 = 0 ;
28720   int res3 = 0 ;
28721   void *argp4 = 0 ;
28722   int res4 = 0 ;
28723   double val5 ;
28724   int ecode5 = 0 ;
28725   int val6 ;
28726   int ecode6 = 0 ;
28727   PyObject * obj0 = 0 ;
28728   PyObject * obj1 = 0 ;
28729   PyObject * obj2 = 0 ;
28730   PyObject * obj3 = 0 ;
28731   PyObject * obj4 = 0 ;
28732   PyObject * obj5 = 0 ;
28733   Hex::Elements *result = 0 ;
28734
28735   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
28736   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28737   if (!SWIG_IsOK(res1)) {
28738     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
28739   }
28740   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28741   {
28742     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
28743     int res = swig::asptr(obj1, &ptr);
28744     if (!SWIG_IsOK(res) || !ptr) {
28745       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
28746     }
28747     arg2 = *ptr;
28748     if (SWIG_IsNewObj(res)) delete ptr;
28749   }
28750   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28751   if (!SWIG_IsOK(res3)) {
28752     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadsUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
28753   }
28754   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
28755   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28756   if (!SWIG_IsOK(res4)) {
28757     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadsUni" "', argument " "4"" of type '" "Hex::Vector *""'");
28758   }
28759   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
28760   ecode5 = SWIG_AsVal_double(obj4, &val5);
28761   if (!SWIG_IsOK(ecode5)) {
28762     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadsUni" "', argument " "5"" of type '" "double""'");
28763   }
28764   arg5 = static_cast< double >(val5);
28765   ecode6 = SWIG_AsVal_int(obj5, &val6);
28766   if (!SWIG_IsOK(ecode6)) {
28767     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadsUni" "', argument " "6"" of type '" "int""'");
28768   }
28769   arg6 = static_cast< int >(val6);
28770   result = (Hex::Elements *)(arg1)->revolutionQuadsUni(arg2,arg3,arg4,arg5,arg6);
28771   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28772   return resultobj;
28773 fail:
28774   return NULL;
28775 }
28776
28777
28778 SWIGINTERN PyObject *_wrap_Document_revolutionQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28779   PyObject *resultobj = 0;
28780   Hex::Document *arg1 = (Hex::Document *) 0 ;
28781   Hex::Quads arg2 ;
28782   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
28783   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
28784   Hex::RealVector arg5 ;
28785   void *argp1 = 0 ;
28786   int res1 = 0 ;
28787   void *argp3 = 0 ;
28788   int res3 = 0 ;
28789   void *argp4 = 0 ;
28790   int res4 = 0 ;
28791   PyObject * obj0 = 0 ;
28792   PyObject * obj1 = 0 ;
28793   PyObject * obj2 = 0 ;
28794   PyObject * obj3 = 0 ;
28795   PyObject * obj4 = 0 ;
28796   Hex::Elements *result = 0 ;
28797
28798   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28799   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28800   if (!SWIG_IsOK(res1)) {
28801     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuads" "', argument " "1"" of type '" "Hex::Document *""'");
28802   }
28803   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28804   {
28805     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
28806     int res = swig::asptr(obj1, &ptr);
28807     if (!SWIG_IsOK(res) || !ptr) {
28808       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "2"" of type '" "Hex::Quads""'");
28809     }
28810     arg2 = *ptr;
28811     if (SWIG_IsNewObj(res)) delete ptr;
28812   }
28813   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28814   if (!SWIG_IsOK(res3)) {
28815     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuads" "', argument " "3"" of type '" "Hex::Vertex *""'");
28816   }
28817   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
28818   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28819   if (!SWIG_IsOK(res4)) {
28820     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuads" "', argument " "4"" of type '" "Hex::Vector *""'");
28821   }
28822   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
28823   {
28824     std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
28825     int res = swig::asptr(obj4, &ptr);
28826     if (!SWIG_IsOK(res) || !ptr) {
28827       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "5"" of type '" "Hex::RealVector""'");
28828     }
28829     arg5 = *ptr;
28830     if (SWIG_IsNewObj(res)) delete ptr;
28831   }
28832   result = (Hex::Elements *)(arg1)->revolutionQuads(arg2,arg3,arg4,arg5);
28833   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28834   return resultobj;
28835 fail:
28836   return NULL;
28837 }
28838
28839
28840 SWIGINTERN PyObject *_wrap_Document_joinQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28841   PyObject *resultobj = 0;
28842   Hex::Document *arg1 = (Hex::Document *) 0 ;
28843   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
28844   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
28845   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
28846   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
28847   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
28848   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
28849   int arg8 ;
28850   void *argp1 = 0 ;
28851   int res1 = 0 ;
28852   void *argp2 = 0 ;
28853   int res2 = 0 ;
28854   void *argp3 = 0 ;
28855   int res3 = 0 ;
28856   void *argp4 = 0 ;
28857   int res4 = 0 ;
28858   void *argp5 = 0 ;
28859   int res5 = 0 ;
28860   void *argp6 = 0 ;
28861   int res6 = 0 ;
28862   void *argp7 = 0 ;
28863   int res7 = 0 ;
28864   int val8 ;
28865   int ecode8 = 0 ;
28866   PyObject * obj0 = 0 ;
28867   PyObject * obj1 = 0 ;
28868   PyObject * obj2 = 0 ;
28869   PyObject * obj3 = 0 ;
28870   PyObject * obj4 = 0 ;
28871   PyObject * obj5 = 0 ;
28872   PyObject * obj6 = 0 ;
28873   PyObject * obj7 = 0 ;
28874   Hex::Elements *result = 0 ;
28875
28876   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
28877   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28878   if (!SWIG_IsOK(res1)) {
28879     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
28880   }
28881   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28882   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28883   if (!SWIG_IsOK(res2)) {
28884     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
28885   }
28886   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
28887   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28888   if (!SWIG_IsOK(res3)) {
28889     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadUni" "', argument " "3"" of type '" "Hex::Quad *""'");
28890   }
28891   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
28892   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28893   if (!SWIG_IsOK(res4)) {
28894     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
28895   }
28896   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
28897   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28898   if (!SWIG_IsOK(res5)) {
28899     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
28900   }
28901   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
28902   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28903   if (!SWIG_IsOK(res6)) {
28904     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
28905   }
28906   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
28907   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28908   if (!SWIG_IsOK(res7)) {
28909     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
28910   }
28911   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
28912   ecode8 = SWIG_AsVal_int(obj7, &val8);
28913   if (!SWIG_IsOK(ecode8)) {
28914     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadUni" "', argument " "8"" of type '" "int""'");
28915   }
28916   arg8 = static_cast< int >(val8);
28917   result = (Hex::Elements *)(arg1)->joinQuadUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
28918   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28919   return resultobj;
28920 fail:
28921   return NULL;
28922 }
28923
28924
28925 SWIGINTERN PyObject *_wrap_Document_joinQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28926   PyObject *resultobj = 0;
28927   Hex::Document *arg1 = (Hex::Document *) 0 ;
28928   Hex::Quads arg2 ;
28929   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
28930   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
28931   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
28932   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
28933   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
28934   int arg8 ;
28935   void *argp1 = 0 ;
28936   int res1 = 0 ;
28937   void *argp3 = 0 ;
28938   int res3 = 0 ;
28939   void *argp4 = 0 ;
28940   int res4 = 0 ;
28941   void *argp5 = 0 ;
28942   int res5 = 0 ;
28943   void *argp6 = 0 ;
28944   int res6 = 0 ;
28945   void *argp7 = 0 ;
28946   int res7 = 0 ;
28947   int val8 ;
28948   int ecode8 = 0 ;
28949   PyObject * obj0 = 0 ;
28950   PyObject * obj1 = 0 ;
28951   PyObject * obj2 = 0 ;
28952   PyObject * obj3 = 0 ;
28953   PyObject * obj4 = 0 ;
28954   PyObject * obj5 = 0 ;
28955   PyObject * obj6 = 0 ;
28956   PyObject * obj7 = 0 ;
28957   Hex::Elements *result = 0 ;
28958
28959   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
28960   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28961   if (!SWIG_IsOK(res1)) {
28962     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
28963   }
28964   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28965   {
28966     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
28967     int res = swig::asptr(obj1, &ptr);
28968     if (!SWIG_IsOK(res) || !ptr) {
28969       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
28970     }
28971     arg2 = *ptr;
28972     if (SWIG_IsNewObj(res)) delete ptr;
28973   }
28974   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28975   if (!SWIG_IsOK(res3)) {
28976     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadsUni" "', argument " "3"" of type '" "Hex::Quad *""'");
28977   }
28978   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
28979   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28980   if (!SWIG_IsOK(res4)) {
28981     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadsUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
28982   }
28983   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
28984   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28985   if (!SWIG_IsOK(res5)) {
28986     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadsUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
28987   }
28988   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
28989   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28990   if (!SWIG_IsOK(res6)) {
28991     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadsUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
28992   }
28993   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
28994   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28995   if (!SWIG_IsOK(res7)) {
28996     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadsUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
28997   }
28998   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
28999   ecode8 = SWIG_AsVal_int(obj7, &val8);
29000   if (!SWIG_IsOK(ecode8)) {
29001     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadsUni" "', argument " "8"" of type '" "int""'");
29002   }
29003   arg8 = static_cast< int >(val8);
29004   result = (Hex::Elements *)(arg1)->joinQuadsUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
29005   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29006   return resultobj;
29007 fail:
29008   return NULL;
29009 }
29010
29011
29012 SWIGINTERN PyObject *_wrap_Document_joinQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29013   PyObject *resultobj = 0;
29014   Hex::Document *arg1 = (Hex::Document *) 0 ;
29015   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
29016   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
29017   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
29018   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
29019   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
29020   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
29021   Hex::RealVector *arg8 = 0 ;
29022   void *argp1 = 0 ;
29023   int res1 = 0 ;
29024   void *argp2 = 0 ;
29025   int res2 = 0 ;
29026   void *argp3 = 0 ;
29027   int res3 = 0 ;
29028   void *argp4 = 0 ;
29029   int res4 = 0 ;
29030   void *argp5 = 0 ;
29031   int res5 = 0 ;
29032   void *argp6 = 0 ;
29033   int res6 = 0 ;
29034   void *argp7 = 0 ;
29035   int res7 = 0 ;
29036   void *argp8 = 0 ;
29037   int res8 = 0 ;
29038   PyObject * obj0 = 0 ;
29039   PyObject * obj1 = 0 ;
29040   PyObject * obj2 = 0 ;
29041   PyObject * obj3 = 0 ;
29042   PyObject * obj4 = 0 ;
29043   PyObject * obj5 = 0 ;
29044   PyObject * obj6 = 0 ;
29045   PyObject * obj7 = 0 ;
29046   Hex::Elements *result = 0 ;
29047
29048   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuad",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
29049   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29050   if (!SWIG_IsOK(res1)) {
29051     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuad" "', argument " "1"" of type '" "Hex::Document *""'");
29052   }
29053   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29054   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
29055   if (!SWIG_IsOK(res2)) {
29056     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
29057   }
29058   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
29059   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
29060   if (!SWIG_IsOK(res3)) {
29061     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuad" "', argument " "3"" of type '" "Hex::Quad *""'");
29062   }
29063   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
29064   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29065   if (!SWIG_IsOK(res4)) {
29066     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuad" "', argument " "4"" of type '" "Hex::Vertex *""'");
29067   }
29068   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
29069   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29070   if (!SWIG_IsOK(res5)) {
29071     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuad" "', argument " "5"" of type '" "Hex::Vertex *""'");
29072   }
29073   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
29074   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29075   if (!SWIG_IsOK(res6)) {
29076     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuad" "', argument " "6"" of type '" "Hex::Vertex *""'");
29077   }
29078   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
29079   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29080   if (!SWIG_IsOK(res7)) {
29081     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuad" "', argument " "7"" of type '" "Hex::Vertex *""'");
29082   }
29083   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
29084   res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
29085   if (!SWIG_IsOK(res8)) {
29086     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
29087   }
29088   if (!argp8) {
29089     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
29090   }
29091   arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
29092   result = (Hex::Elements *)(arg1)->joinQuad(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
29093   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29094   return resultobj;
29095 fail:
29096   return NULL;
29097 }
29098
29099
29100 SWIGINTERN PyObject *_wrap_Document_joinQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29101   PyObject *resultobj = 0;
29102   Hex::Document *arg1 = (Hex::Document *) 0 ;
29103   Hex::Quads arg2 ;
29104   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
29105   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
29106   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
29107   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
29108   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
29109   Hex::RealVector *arg8 = 0 ;
29110   void *argp1 = 0 ;
29111   int res1 = 0 ;
29112   void *argp3 = 0 ;
29113   int res3 = 0 ;
29114   void *argp4 = 0 ;
29115   int res4 = 0 ;
29116   void *argp5 = 0 ;
29117   int res5 = 0 ;
29118   void *argp6 = 0 ;
29119   int res6 = 0 ;
29120   void *argp7 = 0 ;
29121   int res7 = 0 ;
29122   void *argp8 = 0 ;
29123   int res8 = 0 ;
29124   PyObject * obj0 = 0 ;
29125   PyObject * obj1 = 0 ;
29126   PyObject * obj2 = 0 ;
29127   PyObject * obj3 = 0 ;
29128   PyObject * obj4 = 0 ;
29129   PyObject * obj5 = 0 ;
29130   PyObject * obj6 = 0 ;
29131   PyObject * obj7 = 0 ;
29132   Hex::Elements *result = 0 ;
29133
29134   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
29135   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29136   if (!SWIG_IsOK(res1)) {
29137     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuads" "', argument " "1"" of type '" "Hex::Document *""'");
29138   }
29139   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29140   {
29141     std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
29142     int res = swig::asptr(obj1, &ptr);
29143     if (!SWIG_IsOK(res) || !ptr) {
29144       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuads" "', argument " "2"" of type '" "Hex::Quads""'");
29145     }
29146     arg2 = *ptr;
29147     if (SWIG_IsNewObj(res)) delete ptr;
29148   }
29149   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
29150   if (!SWIG_IsOK(res3)) {
29151     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
29152   }
29153   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
29154   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29155   if (!SWIG_IsOK(res4)) {
29156     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuads" "', argument " "4"" of type '" "Hex::Vertex *""'");
29157   }
29158   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
29159   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29160   if (!SWIG_IsOK(res5)) {
29161     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuads" "', argument " "5"" of type '" "Hex::Vertex *""'");
29162   }
29163   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
29164   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29165   if (!SWIG_IsOK(res6)) {
29166     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuads" "', argument " "6"" of type '" "Hex::Vertex *""'");
29167   }
29168   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
29169   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29170   if (!SWIG_IsOK(res7)) {
29171     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
29172   }
29173   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
29174   res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
29175   if (!SWIG_IsOK(res8)) {
29176     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
29177   }
29178   if (!argp8) {
29179     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
29180   }
29181   arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
29182   result = (Hex::Elements *)(arg1)->joinQuads(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
29183   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29184   return resultobj;
29185 fail:
29186   return NULL;
29187 }
29188
29189
29190 SWIGINTERN PyObject *_wrap_Document_cutUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29191   PyObject *resultobj = 0;
29192   Hex::Document *arg1 = (Hex::Document *) 0 ;
29193   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
29194   int arg3 ;
29195   void *argp1 = 0 ;
29196   int res1 = 0 ;
29197   void *argp2 = 0 ;
29198   int res2 = 0 ;
29199   int val3 ;
29200   int ecode3 = 0 ;
29201   PyObject * obj0 = 0 ;
29202   PyObject * obj1 = 0 ;
29203   PyObject * obj2 = 0 ;
29204   Hex::Elements *result = 0 ;
29205
29206   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cutUni",&obj0,&obj1,&obj2)) SWIG_fail;
29207   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29208   if (!SWIG_IsOK(res1)) {
29209     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cutUni" "', argument " "1"" of type '" "Hex::Document *""'");
29210   }
29211   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29212   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
29213   if (!SWIG_IsOK(res2)) {
29214     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cutUni" "', argument " "2"" of type '" "Hex::Edge *""'");
29215   }
29216   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
29217   ecode3 = SWIG_AsVal_int(obj2, &val3);
29218   if (!SWIG_IsOK(ecode3)) {
29219     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_cutUni" "', argument " "3"" of type '" "int""'");
29220   }
29221   arg3 = static_cast< int >(val3);
29222   result = (Hex::Elements *)(arg1)->cutUni(arg2,arg3);
29223   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29224   return resultobj;
29225 fail:
29226   return NULL;
29227 }
29228
29229
29230 SWIGINTERN PyObject *_wrap_Document_cut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29231   PyObject *resultobj = 0;
29232   Hex::Document *arg1 = (Hex::Document *) 0 ;
29233   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
29234   Hex::RealVector *arg3 = 0 ;
29235   void *argp1 = 0 ;
29236   int res1 = 0 ;
29237   void *argp2 = 0 ;
29238   int res2 = 0 ;
29239   void *argp3 = 0 ;
29240   int res3 = 0 ;
29241   PyObject * obj0 = 0 ;
29242   PyObject * obj1 = 0 ;
29243   PyObject * obj2 = 0 ;
29244   Hex::Elements *result = 0 ;
29245
29246   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cut",&obj0,&obj1,&obj2)) SWIG_fail;
29247   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29248   if (!SWIG_IsOK(res1)) {
29249     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cut" "', argument " "1"" of type '" "Hex::Document *""'");
29250   }
29251   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29252   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
29253   if (!SWIG_IsOK(res2)) {
29254     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cut" "', argument " "2"" of type '" "Hex::Edge *""'");
29255   }
29256   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
29257   res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
29258   if (!SWIG_IsOK(res3)) {
29259     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
29260   }
29261   if (!argp3) {
29262     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
29263   }
29264   arg3 = reinterpret_cast< Hex::RealVector * >(argp3);
29265   result = (Hex::Elements *)(arg1)->cut(arg2,*arg3);
29266   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29267   return resultobj;
29268 fail:
29269   return NULL;
29270 }
29271
29272
29273 SWIGINTERN PyObject *_wrap_Document_addGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29274   PyObject *resultobj = 0;
29275   Hex::Document *arg1 = (Hex::Document *) 0 ;
29276   cpchar arg2 = (cpchar) 0 ;
29277   Hex::EnumGroup arg3 ;
29278   void *argp1 = 0 ;
29279   int res1 = 0 ;
29280   int res2 ;
29281   char *buf2 = 0 ;
29282   int alloc2 = 0 ;
29283   int val3 ;
29284   int ecode3 = 0 ;
29285   PyObject * obj0 = 0 ;
29286   PyObject * obj1 = 0 ;
29287   PyObject * obj2 = 0 ;
29288   Hex::Group *result = 0 ;
29289
29290   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addGroup",&obj0,&obj1,&obj2)) SWIG_fail;
29291   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29292   if (!SWIG_IsOK(res1)) {
29293     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addGroup" "', argument " "1"" of type '" "Hex::Document *""'");
29294   }
29295   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29296   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29297   if (!SWIG_IsOK(res2)) {
29298     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addGroup" "', argument " "2"" of type '" "cpchar""'");
29299   }
29300   arg2 = reinterpret_cast< cpchar >(buf2);
29301   ecode3 = SWIG_AsVal_int(obj2, &val3);
29302   if (!SWIG_IsOK(ecode3)) {
29303     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addGroup" "', argument " "3"" of type '" "Hex::EnumGroup""'");
29304   }
29305   arg3 = static_cast< Hex::EnumGroup >(val3);
29306   result = (Hex::Group *)(arg1)->addGroup(arg2,arg3);
29307   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
29308   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29309   return resultobj;
29310 fail:
29311   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29312   return NULL;
29313 }
29314
29315
29316 SWIGINTERN PyObject *_wrap_Document_isSaved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29317   PyObject *resultobj = 0;
29318   Hex::Document *arg1 = (Hex::Document *) 0 ;
29319   void *argp1 = 0 ;
29320   int res1 = 0 ;
29321   PyObject * obj0 = 0 ;
29322   bool result;
29323
29324   if (!PyArg_ParseTuple(args,(char *)"O:Document_isSaved",&obj0)) SWIG_fail;
29325   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29326   if (!SWIG_IsOK(res1)) {
29327     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_isSaved" "', argument " "1"" of type '" "Hex::Document *""'");
29328   }
29329   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29330   result = (bool)(arg1)->isSaved();
29331   resultobj = SWIG_From_bool(static_cast< bool >(result));
29332   return resultobj;
29333 fail:
29334   return NULL;
29335 }
29336
29337
29338 SWIGINTERN PyObject *_wrap_Document_appendXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29339   PyObject *resultobj = 0;
29340   Hex::Document *arg1 = (Hex::Document *) 0 ;
29341   pfile arg2 = (pfile) 0 ;
29342   void *argp1 = 0 ;
29343   int res1 = 0 ;
29344   void *argp2 = 0 ;
29345   int res2 = 0 ;
29346   PyObject * obj0 = 0 ;
29347   PyObject * obj1 = 0 ;
29348   int result;
29349
29350   if (!PyArg_ParseTuple(args,(char *)"OO:Document_appendXml",&obj0,&obj1)) SWIG_fail;
29351   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29352   if (!SWIG_IsOK(res1)) {
29353     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_appendXml" "', argument " "1"" of type '" "Hex::Document *""'");
29354   }
29355   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29356   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
29357   if (!SWIG_IsOK(res2)) {
29358     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_appendXml" "', argument " "2"" of type '" "pfile""'");
29359   }
29360   arg2 = reinterpret_cast< pfile >(argp2);
29361   result = (int)(arg1)->appendXml(arg2);
29362   resultobj = SWIG_From_int(static_cast< int >(result));
29363   return resultobj;
29364 fail:
29365   return NULL;
29366 }
29367
29368
29369 SWIGINTERN PyObject *_wrap_Document_getXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29370   PyObject *resultobj = 0;
29371   Hex::Document *arg1 = (Hex::Document *) 0 ;
29372   void *argp1 = 0 ;
29373   int res1 = 0 ;
29374   PyObject * obj0 = 0 ;
29375   cpchar result;
29376
29377   if (!PyArg_ParseTuple(args,(char *)"O:Document_getXml",&obj0)) SWIG_fail;
29378   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29379   if (!SWIG_IsOK(res1)) {
29380     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getXml" "', argument " "1"" of type '" "Hex::Document *""'");
29381   }
29382   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29383   result = (cpchar)(arg1)->getXml();
29384   resultobj = SWIG_FromCharPtr((const char *)result);
29385   return resultobj;
29386 fail:
29387   return NULL;
29388 }
29389
29390
29391 SWIGINTERN PyObject *_wrap_Document_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29392   PyObject *resultobj = 0;
29393   Hex::Document *arg1 = (Hex::Document *) 0 ;
29394   void *argp1 = 0 ;
29395   int res1 = 0 ;
29396   PyObject * obj0 = 0 ;
29397   int result;
29398
29399   if (!PyArg_ParseTuple(args,(char *)"O:Document_getLevel",&obj0)) SWIG_fail;
29400   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29401   if (!SWIG_IsOK(res1)) {
29402     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getLevel" "', argument " "1"" of type '" "Hex::Document *""'");
29403   }
29404   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29405   result = (int)(arg1)->getLevel();
29406   resultobj = SWIG_From_int(static_cast< int >(result));
29407   return resultobj;
29408 fail:
29409   return NULL;
29410 }
29411
29412
29413 SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29414   PyObject *resultobj = 0;
29415   Hex::Document *arg1 = (Hex::Document *) 0 ;
29416   int arg2 ;
29417   void *argp1 = 0 ;
29418   int res1 = 0 ;
29419   int val2 ;
29420   int ecode2 = 0 ;
29421   PyObject * obj0 = 0 ;
29422   PyObject * obj1 = 0 ;
29423   Hex::Vertex *result = 0 ;
29424
29425   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findVertex",&obj0,&obj1)) SWIG_fail;
29426   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29427   if (!SWIG_IsOK(res1)) {
29428     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
29429   }
29430   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29431   ecode2 = SWIG_AsVal_int(obj1, &val2);
29432   if (!SWIG_IsOK(ecode2)) {
29433     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "int""'");
29434   }
29435   arg2 = static_cast< int >(val2);
29436   result = (Hex::Vertex *)(arg1)->findVertex(arg2);
29437   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29438   return resultobj;
29439 fail:
29440   return NULL;
29441 }
29442
29443
29444 SWIGINTERN PyObject *_wrap_Document_findVertex(PyObject *self, PyObject *args) {
29445   int argc;
29446   PyObject *argv[5];
29447   int ii;
29448
29449   if (!PyTuple_Check(args)) SWIG_fail;
29450   argc = (int)PyObject_Length(args);
29451   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
29452     argv[ii] = PyTuple_GET_ITEM(args,ii);
29453   }
29454   if (argc == 2) {
29455     int _v;
29456     void *vptr = 0;
29457     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29458     _v = SWIG_CheckState(res);
29459     if (_v) {
29460       {
29461         int res = SWIG_AsVal_int(argv[1], NULL);
29462         _v = SWIG_CheckState(res);
29463       }
29464       if (_v) {
29465         return _wrap_Document_findVertex__SWIG_1(self, args);
29466       }
29467     }
29468   }
29469   if (argc == 4) {
29470     int _v;
29471     void *vptr = 0;
29472     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29473     _v = SWIG_CheckState(res);
29474     if (_v) {
29475       {
29476         int res = SWIG_AsVal_double(argv[1], NULL);
29477         _v = SWIG_CheckState(res);
29478       }
29479       if (_v) {
29480         {
29481           int res = SWIG_AsVal_double(argv[2], NULL);
29482           _v = SWIG_CheckState(res);
29483         }
29484         if (_v) {
29485           {
29486             int res = SWIG_AsVal_double(argv[3], NULL);
29487             _v = SWIG_CheckState(res);
29488           }
29489           if (_v) {
29490             return _wrap_Document_findVertex__SWIG_0(self, args);
29491           }
29492         }
29493       }
29494     }
29495   }
29496
29497 fail:
29498   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_findVertex'.\n"
29499     "  Possible C/C++ prototypes are:\n"
29500     "    findVertex(Hex::Document *,double,double,double)\n"
29501     "    findVertex(Hex::Document *,int)\n");
29502   return NULL;
29503 }
29504
29505
29506 SWIGINTERN PyObject *_wrap_Document_closeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29507   PyObject *resultobj = 0;
29508   Hex::Document *arg1 = (Hex::Document *) 0 ;
29509   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
29510   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
29511   void *argp1 = 0 ;
29512   int res1 = 0 ;
29513   void *argp2 = 0 ;
29514   int res2 = 0 ;
29515   void *argp3 = 0 ;
29516   int res3 = 0 ;
29517   PyObject * obj0 = 0 ;
29518   PyObject * obj1 = 0 ;
29519   PyObject * obj2 = 0 ;
29520   int result;
29521
29522   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_closeQuads",&obj0,&obj1,&obj2)) SWIG_fail;
29523   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29524   if (!SWIG_IsOK(res1)) {
29525     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_closeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
29526   }
29527   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29528   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
29529   if (!SWIG_IsOK(res2)) {
29530     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_closeQuads" "', argument " "2"" of type '" "Hex::Quad *""'");
29531   }
29532   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
29533   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
29534   if (!SWIG_IsOK(res3)) {
29535     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_closeQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
29536   }
29537   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
29538   result = (int)(arg1)->closeQuads(arg2,arg3);
29539   resultobj = SWIG_From_int(static_cast< int >(result));
29540   return resultobj;
29541 fail:
29542   return NULL;
29543 }
29544
29545
29546 SWIGINTERN PyObject *_wrap_Document_addLaw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29547   PyObject *resultobj = 0;
29548   Hex::Document *arg1 = (Hex::Document *) 0 ;
29549   Hex::Law *arg2 = (Hex::Law *) 0 ;
29550   void *argp1 = 0 ;
29551   int res1 = 0 ;
29552   void *argp2 = 0 ;
29553   int res2 = 0 ;
29554   PyObject * obj0 = 0 ;
29555   PyObject * obj1 = 0 ;
29556   Hex::Law *result = 0 ;
29557
29558   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaw",&obj0,&obj1)) SWIG_fail;
29559   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29560   if (!SWIG_IsOK(res1)) {
29561     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaw" "', argument " "1"" of type '" "Hex::Document *""'");
29562   }
29563   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29564   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
29565   if (!SWIG_IsOK(res2)) {
29566     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addLaw" "', argument " "2"" of type '" "Hex::Law *""'");
29567   }
29568   arg2 = reinterpret_cast< Hex::Law * >(argp2);
29569   result = (Hex::Law *)(arg1)->addLaw(arg2);
29570   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
29571   return resultobj;
29572 fail:
29573   return NULL;
29574 }
29575
29576
29577 SWIGINTERN PyObject *_wrap_Document_addLaw(PyObject *self, PyObject *args) {
29578   int argc;
29579   PyObject *argv[4];
29580   int ii;
29581
29582   if (!PyTuple_Check(args)) SWIG_fail;
29583   argc = (int)PyObject_Length(args);
29584   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
29585     argv[ii] = PyTuple_GET_ITEM(args,ii);
29586   }
29587   if (argc == 2) {
29588     int _v;
29589     void *vptr = 0;
29590     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29591     _v = SWIG_CheckState(res);
29592     if (_v) {
29593       void *vptr = 0;
29594       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Law, 0);
29595       _v = SWIG_CheckState(res);
29596       if (_v) {
29597         return _wrap_Document_addLaw__SWIG_1(self, args);
29598       }
29599     }
29600   }
29601   if (argc == 3) {
29602     int _v;
29603     void *vptr = 0;
29604     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29605     _v = SWIG_CheckState(res);
29606     if (_v) {
29607       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
29608       _v = SWIG_CheckState(res);
29609       if (_v) {
29610         {
29611           int res = SWIG_AsVal_int(argv[2], NULL);
29612           _v = SWIG_CheckState(res);
29613         }
29614         if (_v) {
29615           return _wrap_Document_addLaw__SWIG_0(self, args);
29616         }
29617       }
29618     }
29619   }
29620
29621 fail:
29622   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addLaw'.\n"
29623     "  Possible C/C++ prototypes are:\n"
29624     "    addLaw(Hex::Document *,char const *,int)\n"
29625     "    addLaw(Hex::Document *,Hex::Law *)\n");
29626   return NULL;
29627 }
29628
29629
29630 SWIGINTERN PyObject *_wrap_Document_checkAssociations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29631   PyObject *resultobj = 0;
29632   Hex::Document *arg1 = (Hex::Document *) 0 ;
29633   void *argp1 = 0 ;
29634   int res1 = 0 ;
29635   PyObject * obj0 = 0 ;
29636   int result;
29637
29638   if (!PyArg_ParseTuple(args,(char *)"O:Document_checkAssociations",&obj0)) SWIG_fail;
29639   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29640   if (!SWIG_IsOK(res1)) {
29641     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_checkAssociations" "', argument " "1"" of type '" "Hex::Document *""'");
29642   }
29643   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29644   result = (int)(arg1)->checkAssociations();
29645   resultobj = SWIG_From_int(static_cast< int >(result));
29646   return resultobj;
29647 fail:
29648   return NULL;
29649 }
29650
29651
29652 SWIGINTERN PyObject *_wrap_Document_addShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29653   PyObject *resultobj = 0;
29654   Hex::Document *arg1 = (Hex::Document *) 0 ;
29655   long arg2 ;
29656   char *arg3 = (char *) 0 ;
29657   void *argp1 = 0 ;
29658   int res1 = 0 ;
29659   long val2 ;
29660   int ecode2 = 0 ;
29661   int res3 ;
29662   char *buf3 = 0 ;
29663   int alloc3 = 0 ;
29664   PyObject * obj0 = 0 ;
29665   PyObject * obj1 = 0 ;
29666   PyObject * obj2 = 0 ;
29667   Hex::NewShape *result = 0 ;
29668
29669   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addShape",&obj0,&obj1,&obj2)) SWIG_fail;
29670   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29671   if (!SWIG_IsOK(res1)) {
29672     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addShape" "', argument " "1"" of type '" "Hex::Document *""'");
29673   }
29674   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29675   ecode2 = SWIG_AsVal_long(obj1, &val2);
29676   if (!SWIG_IsOK(ecode2)) {
29677     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addShape" "', argument " "2"" of type '" "long""'");
29678   }
29679   arg2 = static_cast< long >(val2);
29680   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
29681   if (!SWIG_IsOK(res3)) {
29682     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addShape" "', argument " "3"" of type '" "char const *""'");
29683   }
29684   arg3 = reinterpret_cast< char * >(buf3);
29685   result = (Hex::NewShape *)(arg1)->addShape(arg2,(char const *)arg3);
29686   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 |  0 );
29687   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
29688   return resultobj;
29689 fail:
29690   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
29691   return NULL;
29692 }
29693
29694
29695 SWIGINTERN PyObject *_wrap_delete_Document(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29696   PyObject *resultobj = 0;
29697   Hex::Document *arg1 = (Hex::Document *) 0 ;
29698   void *argp1 = 0 ;
29699   int res1 = 0 ;
29700   PyObject * obj0 = 0 ;
29701
29702   if (!PyArg_ParseTuple(args,(char *)"O:delete_Document",&obj0)) SWIG_fail;
29703   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, SWIG_POINTER_DISOWN |  0 );
29704   if (!SWIG_IsOK(res1)) {
29705     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Document" "', argument " "1"" of type '" "Hex::Document *""'");
29706   }
29707   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29708   delete arg1;
29709   resultobj = SWIG_Py_Void();
29710   return resultobj;
29711 fail:
29712   return NULL;
29713 }
29714
29715
29716 SWIGINTERN PyObject *Document_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29717   PyObject *obj;
29718   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
29719   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Document, SWIG_NewClientData(obj));
29720   return SWIG_Py_Void();
29721 }
29722
29723 SWIGINTERN PyObject *_wrap_Propagation_getEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29724   PyObject *resultobj = 0;
29725   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
29726   void *argp1 = 0 ;
29727   int res1 = 0 ;
29728   PyObject * obj0 = 0 ;
29729   Hex::Edges *result = 0 ;
29730
29731   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getEdges",&obj0)) SWIG_fail;
29732   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
29733   if (!SWIG_IsOK(res1)) {
29734     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getEdges" "', argument " "1"" of type '" "Hex::Propagation *""'");
29735   }
29736   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
29737   result = (Hex::Edges *) &(arg1)->getEdges();
29738   resultobj = swig::from(static_cast< std::vector<Hex::Edge*,std::allocator< Hex::Edge * > > >(*result));
29739   return resultobj;
29740 fail:
29741   return NULL;
29742 }
29743
29744
29745 SWIGINTERN PyObject *_wrap_Propagation_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29746   PyObject *resultobj = 0;
29747   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
29748   void *argp1 = 0 ;
29749   int res1 = 0 ;
29750   PyObject * obj0 = 0 ;
29751   Hex::Law *result = 0 ;
29752
29753   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getLaw",&obj0)) SWIG_fail;
29754   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
29755   if (!SWIG_IsOK(res1)) {
29756     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
29757   }
29758   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
29759   result = (Hex::Law *)(arg1)->getLaw();
29760   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
29761   return resultobj;
29762 fail:
29763   return NULL;
29764 }
29765
29766
29767 SWIGINTERN PyObject *_wrap_Propagation_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29768   PyObject *resultobj = 0;
29769   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
29770   void *argp1 = 0 ;
29771   int res1 = 0 ;
29772   PyObject * obj0 = 0 ;
29773   bool result;
29774
29775   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getWay",&obj0)) SWIG_fail;
29776   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
29777   if (!SWIG_IsOK(res1)) {
29778     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
29779   }
29780   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
29781   result = (bool)(arg1)->getWay();
29782   resultobj = SWIG_From_bool(static_cast< bool >(result));
29783   return resultobj;
29784 fail:
29785   return NULL;
29786 }
29787
29788
29789 SWIGINTERN PyObject *_wrap_Propagation_setWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29790   PyObject *resultobj = 0;
29791   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
29792   bool arg2 ;
29793   void *argp1 = 0 ;
29794   int res1 = 0 ;
29795   bool val2 ;
29796   int ecode2 = 0 ;
29797   PyObject * obj0 = 0 ;
29798   PyObject * obj1 = 0 ;
29799
29800   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setWay",&obj0,&obj1)) SWIG_fail;
29801   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
29802   if (!SWIG_IsOK(res1)) {
29803     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
29804   }
29805   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
29806   ecode2 = SWIG_AsVal_bool(obj1, &val2);
29807   if (!SWIG_IsOK(ecode2)) {
29808     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Propagation_setWay" "', argument " "2"" of type '" "bool""'");
29809   }
29810   arg2 = static_cast< bool >(val2);
29811   (arg1)->setWay(arg2);
29812   resultobj = SWIG_Py_Void();
29813   return resultobj;
29814 fail:
29815   return NULL;
29816 }
29817
29818
29819 SWIGINTERN PyObject *_wrap_Propagation_setLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29820   PyObject *resultobj = 0;
29821   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
29822   Hex::Law *arg2 = (Hex::Law *) 0 ;
29823   void *argp1 = 0 ;
29824   int res1 = 0 ;
29825   void *argp2 = 0 ;
29826   int res2 = 0 ;
29827   PyObject * obj0 = 0 ;
29828   PyObject * obj1 = 0 ;
29829   int result;
29830
29831   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setLaw",&obj0,&obj1)) SWIG_fail;
29832   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
29833   if (!SWIG_IsOK(res1)) {
29834     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
29835   }
29836   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
29837   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
29838   if (!SWIG_IsOK(res2)) {
29839     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_setLaw" "', argument " "2"" of type '" "Hex::Law *""'");
29840   }
29841   arg2 = reinterpret_cast< Hex::Law * >(argp2);
29842   result = (int)(arg1)->setLaw(arg2);
29843   resultobj = SWIG_From_int(static_cast< int >(result));
29844   return resultobj;
29845 fail:
29846   return NULL;
29847 }
29848
29849
29850 SWIGINTERN PyObject *_wrap_new_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29851   PyObject *resultobj = 0;
29852   Hex::Document *arg1 = (Hex::Document *) 0 ;
29853   void *argp1 = 0 ;
29854   int res1 = 0 ;
29855   PyObject * obj0 = 0 ;
29856   Hex::Propagation *result = 0 ;
29857
29858   if (!PyArg_ParseTuple(args,(char *)"O:new_Propagation",&obj0)) SWIG_fail;
29859   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29860   if (!SWIG_IsOK(res1)) {
29861     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Propagation" "', argument " "1"" of type '" "Hex::Document *""'");
29862   }
29863   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29864   result = (Hex::Propagation *)new Hex::Propagation(arg1);
29865   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_NEW |  0 );
29866   return resultobj;
29867 fail:
29868   return NULL;
29869 }
29870
29871
29872 SWIGINTERN PyObject *_wrap_Propagation_saveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29873   PyObject *resultobj = 0;
29874   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
29875   Hex::XmlWriter *arg2 = (Hex::XmlWriter *) 0 ;
29876   void *argp1 = 0 ;
29877   int res1 = 0 ;
29878   void *argp2 = 0 ;
29879   int res2 = 0 ;
29880   PyObject * obj0 = 0 ;
29881   PyObject * obj1 = 0 ;
29882
29883   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_saveXml",&obj0,&obj1)) SWIG_fail;
29884   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
29885   if (!SWIG_IsOK(res1)) {
29886     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_saveXml" "', argument " "1"" of type '" "Hex::Propagation *""'");
29887   }
29888   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
29889   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__XmlWriter, 0 |  0 );
29890   if (!SWIG_IsOK(res2)) {
29891     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_saveXml" "', argument " "2"" of type '" "Hex::XmlWriter *""'");
29892   }
29893   arg2 = reinterpret_cast< Hex::XmlWriter * >(argp2);
29894   (arg1)->saveXml(arg2);
29895   resultobj = SWIG_Py_Void();
29896   return resultobj;
29897 fail:
29898   return NULL;
29899 }
29900
29901
29902 SWIGINTERN PyObject *_wrap_Propagation_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29903   PyObject *resultobj = 0;
29904   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
29905   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
29906   void *argp1 = 0 ;
29907   int res1 = 0 ;
29908   void *argp2 = 0 ;
29909   int res2 = 0 ;
29910   PyObject * obj0 = 0 ;
29911   PyObject * obj1 = 0 ;
29912
29913   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_addEdge",&obj0,&obj1)) SWIG_fail;
29914   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
29915   if (!SWIG_IsOK(res1)) {
29916     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_addEdge" "', argument " "1"" of type '" "Hex::Propagation *""'");
29917   }
29918   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
29919   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
29920   if (!SWIG_IsOK(res2)) {
29921     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_addEdge" "', argument " "2"" of type '" "Hex::Edge *""'");
29922   }
29923   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
29924   (arg1)->addEdge(arg2);
29925   resultobj = SWIG_Py_Void();
29926   return resultobj;
29927 fail:
29928   return NULL;
29929 }
29930
29931
29932 SWIGINTERN PyObject *_wrap_Propagation_majLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29933   PyObject *resultobj = 0;
29934   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
29935   void *argp1 = 0 ;
29936   int res1 = 0 ;
29937   PyObject * obj0 = 0 ;
29938
29939   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_majLaw",&obj0)) SWIG_fail;
29940   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
29941   if (!SWIG_IsOK(res1)) {
29942     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_majLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
29943   }
29944   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
29945   (arg1)->majLaw();
29946   resultobj = SWIG_Py_Void();
29947   return resultobj;
29948 fail:
29949   return NULL;
29950 }
29951
29952
29953 SWIGINTERN PyObject *_wrap_delete_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29954   PyObject *resultobj = 0;
29955   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
29956   void *argp1 = 0 ;
29957   int res1 = 0 ;
29958   PyObject * obj0 = 0 ;
29959
29960   if (!PyArg_ParseTuple(args,(char *)"O:delete_Propagation",&obj0)) SWIG_fail;
29961   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_DISOWN |  0 );
29962   if (!SWIG_IsOK(res1)) {
29963     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Propagation" "', argument " "1"" of type '" "Hex::Propagation *""'");
29964   }
29965   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
29966   delete arg1;
29967   resultobj = SWIG_Py_Void();
29968   return resultobj;
29969 fail:
29970   return NULL;
29971 }
29972
29973
29974 SWIGINTERN PyObject *Propagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29975   PyObject *obj;
29976   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
29977   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Propagation, SWIG_NewClientData(obj));
29978   return SWIG_Py_Void();
29979 }
29980
29981 SWIGINTERN PyObject *_wrap_hex_instance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29982   PyObject *resultobj = 0;
29983   Hex::Hex *result = 0 ;
29984
29985   if (!PyArg_ParseTuple(args,(char *)":hex_instance")) SWIG_fail;
29986   result = (Hex::Hex *)Hex::hex_instance();
29987   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 |  0 );
29988   return resultobj;
29989 fail:
29990   return NULL;
29991 }
29992
29993
29994 SWIGINTERN PyObject *_wrap_Hex_getInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29995   PyObject *resultobj = 0;
29996   Hex::Hex *result = 0 ;
29997
29998   if (!PyArg_ParseTuple(args,(char *)":Hex_getInstance")) SWIG_fail;
29999   result = (Hex::Hex *)Hex::Hex::getInstance();
30000   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 |  0 );
30001   return resultobj;
30002 fail:
30003   return NULL;
30004 }
30005
30006
30007 SWIGINTERN PyObject *_wrap_Hex_countDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30008   PyObject *resultobj = 0;
30009   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30010   void *argp1 = 0 ;
30011   int res1 = 0 ;
30012   PyObject * obj0 = 0 ;
30013   int result;
30014
30015   if (!PyArg_ParseTuple(args,(char *)"O:Hex_countDocument",&obj0)) SWIG_fail;
30016   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
30017   if (!SWIG_IsOK(res1)) {
30018     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_countDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
30019   }
30020   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30021   result = (int)(arg1)->countDocument();
30022   resultobj = SWIG_From_int(static_cast< int >(result));
30023   return resultobj;
30024 fail:
30025   return NULL;
30026 }
30027
30028
30029 SWIGINTERN PyObject *_wrap_Hex_getDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30030   PyObject *resultobj = 0;
30031   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30032   int arg2 ;
30033   void *argp1 = 0 ;
30034   int res1 = 0 ;
30035   int val2 ;
30036   int ecode2 = 0 ;
30037   PyObject * obj0 = 0 ;
30038   PyObject * obj1 = 0 ;
30039   Hex::Document *result = 0 ;
30040
30041   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getDocument",&obj0,&obj1)) SWIG_fail;
30042   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
30043   if (!SWIG_IsOK(res1)) {
30044     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
30045   }
30046   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30047   ecode2 = SWIG_AsVal_int(obj1, &val2);
30048   if (!SWIG_IsOK(ecode2)) {
30049     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getDocument" "', argument " "2"" of type '" "int""'");
30050   }
30051   arg2 = static_cast< int >(val2);
30052   result = (Hex::Document *)(arg1)->getDocument(arg2);
30053   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
30054   return resultobj;
30055 fail:
30056   return NULL;
30057 }
30058
30059
30060 SWIGINTERN PyObject *_wrap_Hex_removeDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30061   PyObject *resultobj = 0;
30062   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30063   Hex::Document *arg2 = (Hex::Document *) 0 ;
30064   void *argp1 = 0 ;
30065   int res1 = 0 ;
30066   void *argp2 = 0 ;
30067   int res2 = 0 ;
30068   PyObject * obj0 = 0 ;
30069   PyObject * obj1 = 0 ;
30070
30071   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_removeDocument",&obj0,&obj1)) SWIG_fail;
30072   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
30073   if (!SWIG_IsOK(res1)) {
30074     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_removeDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
30075   }
30076   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30077   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Document, 0 |  0 );
30078   if (!SWIG_IsOK(res2)) {
30079     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_removeDocument" "', argument " "2"" of type '" "Hex::Document *""'");
30080   }
30081   arg2 = reinterpret_cast< Hex::Document * >(argp2);
30082   (arg1)->removeDocument(arg2);
30083   resultobj = SWIG_Py_Void();
30084   return resultobj;
30085 fail:
30086   return NULL;
30087 }
30088
30089
30090 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30091   PyObject *resultobj = 0;
30092   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30093   cpchar arg2 = (cpchar) 0 ;
30094   void *argp1 = 0 ;
30095   int res1 = 0 ;
30096   int res2 ;
30097   char *buf2 = 0 ;
30098   int alloc2 = 0 ;
30099   PyObject * obj0 = 0 ;
30100   PyObject * obj1 = 0 ;
30101   Hex::Document *result = 0 ;
30102
30103   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_addDocument",&obj0,&obj1)) SWIG_fail;
30104   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
30105   if (!SWIG_IsOK(res1)) {
30106     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
30107   }
30108   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30109   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30110   if (!SWIG_IsOK(res2)) {
30111     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_addDocument" "', argument " "2"" of type '" "cpchar""'");
30112   }
30113   arg2 = reinterpret_cast< cpchar >(buf2);
30114   result = (Hex::Document *)(arg1)->addDocument(arg2);
30115   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
30116   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30117   return resultobj;
30118 fail:
30119   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30120   return NULL;
30121 }
30122
30123
30124 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30125   PyObject *resultobj = 0;
30126   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30127   void *argp1 = 0 ;
30128   int res1 = 0 ;
30129   PyObject * obj0 = 0 ;
30130   Hex::Document *result = 0 ;
30131
30132   if (!PyArg_ParseTuple(args,(char *)"O:Hex_addDocument",&obj0)) SWIG_fail;
30133   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
30134   if (!SWIG_IsOK(res1)) {
30135     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
30136   }
30137   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30138   result = (Hex::Document *)(arg1)->addDocument();
30139   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
30140   return resultobj;
30141 fail:
30142   return NULL;
30143 }
30144
30145
30146 SWIGINTERN PyObject *_wrap_Hex_addDocument(PyObject *self, PyObject *args) {
30147   int argc;
30148   PyObject *argv[3];
30149   int ii;
30150
30151   if (!PyTuple_Check(args)) SWIG_fail;
30152   argc = (int)PyObject_Length(args);
30153   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30154     argv[ii] = PyTuple_GET_ITEM(args,ii);
30155   }
30156   if (argc == 1) {
30157     int _v;
30158     void *vptr = 0;
30159     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
30160     _v = SWIG_CheckState(res);
30161     if (_v) {
30162       return _wrap_Hex_addDocument__SWIG_1(self, args);
30163     }
30164   }
30165   if (argc == 2) {
30166     int _v;
30167     void *vptr = 0;
30168     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
30169     _v = SWIG_CheckState(res);
30170     if (_v) {
30171       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
30172       _v = SWIG_CheckState(res);
30173       if (_v) {
30174         return _wrap_Hex_addDocument__SWIG_0(self, args);
30175       }
30176     }
30177   }
30178
30179 fail:
30180   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Hex_addDocument'.\n"
30181     "  Possible C/C++ prototypes are:\n"
30182     "    addDocument(Hex::Hex *,cpchar)\n"
30183     "    addDocument(Hex::Hex *)\n");
30184   return NULL;
30185 }
30186
30187
30188 SWIGINTERN PyObject *_wrap_Hex_loadDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30189   PyObject *resultobj = 0;
30190   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30191   cpchar arg2 = (cpchar) 0 ;
30192   void *argp1 = 0 ;
30193   int res1 = 0 ;
30194   int res2 ;
30195   char *buf2 = 0 ;
30196   int alloc2 = 0 ;
30197   PyObject * obj0 = 0 ;
30198   PyObject * obj1 = 0 ;
30199   Hex::Document *result = 0 ;
30200
30201   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_loadDocument",&obj0,&obj1)) SWIG_fail;
30202   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
30203   if (!SWIG_IsOK(res1)) {
30204     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_loadDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
30205   }
30206   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30207   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30208   if (!SWIG_IsOK(res2)) {
30209     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_loadDocument" "', argument " "2"" of type '" "cpchar""'");
30210   }
30211   arg2 = reinterpret_cast< cpchar >(buf2);
30212   result = (Hex::Document *)(arg1)->loadDocument(arg2);
30213   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
30214   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30215   return resultobj;
30216 fail:
30217   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30218   return NULL;
30219 }
30220
30221
30222 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30223   PyObject *resultobj = 0;
30224   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30225   cpchar arg2 = (cpchar) 0 ;
30226   void *argp1 = 0 ;
30227   int res1 = 0 ;
30228   int res2 ;
30229   char *buf2 = 0 ;
30230   int alloc2 = 0 ;
30231   PyObject * obj0 = 0 ;
30232   PyObject * obj1 = 0 ;
30233   Hex::Document *result = 0 ;
30234
30235   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
30236   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
30237   if (!SWIG_IsOK(res1)) {
30238     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
30239   }
30240   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30241   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30242   if (!SWIG_IsOK(res2)) {
30243     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "cpchar""'");
30244   }
30245   arg2 = reinterpret_cast< cpchar >(buf2);
30246   result = (Hex::Document *)(arg1)->findDocument(arg2);
30247   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
30248   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30249   return resultobj;
30250 fail:
30251   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30252   return NULL;
30253 }
30254
30255
30256 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30257   PyObject *resultobj = 0;
30258   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30259   string *arg2 = 0 ;
30260   void *argp1 = 0 ;
30261   int res1 = 0 ;
30262   void *argp2 = 0 ;
30263   int res2 = 0 ;
30264   PyObject * obj0 = 0 ;
30265   PyObject * obj1 = 0 ;
30266   Hex::Document *result = 0 ;
30267
30268   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
30269   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
30270   if (!SWIG_IsOK(res1)) {
30271     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
30272   }
30273   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30274   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string,  0  | 0);
30275   if (!SWIG_IsOK(res2)) {
30276     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
30277   }
30278   if (!argp2) {
30279     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
30280   }
30281   arg2 = reinterpret_cast< string * >(argp2);
30282   result = (Hex::Document *)(arg1)->findDocument((string const &)*arg2);
30283   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
30284   return resultobj;
30285 fail:
30286   return NULL;
30287 }
30288
30289
30290 SWIGINTERN PyObject *_wrap_Hex_findDocument(PyObject *self, PyObject *args) {
30291   int argc;
30292   PyObject *argv[3];
30293   int ii;
30294
30295   if (!PyTuple_Check(args)) SWIG_fail;
30296   argc = (int)PyObject_Length(args);
30297   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30298     argv[ii] = PyTuple_GET_ITEM(args,ii);
30299   }
30300   if (argc == 2) {
30301     int _v;
30302     void *vptr = 0;
30303     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
30304     _v = SWIG_CheckState(res);
30305     if (_v) {
30306       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_string, 0);
30307       _v = SWIG_CheckState(res);
30308       if (_v) {
30309         return _wrap_Hex_findDocument__SWIG_1(self, args);
30310       }
30311     }
30312   }
30313   if (argc == 2) {
30314     int _v;
30315     void *vptr = 0;
30316     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
30317     _v = SWIG_CheckState(res);
30318     if (_v) {
30319       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
30320       _v = SWIG_CheckState(res);
30321       if (_v) {
30322         return _wrap_Hex_findDocument__SWIG_0(self, args);
30323       }
30324     }
30325   }
30326
30327 fail:
30328   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Hex_findDocument'.\n"
30329     "  Possible C/C++ prototypes are:\n"
30330     "    findDocument(Hex::Hex *,cpchar)\n"
30331     "    findDocument(Hex::Hex *,string const &)\n");
30332   return NULL;
30333 }
30334
30335
30336 SWIGINTERN PyObject *_wrap_Hex_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30337   PyObject *resultobj = 0;
30338   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30339   void *argp1 = 0 ;
30340   int res1 = 0 ;
30341   PyObject * obj0 = 0 ;
30342
30343   if (!PyArg_ParseTuple(args,(char *)"O:Hex_what",&obj0)) SWIG_fail;
30344   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
30345   if (!SWIG_IsOK(res1)) {
30346     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_what" "', argument " "1"" of type '" "Hex::Hex *""'");
30347   }
30348   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30349   (arg1)->what();
30350   resultobj = SWIG_Py_Void();
30351   return resultobj;
30352 fail:
30353   return NULL;
30354 }
30355
30356
30357 SWIGINTERN PyObject *_wrap_Hex_sizeofMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30358   PyObject *resultobj = 0;
30359   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30360   void *argp1 = 0 ;
30361   int res1 = 0 ;
30362   PyObject * obj0 = 0 ;
30363   int result;
30364
30365   if (!PyArg_ParseTuple(args,(char *)"O:Hex_sizeofMessage",&obj0)) SWIG_fail;
30366   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
30367   if (!SWIG_IsOK(res1)) {
30368     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_sizeofMessage" "', argument " "1"" of type '" "Hex::Hex *""'");
30369   }
30370   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30371   result = (int)(arg1)->sizeofMessage();
30372   resultobj = SWIG_From_int(static_cast< int >(result));
30373   return resultobj;
30374 fail:
30375   return NULL;
30376 }
30377
30378
30379 SWIGINTERN PyObject *_wrap_Hex_getMessageLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30380   PyObject *resultobj = 0;
30381   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30382   int arg2 ;
30383   void *argp1 = 0 ;
30384   int res1 = 0 ;
30385   int val2 ;
30386   int ecode2 = 0 ;
30387   PyObject * obj0 = 0 ;
30388   PyObject * obj1 = 0 ;
30389   cpchar result;
30390
30391   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getMessageLine",&obj0,&obj1)) SWIG_fail;
30392   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
30393   if (!SWIG_IsOK(res1)) {
30394     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getMessageLine" "', argument " "1"" of type '" "Hex::Hex *""'");
30395   }
30396   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30397   ecode2 = SWIG_AsVal_int(obj1, &val2);
30398   if (!SWIG_IsOK(ecode2)) {
30399     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getMessageLine" "', argument " "2"" of type '" "int""'");
30400   }
30401   arg2 = static_cast< int >(val2);
30402   result = (cpchar)(arg1)->getMessageLine(arg2);
30403   resultobj = SWIG_FromCharPtr((const char *)result);
30404   return resultobj;
30405 fail:
30406   return NULL;
30407 }
30408
30409
30410 SWIGINTERN PyObject *_wrap_new_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30411   PyObject *resultobj = 0;
30412   Hex::Hex *result = 0 ;
30413
30414   if (!PyArg_ParseTuple(args,(char *)":new_Hex")) SWIG_fail;
30415   result = (Hex::Hex *)new Hex::Hex();
30416   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, SWIG_POINTER_NEW |  0 );
30417   return resultobj;
30418 fail:
30419   return NULL;
30420 }
30421
30422
30423 SWIGINTERN PyObject *_wrap_delete_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30424   PyObject *resultobj = 0;
30425   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
30426   void *argp1 = 0 ;
30427   int res1 = 0 ;
30428   PyObject * obj0 = 0 ;
30429
30430   if (!PyArg_ParseTuple(args,(char *)"O:delete_Hex",&obj0)) SWIG_fail;
30431   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, SWIG_POINTER_DISOWN |  0 );
30432   if (!SWIG_IsOK(res1)) {
30433     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hex" "', argument " "1"" of type '" "Hex::Hex *""'");
30434   }
30435   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
30436   delete arg1;
30437   resultobj = SWIG_Py_Void();
30438   return resultobj;
30439 fail:
30440   return NULL;
30441 }
30442
30443
30444 SWIGINTERN PyObject *Hex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30445   PyObject *obj;
30446   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
30447   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hex, SWIG_NewClientData(obj));
30448   return SWIG_Py_Void();
30449 }
30450
30451 SWIGINTERN PyObject *_wrap_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30452   PyObject *resultobj = 0;
30453
30454   if (!PyArg_ParseTuple(args,(char *)":what")) SWIG_fail;
30455   Hex::what();
30456   resultobj = SWIG_Py_Void();
30457   return resultobj;
30458 fail:
30459   return NULL;
30460 }
30461
30462
30463 SWIGINTERN PyObject *_wrap_Elements_getHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30464   PyObject *resultobj = 0;
30465   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30466   int arg2 ;
30467   void *argp1 = 0 ;
30468   int res1 = 0 ;
30469   int val2 ;
30470   int ecode2 = 0 ;
30471   PyObject * obj0 = 0 ;
30472   PyObject * obj1 = 0 ;
30473   Hex::Hexa *result = 0 ;
30474
30475   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getHexa",&obj0,&obj1)) SWIG_fail;
30476   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30477   if (!SWIG_IsOK(res1)) {
30478     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
30479   }
30480   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30481   ecode2 = SWIG_AsVal_int(obj1, &val2);
30482   if (!SWIG_IsOK(ecode2)) {
30483     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexa" "', argument " "2"" of type '" "int""'");
30484   }
30485   arg2 = static_cast< int >(val2);
30486   result = (Hex::Hexa *)(arg1)->getHexa(arg2);
30487   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
30488   return resultobj;
30489 fail:
30490   return NULL;
30491 }
30492
30493
30494 SWIGINTERN PyObject *_wrap_Elements_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30495   PyObject *resultobj = 0;
30496   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30497   int arg2 ;
30498   void *argp1 = 0 ;
30499   int res1 = 0 ;
30500   int val2 ;
30501   int ecode2 = 0 ;
30502   PyObject * obj0 = 0 ;
30503   PyObject * obj1 = 0 ;
30504   Hex::Quad *result = 0 ;
30505
30506   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getQuad",&obj0,&obj1)) SWIG_fail;
30507   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30508   if (!SWIG_IsOK(res1)) {
30509     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
30510   }
30511   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30512   ecode2 = SWIG_AsVal_int(obj1, &val2);
30513   if (!SWIG_IsOK(ecode2)) {
30514     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuad" "', argument " "2"" of type '" "int""'");
30515   }
30516   arg2 = static_cast< int >(val2);
30517   result = (Hex::Quad *)(arg1)->getQuad(arg2);
30518   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
30519   return resultobj;
30520 fail:
30521   return NULL;
30522 }
30523
30524
30525 SWIGINTERN PyObject *_wrap_Elements_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30526   PyObject *resultobj = 0;
30527   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30528   int arg2 ;
30529   void *argp1 = 0 ;
30530   int res1 = 0 ;
30531   int val2 ;
30532   int ecode2 = 0 ;
30533   PyObject * obj0 = 0 ;
30534   PyObject * obj1 = 0 ;
30535   Hex::Edge *result = 0 ;
30536
30537   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getEdge",&obj0,&obj1)) SWIG_fail;
30538   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30539   if (!SWIG_IsOK(res1)) {
30540     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
30541   }
30542   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30543   ecode2 = SWIG_AsVal_int(obj1, &val2);
30544   if (!SWIG_IsOK(ecode2)) {
30545     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdge" "', argument " "2"" of type '" "int""'");
30546   }
30547   arg2 = static_cast< int >(val2);
30548   result = (Hex::Edge *)(arg1)->getEdge(arg2);
30549   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
30550   return resultobj;
30551 fail:
30552   return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_Elements_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30557   PyObject *resultobj = 0;
30558   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30559   int arg2 ;
30560   void *argp1 = 0 ;
30561   int res1 = 0 ;
30562   int val2 ;
30563   int ecode2 = 0 ;
30564   PyObject * obj0 = 0 ;
30565   PyObject * obj1 = 0 ;
30566   Hex::Vertex *result = 0 ;
30567
30568   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getVertex",&obj0,&obj1)) SWIG_fail;
30569   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30570   if (!SWIG_IsOK(res1)) {
30571     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
30572   }
30573   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30574   ecode2 = SWIG_AsVal_int(obj1, &val2);
30575   if (!SWIG_IsOK(ecode2)) {
30576     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertex" "', argument " "2"" of type '" "int""'");
30577   }
30578   arg2 = static_cast< int >(val2);
30579   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
30580   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30581   return resultobj;
30582 fail:
30583   return NULL;
30584 }
30585
30586
30587 SWIGINTERN PyObject *_wrap_Elements_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30588   PyObject *resultobj = 0;
30589   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30590   int arg2 ;
30591   int arg3 ;
30592   int arg4 ;
30593   void *argp1 = 0 ;
30594   int res1 = 0 ;
30595   int val2 ;
30596   int ecode2 = 0 ;
30597   int val3 ;
30598   int ecode3 = 0 ;
30599   int val4 ;
30600   int ecode4 = 0 ;
30601   PyObject * obj0 = 0 ;
30602   PyObject * obj1 = 0 ;
30603   PyObject * obj2 = 0 ;
30604   PyObject * obj3 = 0 ;
30605   Hex::Hexa *result = 0 ;
30606
30607   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getHexaIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30608   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30609   if (!SWIG_IsOK(res1)) {
30610     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexaIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
30611   }
30612   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30613   ecode2 = SWIG_AsVal_int(obj1, &val2);
30614   if (!SWIG_IsOK(ecode2)) {
30615     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexaIJK" "', argument " "2"" of type '" "int""'");
30616   }
30617   arg2 = static_cast< int >(val2);
30618   ecode3 = SWIG_AsVal_int(obj2, &val3);
30619   if (!SWIG_IsOK(ecode3)) {
30620     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getHexaIJK" "', argument " "3"" of type '" "int""'");
30621   }
30622   arg3 = static_cast< int >(val3);
30623   ecode4 = SWIG_AsVal_int(obj3, &val4);
30624   if (!SWIG_IsOK(ecode4)) {
30625     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getHexaIJK" "', argument " "4"" of type '" "int""'");
30626   }
30627   arg4 = static_cast< int >(val4);
30628   result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4);
30629   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
30630   return resultobj;
30631 fail:
30632   return NULL;
30633 }
30634
30635
30636 SWIGINTERN PyObject *_wrap_Elements_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30637   PyObject *resultobj = 0;
30638   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30639   int arg2 ;
30640   int arg3 ;
30641   int arg4 ;
30642   void *argp1 = 0 ;
30643   int res1 = 0 ;
30644   int val2 ;
30645   int ecode2 = 0 ;
30646   int val3 ;
30647   int ecode3 = 0 ;
30648   int val4 ;
30649   int ecode4 = 0 ;
30650   PyObject * obj0 = 0 ;
30651   PyObject * obj1 = 0 ;
30652   PyObject * obj2 = 0 ;
30653   PyObject * obj3 = 0 ;
30654   Hex::Quad *result = 0 ;
30655
30656   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30657   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30658   if (!SWIG_IsOK(res1)) {
30659     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIJ" "', argument " "1"" of type '" "Hex::Elements *""'");
30660   }
30661   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30662   ecode2 = SWIG_AsVal_int(obj1, &val2);
30663   if (!SWIG_IsOK(ecode2)) {
30664     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIJ" "', argument " "2"" of type '" "int""'");
30665   }
30666   arg2 = static_cast< int >(val2);
30667   ecode3 = SWIG_AsVal_int(obj2, &val3);
30668   if (!SWIG_IsOK(ecode3)) {
30669     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIJ" "', argument " "3"" of type '" "int""'");
30670   }
30671   arg3 = static_cast< int >(val3);
30672   ecode4 = SWIG_AsVal_int(obj3, &val4);
30673   if (!SWIG_IsOK(ecode4)) {
30674     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIJ" "', argument " "4"" of type '" "int""'");
30675   }
30676   arg4 = static_cast< int >(val4);
30677   result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4);
30678   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
30679   return resultobj;
30680 fail:
30681   return NULL;
30682 }
30683
30684
30685 SWIGINTERN PyObject *_wrap_Elements_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30686   PyObject *resultobj = 0;
30687   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30688   int arg2 ;
30689   int arg3 ;
30690   int arg4 ;
30691   void *argp1 = 0 ;
30692   int res1 = 0 ;
30693   int val2 ;
30694   int ecode2 = 0 ;
30695   int val3 ;
30696   int ecode3 = 0 ;
30697   int val4 ;
30698   int ecode4 = 0 ;
30699   PyObject * obj0 = 0 ;
30700   PyObject * obj1 = 0 ;
30701   PyObject * obj2 = 0 ;
30702   PyObject * obj3 = 0 ;
30703   Hex::Quad *result = 0 ;
30704
30705   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30706   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30707   if (!SWIG_IsOK(res1)) {
30708     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadJK" "', argument " "1"" of type '" "Hex::Elements *""'");
30709   }
30710   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30711   ecode2 = SWIG_AsVal_int(obj1, &val2);
30712   if (!SWIG_IsOK(ecode2)) {
30713     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadJK" "', argument " "2"" of type '" "int""'");
30714   }
30715   arg2 = static_cast< int >(val2);
30716   ecode3 = SWIG_AsVal_int(obj2, &val3);
30717   if (!SWIG_IsOK(ecode3)) {
30718     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadJK" "', argument " "3"" of type '" "int""'");
30719   }
30720   arg3 = static_cast< int >(val3);
30721   ecode4 = SWIG_AsVal_int(obj3, &val4);
30722   if (!SWIG_IsOK(ecode4)) {
30723     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadJK" "', argument " "4"" of type '" "int""'");
30724   }
30725   arg4 = static_cast< int >(val4);
30726   result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4);
30727   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
30728   return resultobj;
30729 fail:
30730   return NULL;
30731 }
30732
30733
30734 SWIGINTERN PyObject *_wrap_Elements_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30735   PyObject *resultobj = 0;
30736   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30737   int arg2 ;
30738   int arg3 ;
30739   int arg4 ;
30740   void *argp1 = 0 ;
30741   int res1 = 0 ;
30742   int val2 ;
30743   int ecode2 = 0 ;
30744   int val3 ;
30745   int ecode3 = 0 ;
30746   int val4 ;
30747   int ecode4 = 0 ;
30748   PyObject * obj0 = 0 ;
30749   PyObject * obj1 = 0 ;
30750   PyObject * obj2 = 0 ;
30751   PyObject * obj3 = 0 ;
30752   Hex::Quad *result = 0 ;
30753
30754   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30755   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30756   if (!SWIG_IsOK(res1)) {
30757     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIK" "', argument " "1"" of type '" "Hex::Elements *""'");
30758   }
30759   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30760   ecode2 = SWIG_AsVal_int(obj1, &val2);
30761   if (!SWIG_IsOK(ecode2)) {
30762     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIK" "', argument " "2"" of type '" "int""'");
30763   }
30764   arg2 = static_cast< int >(val2);
30765   ecode3 = SWIG_AsVal_int(obj2, &val3);
30766   if (!SWIG_IsOK(ecode3)) {
30767     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIK" "', argument " "3"" of type '" "int""'");
30768   }
30769   arg3 = static_cast< int >(val3);
30770   ecode4 = SWIG_AsVal_int(obj3, &val4);
30771   if (!SWIG_IsOK(ecode4)) {
30772     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIK" "', argument " "4"" of type '" "int""'");
30773   }
30774   arg4 = static_cast< int >(val4);
30775   result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4);
30776   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
30777   return resultobj;
30778 fail:
30779   return NULL;
30780 }
30781
30782
30783 SWIGINTERN PyObject *_wrap_Elements_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30784   PyObject *resultobj = 0;
30785   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30786   int arg2 ;
30787   int arg3 ;
30788   int arg4 ;
30789   void *argp1 = 0 ;
30790   int res1 = 0 ;
30791   int val2 ;
30792   int ecode2 = 0 ;
30793   int val3 ;
30794   int ecode3 = 0 ;
30795   int val4 ;
30796   int ecode4 = 0 ;
30797   PyObject * obj0 = 0 ;
30798   PyObject * obj1 = 0 ;
30799   PyObject * obj2 = 0 ;
30800   PyObject * obj3 = 0 ;
30801   Hex::Edge *result = 0 ;
30802
30803   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeI",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30804   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30805   if (!SWIG_IsOK(res1)) {
30806     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeI" "', argument " "1"" of type '" "Hex::Elements *""'");
30807   }
30808   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30809   ecode2 = SWIG_AsVal_int(obj1, &val2);
30810   if (!SWIG_IsOK(ecode2)) {
30811     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeI" "', argument " "2"" of type '" "int""'");
30812   }
30813   arg2 = static_cast< int >(val2);
30814   ecode3 = SWIG_AsVal_int(obj2, &val3);
30815   if (!SWIG_IsOK(ecode3)) {
30816     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeI" "', argument " "3"" of type '" "int""'");
30817   }
30818   arg3 = static_cast< int >(val3);
30819   ecode4 = SWIG_AsVal_int(obj3, &val4);
30820   if (!SWIG_IsOK(ecode4)) {
30821     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeI" "', argument " "4"" of type '" "int""'");
30822   }
30823   arg4 = static_cast< int >(val4);
30824   result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4);
30825   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
30826   return resultobj;
30827 fail:
30828   return NULL;
30829 }
30830
30831
30832 SWIGINTERN PyObject *_wrap_Elements_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30833   PyObject *resultobj = 0;
30834   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30835   int arg2 ;
30836   int arg3 ;
30837   int arg4 ;
30838   void *argp1 = 0 ;
30839   int res1 = 0 ;
30840   int val2 ;
30841   int ecode2 = 0 ;
30842   int val3 ;
30843   int ecode3 = 0 ;
30844   int val4 ;
30845   int ecode4 = 0 ;
30846   PyObject * obj0 = 0 ;
30847   PyObject * obj1 = 0 ;
30848   PyObject * obj2 = 0 ;
30849   PyObject * obj3 = 0 ;
30850   Hex::Edge *result = 0 ;
30851
30852   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30853   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30854   if (!SWIG_IsOK(res1)) {
30855     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeJ" "', argument " "1"" of type '" "Hex::Elements *""'");
30856   }
30857   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30858   ecode2 = SWIG_AsVal_int(obj1, &val2);
30859   if (!SWIG_IsOK(ecode2)) {
30860     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeJ" "', argument " "2"" of type '" "int""'");
30861   }
30862   arg2 = static_cast< int >(val2);
30863   ecode3 = SWIG_AsVal_int(obj2, &val3);
30864   if (!SWIG_IsOK(ecode3)) {
30865     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeJ" "', argument " "3"" of type '" "int""'");
30866   }
30867   arg3 = static_cast< int >(val3);
30868   ecode4 = SWIG_AsVal_int(obj3, &val4);
30869   if (!SWIG_IsOK(ecode4)) {
30870     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeJ" "', argument " "4"" of type '" "int""'");
30871   }
30872   arg4 = static_cast< int >(val4);
30873   result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4);
30874   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
30875   return resultobj;
30876 fail:
30877   return NULL;
30878 }
30879
30880
30881 SWIGINTERN PyObject *_wrap_Elements_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30882   PyObject *resultobj = 0;
30883   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30884   int arg2 ;
30885   int arg3 ;
30886   int arg4 ;
30887   void *argp1 = 0 ;
30888   int res1 = 0 ;
30889   int val2 ;
30890   int ecode2 = 0 ;
30891   int val3 ;
30892   int ecode3 = 0 ;
30893   int val4 ;
30894   int ecode4 = 0 ;
30895   PyObject * obj0 = 0 ;
30896   PyObject * obj1 = 0 ;
30897   PyObject * obj2 = 0 ;
30898   PyObject * obj3 = 0 ;
30899   Hex::Edge *result = 0 ;
30900
30901   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30902   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30903   if (!SWIG_IsOK(res1)) {
30904     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeK" "', argument " "1"" of type '" "Hex::Elements *""'");
30905   }
30906   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30907   ecode2 = SWIG_AsVal_int(obj1, &val2);
30908   if (!SWIG_IsOK(ecode2)) {
30909     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeK" "', argument " "2"" of type '" "int""'");
30910   }
30911   arg2 = static_cast< int >(val2);
30912   ecode3 = SWIG_AsVal_int(obj2, &val3);
30913   if (!SWIG_IsOK(ecode3)) {
30914     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeK" "', argument " "3"" of type '" "int""'");
30915   }
30916   arg3 = static_cast< int >(val3);
30917   ecode4 = SWIG_AsVal_int(obj3, &val4);
30918   if (!SWIG_IsOK(ecode4)) {
30919     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeK" "', argument " "4"" of type '" "int""'");
30920   }
30921   arg4 = static_cast< int >(val4);
30922   result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4);
30923   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
30924   return resultobj;
30925 fail:
30926   return NULL;
30927 }
30928
30929
30930 SWIGINTERN PyObject *_wrap_Elements_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30931   PyObject *resultobj = 0;
30932   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30933   int arg2 ;
30934   int arg3 ;
30935   int arg4 ;
30936   void *argp1 = 0 ;
30937   int res1 = 0 ;
30938   int val2 ;
30939   int ecode2 = 0 ;
30940   int val3 ;
30941   int ecode3 = 0 ;
30942   int val4 ;
30943   int ecode4 = 0 ;
30944   PyObject * obj0 = 0 ;
30945   PyObject * obj1 = 0 ;
30946   PyObject * obj2 = 0 ;
30947   PyObject * obj3 = 0 ;
30948   Hex::Vertex *result = 0 ;
30949
30950   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getVertexIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30951   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30952   if (!SWIG_IsOK(res1)) {
30953     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertexIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
30954   }
30955   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30956   ecode2 = SWIG_AsVal_int(obj1, &val2);
30957   if (!SWIG_IsOK(ecode2)) {
30958     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertexIJK" "', argument " "2"" of type '" "int""'");
30959   }
30960   arg2 = static_cast< int >(val2);
30961   ecode3 = SWIG_AsVal_int(obj2, &val3);
30962   if (!SWIG_IsOK(ecode3)) {
30963     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getVertexIJK" "', argument " "3"" of type '" "int""'");
30964   }
30965   arg3 = static_cast< int >(val3);
30966   ecode4 = SWIG_AsVal_int(obj3, &val4);
30967   if (!SWIG_IsOK(ecode4)) {
30968     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getVertexIJK" "', argument " "4"" of type '" "int""'");
30969   }
30970   arg4 = static_cast< int >(val4);
30971   result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4);
30972   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30973   return resultobj;
30974 fail:
30975   return NULL;
30976 }
30977
30978
30979 SWIGINTERN PyObject *_wrap_Elements_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30980   PyObject *resultobj = 0;
30981   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30982   void *argp1 = 0 ;
30983   int res1 = 0 ;
30984   PyObject * obj0 = 0 ;
30985   int result;
30986
30987   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countHexa",&obj0)) SWIG_fail;
30988   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30989   if (!SWIG_IsOK(res1)) {
30990     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
30991   }
30992   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30993   result = (int)(arg1)->countHexa();
30994   resultobj = SWIG_From_int(static_cast< int >(result));
30995   return resultobj;
30996 fail:
30997   return NULL;
30998 }
30999
31000
31001 SWIGINTERN PyObject *_wrap_Elements_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31002   PyObject *resultobj = 0;
31003   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
31004   void *argp1 = 0 ;
31005   int res1 = 0 ;
31006   PyObject * obj0 = 0 ;
31007   int result;
31008
31009   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countQuad",&obj0)) SWIG_fail;
31010   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
31011   if (!SWIG_IsOK(res1)) {
31012     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
31013   }
31014   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
31015   result = (int)(arg1)->countQuad();
31016   resultobj = SWIG_From_int(static_cast< int >(result));
31017   return resultobj;
31018 fail:
31019   return NULL;
31020 }
31021
31022
31023 SWIGINTERN PyObject *_wrap_Elements_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31024   PyObject *resultobj = 0;
31025   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
31026   void *argp1 = 0 ;
31027   int res1 = 0 ;
31028   PyObject * obj0 = 0 ;
31029   int result;
31030
31031   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countEdge",&obj0)) SWIG_fail;
31032   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
31033   if (!SWIG_IsOK(res1)) {
31034     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
31035   }
31036   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
31037   result = (int)(arg1)->countEdge();
31038   resultobj = SWIG_From_int(static_cast< int >(result));
31039   return resultobj;
31040 fail:
31041   return NULL;
31042 }
31043
31044
31045 SWIGINTERN PyObject *_wrap_Elements_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31046   PyObject *resultobj = 0;
31047   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
31048   void *argp1 = 0 ;
31049   int res1 = 0 ;
31050   PyObject * obj0 = 0 ;
31051   int result;
31052
31053   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countVertex",&obj0)) SWIG_fail;
31054   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
31055   if (!SWIG_IsOK(res1)) {
31056     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
31057   }
31058   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
31059   result = (int)(arg1)->countVertex();
31060   resultobj = SWIG_From_int(static_cast< int >(result));
31061   return resultobj;
31062 fail:
31063   return NULL;
31064 }
31065
31066
31067 SWIGINTERN PyObject *_wrap_Elements_nearestVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31068   PyObject *resultobj = 0;
31069   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
31070   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
31071   void *argp1 = 0 ;
31072   int res1 = 0 ;
31073   void *argp2 = 0 ;
31074   int res2 = 0 ;
31075   PyObject * obj0 = 0 ;
31076   PyObject * obj1 = 0 ;
31077   Hex::Vertex *result = 0 ;
31078
31079   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_nearestVertex",&obj0,&obj1)) SWIG_fail;
31080   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
31081   if (!SWIG_IsOK(res1)) {
31082     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_nearestVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
31083   }
31084   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
31085   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31086   if (!SWIG_IsOK(res2)) {
31087     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_nearestVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
31088   }
31089   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
31090   result = (Hex::Vertex *)(arg1)->nearestVertex(arg2);
31091   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31092   return resultobj;
31093 fail:
31094   return NULL;
31095 }
31096
31097
31098 SWIGINTERN PyObject *_wrap_Elements_findVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31099   PyObject *resultobj = 0;
31100   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
31101   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
31102   void *argp1 = 0 ;
31103   int res1 = 0 ;
31104   void *argp2 = 0 ;
31105   int res2 = 0 ;
31106   PyObject * obj0 = 0 ;
31107   PyObject * obj1 = 0 ;
31108   int result;
31109
31110   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_findVertex",&obj0,&obj1)) SWIG_fail;
31111   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
31112   if (!SWIG_IsOK(res1)) {
31113     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_findVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
31114   }
31115   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
31116   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31117   if (!SWIG_IsOK(res2)) {
31118     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_findVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
31119   }
31120   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
31121   result = (int)(arg1)->findVertex(arg2);
31122   resultobj = SWIG_From_int(static_cast< int >(result));
31123   return resultobj;
31124 fail:
31125   return NULL;
31126 }
31127
31128
31129 SWIGINTERN PyObject *_wrap_Elements_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31130   PyObject *resultobj = 0;
31131   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
31132   void *argp1 = 0 ;
31133   int res1 = 0 ;
31134   PyObject * obj0 = 0 ;
31135
31136   if (!PyArg_ParseTuple(args,(char *)"O:Elements_clearAssociation",&obj0)) SWIG_fail;
31137   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
31138   if (!SWIG_IsOK(res1)) {
31139     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_clearAssociation" "', argument " "1"" of type '" "Hex::Elements *""'");
31140   }
31141   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
31142   (arg1)->clearAssociation();
31143   resultobj = SWIG_Py_Void();
31144   return resultobj;
31145 fail:
31146   return NULL;
31147 }
31148
31149
31150 SWIGINTERN PyObject *_wrap_Elements_saveVtk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31151   PyObject *resultobj = 0;
31152   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
31153   cpchar arg2 = (cpchar) 0 ;
31154   void *argp1 = 0 ;
31155   int res1 = 0 ;
31156   int res2 ;
31157   char *buf2 = 0 ;
31158   int alloc2 = 0 ;
31159   PyObject * obj0 = 0 ;
31160   PyObject * obj1 = 0 ;
31161   int result;
31162
31163   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_saveVtk",&obj0,&obj1)) SWIG_fail;
31164   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
31165   if (!SWIG_IsOK(res1)) {
31166     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_saveVtk" "', argument " "1"" of type '" "Hex::Elements *""'");
31167   }
31168   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
31169   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
31170   if (!SWIG_IsOK(res2)) {
31171     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_saveVtk" "', argument " "2"" of type '" "cpchar""'");
31172   }
31173   arg2 = reinterpret_cast< cpchar >(buf2);
31174   result = (int)(arg1)->saveVtk(arg2);
31175   resultobj = SWIG_From_int(static_cast< int >(result));
31176   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31177   return resultobj;
31178 fail:
31179   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31180   return NULL;
31181 }
31182
31183
31184 SWIGINTERN PyObject *_wrap_new_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31185   PyObject *resultobj = 0;
31186   Hex::Document *arg1 = (Hex::Document *) 0 ;
31187   void *argp1 = 0 ;
31188   int res1 = 0 ;
31189   PyObject * obj0 = 0 ;
31190   Hex::Elements *result = 0 ;
31191
31192   if (!PyArg_ParseTuple(args,(char *)"O:new_Elements",&obj0)) SWIG_fail;
31193   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31194   if (!SWIG_IsOK(res1)) {
31195     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Elements" "', argument " "1"" of type '" "Hex::Document *""'");
31196   }
31197   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31198   result = (Hex::Elements *)new Hex::Elements(arg1);
31199   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, SWIG_POINTER_NEW |  0 );
31200   return resultobj;
31201 fail:
31202   return NULL;
31203 }
31204
31205
31206 SWIGINTERN PyObject *_wrap_delete_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31207   PyObject *resultobj = 0;
31208   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
31209   void *argp1 = 0 ;
31210   int res1 = 0 ;
31211   PyObject * obj0 = 0 ;
31212
31213   if (!PyArg_ParseTuple(args,(char *)"O:delete_Elements",&obj0)) SWIG_fail;
31214   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, SWIG_POINTER_DISOWN |  0 );
31215   if (!SWIG_IsOK(res1)) {
31216     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Elements" "', argument " "1"" of type '" "Hex::Elements *""'");
31217   }
31218   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
31219   delete arg1;
31220   resultobj = SWIG_Py_Void();
31221   return resultobj;
31222 fail:
31223   return NULL;
31224 }
31225
31226
31227 SWIGINTERN PyObject *Elements_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31228   PyObject *obj;
31229   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
31230   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Elements, SWIG_NewClientData(obj));
31231   return SWIG_Py_Void();
31232 }
31233
31234 SWIGINTERN PyObject *_wrap_new_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31235   PyObject *resultobj = 0;
31236   Hex::Document *arg1 = (Hex::Document *) 0 ;
31237   void *argp1 = 0 ;
31238   int res1 = 0 ;
31239   PyObject * obj0 = 0 ;
31240   Hex::BiCylinder *result = 0 ;
31241
31242   if (!PyArg_ParseTuple(args,(char *)"O:new_BiCylinder",&obj0)) SWIG_fail;
31243   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31244   if (!SWIG_IsOK(res1)) {
31245     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BiCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
31246   }
31247   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31248   result = (Hex::BiCylinder *)new Hex::BiCylinder(arg1);
31249   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_NEW |  0 );
31250   return resultobj;
31251 fail:
31252   return NULL;
31253 }
31254
31255
31256 SWIGINTERN PyObject *_wrap_BiCylinder_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31257   PyObject *resultobj = 0;
31258   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
31259   int arg2 ;
31260   int arg3 ;
31261   int arg4 ;
31262   int arg5 ;
31263   void *argp1 = 0 ;
31264   int res1 = 0 ;
31265   int val2 ;
31266   int ecode2 = 0 ;
31267   int val3 ;
31268   int ecode3 = 0 ;
31269   int val4 ;
31270   int ecode4 = 0 ;
31271   int val5 ;
31272   int ecode5 = 0 ;
31273   PyObject * obj0 = 0 ;
31274   PyObject * obj1 = 0 ;
31275   PyObject * obj2 = 0 ;
31276   PyObject * obj3 = 0 ;
31277   PyObject * obj4 = 0 ;
31278   Hex::Hexa *result = 0 ;
31279
31280   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getHexaIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31281   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
31282   if (!SWIG_IsOK(res1)) {
31283     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getHexaIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
31284   }
31285   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
31286   ecode2 = SWIG_AsVal_int(obj1, &val2);
31287   if (!SWIG_IsOK(ecode2)) {
31288     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getHexaIJK" "', argument " "2"" of type '" "int""'");
31289   }
31290   arg2 = static_cast< int >(val2);
31291   ecode3 = SWIG_AsVal_int(obj2, &val3);
31292   if (!SWIG_IsOK(ecode3)) {
31293     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getHexaIJK" "', argument " "3"" of type '" "int""'");
31294   }
31295   arg3 = static_cast< int >(val3);
31296   ecode4 = SWIG_AsVal_int(obj3, &val4);
31297   if (!SWIG_IsOK(ecode4)) {
31298     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getHexaIJK" "', argument " "4"" of type '" "int""'");
31299   }
31300   arg4 = static_cast< int >(val4);
31301   ecode5 = SWIG_AsVal_int(obj4, &val5);
31302   if (!SWIG_IsOK(ecode5)) {
31303     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getHexaIJK" "', argument " "5"" of type '" "int""'");
31304   }
31305   arg5 = static_cast< int >(val5);
31306   result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4,arg5);
31307   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
31308   return resultobj;
31309 fail:
31310   return NULL;
31311 }
31312
31313
31314 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31315   PyObject *resultobj = 0;
31316   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
31317   int arg2 ;
31318   int arg3 ;
31319   int arg4 ;
31320   int arg5 ;
31321   void *argp1 = 0 ;
31322   int res1 = 0 ;
31323   int val2 ;
31324   int ecode2 = 0 ;
31325   int val3 ;
31326   int ecode3 = 0 ;
31327   int val4 ;
31328   int ecode4 = 0 ;
31329   int val5 ;
31330   int ecode5 = 0 ;
31331   PyObject * obj0 = 0 ;
31332   PyObject * obj1 = 0 ;
31333   PyObject * obj2 = 0 ;
31334   PyObject * obj3 = 0 ;
31335   PyObject * obj4 = 0 ;
31336   Hex::Quad *result = 0 ;
31337
31338   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31339   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
31340   if (!SWIG_IsOK(res1)) {
31341     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
31342   }
31343   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
31344   ecode2 = SWIG_AsVal_int(obj1, &val2);
31345   if (!SWIG_IsOK(ecode2)) {
31346     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIJ" "', argument " "2"" of type '" "int""'");
31347   }
31348   arg2 = static_cast< int >(val2);
31349   ecode3 = SWIG_AsVal_int(obj2, &val3);
31350   if (!SWIG_IsOK(ecode3)) {
31351     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIJ" "', argument " "3"" of type '" "int""'");
31352   }
31353   arg3 = static_cast< int >(val3);
31354   ecode4 = SWIG_AsVal_int(obj3, &val4);
31355   if (!SWIG_IsOK(ecode4)) {
31356     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIJ" "', argument " "4"" of type '" "int""'");
31357   }
31358   arg4 = static_cast< int >(val4);
31359   ecode5 = SWIG_AsVal_int(obj4, &val5);
31360   if (!SWIG_IsOK(ecode5)) {
31361     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIJ" "', argument " "5"" of type '" "int""'");
31362   }
31363   arg5 = static_cast< int >(val5);
31364   result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4,arg5);
31365   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
31366   return resultobj;
31367 fail:
31368   return NULL;
31369 }
31370
31371
31372 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31373   PyObject *resultobj = 0;
31374   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
31375   int arg2 ;
31376   int arg3 ;
31377   int arg4 ;
31378   int arg5 ;
31379   void *argp1 = 0 ;
31380   int res1 = 0 ;
31381   int val2 ;
31382   int ecode2 = 0 ;
31383   int val3 ;
31384   int ecode3 = 0 ;
31385   int val4 ;
31386   int ecode4 = 0 ;
31387   int val5 ;
31388   int ecode5 = 0 ;
31389   PyObject * obj0 = 0 ;
31390   PyObject * obj1 = 0 ;
31391   PyObject * obj2 = 0 ;
31392   PyObject * obj3 = 0 ;
31393   PyObject * obj4 = 0 ;
31394   Hex::Quad *result = 0 ;
31395
31396   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31397   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
31398   if (!SWIG_IsOK(res1)) {
31399     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
31400   }
31401   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
31402   ecode2 = SWIG_AsVal_int(obj1, &val2);
31403   if (!SWIG_IsOK(ecode2)) {
31404     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadJK" "', argument " "2"" of type '" "int""'");
31405   }
31406   arg2 = static_cast< int >(val2);
31407   ecode3 = SWIG_AsVal_int(obj2, &val3);
31408   if (!SWIG_IsOK(ecode3)) {
31409     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadJK" "', argument " "3"" of type '" "int""'");
31410   }
31411   arg3 = static_cast< int >(val3);
31412   ecode4 = SWIG_AsVal_int(obj3, &val4);
31413   if (!SWIG_IsOK(ecode4)) {
31414     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadJK" "', argument " "4"" of type '" "int""'");
31415   }
31416   arg4 = static_cast< int >(val4);
31417   ecode5 = SWIG_AsVal_int(obj4, &val5);
31418   if (!SWIG_IsOK(ecode5)) {
31419     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadJK" "', argument " "5"" of type '" "int""'");
31420   }
31421   arg5 = static_cast< int >(val5);
31422   result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4,arg5);
31423   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
31424   return resultobj;
31425 fail:
31426   return NULL;
31427 }
31428
31429
31430 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31431   PyObject *resultobj = 0;
31432   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
31433   int arg2 ;
31434   int arg3 ;
31435   int arg4 ;
31436   int arg5 ;
31437   void *argp1 = 0 ;
31438   int res1 = 0 ;
31439   int val2 ;
31440   int ecode2 = 0 ;
31441   int val3 ;
31442   int ecode3 = 0 ;
31443   int val4 ;
31444   int ecode4 = 0 ;
31445   int val5 ;
31446   int ecode5 = 0 ;
31447   PyObject * obj0 = 0 ;
31448   PyObject * obj1 = 0 ;
31449   PyObject * obj2 = 0 ;
31450   PyObject * obj3 = 0 ;
31451   PyObject * obj4 = 0 ;
31452   Hex::Quad *result = 0 ;
31453
31454   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31455   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
31456   if (!SWIG_IsOK(res1)) {
31457     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
31458   }
31459   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
31460   ecode2 = SWIG_AsVal_int(obj1, &val2);
31461   if (!SWIG_IsOK(ecode2)) {
31462     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIK" "', argument " "2"" of type '" "int""'");
31463   }
31464   arg2 = static_cast< int >(val2);
31465   ecode3 = SWIG_AsVal_int(obj2, &val3);
31466   if (!SWIG_IsOK(ecode3)) {
31467     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIK" "', argument " "3"" of type '" "int""'");
31468   }
31469   arg3 = static_cast< int >(val3);
31470   ecode4 = SWIG_AsVal_int(obj3, &val4);
31471   if (!SWIG_IsOK(ecode4)) {
31472     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIK" "', argument " "4"" of type '" "int""'");
31473   }
31474   arg4 = static_cast< int >(val4);
31475   ecode5 = SWIG_AsVal_int(obj4, &val5);
31476   if (!SWIG_IsOK(ecode5)) {
31477     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIK" "', argument " "5"" of type '" "int""'");
31478   }
31479   arg5 = static_cast< int >(val5);
31480   result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4,arg5);
31481   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
31482   return resultobj;
31483 fail:
31484   return NULL;
31485 }
31486
31487
31488 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31489   PyObject *resultobj = 0;
31490   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
31491   int arg2 ;
31492   int arg3 ;
31493   int arg4 ;
31494   int arg5 ;
31495   void *argp1 = 0 ;
31496   int res1 = 0 ;
31497   int val2 ;
31498   int ecode2 = 0 ;
31499   int val3 ;
31500   int ecode3 = 0 ;
31501   int val4 ;
31502   int ecode4 = 0 ;
31503   int val5 ;
31504   int ecode5 = 0 ;
31505   PyObject * obj0 = 0 ;
31506   PyObject * obj1 = 0 ;
31507   PyObject * obj2 = 0 ;
31508   PyObject * obj3 = 0 ;
31509   PyObject * obj4 = 0 ;
31510   Hex::Edge *result = 0 ;
31511
31512   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeI",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31513   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
31514   if (!SWIG_IsOK(res1)) {
31515     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeI" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
31516   }
31517   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
31518   ecode2 = SWIG_AsVal_int(obj1, &val2);
31519   if (!SWIG_IsOK(ecode2)) {
31520     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeI" "', argument " "2"" of type '" "int""'");
31521   }
31522   arg2 = static_cast< int >(val2);
31523   ecode3 = SWIG_AsVal_int(obj2, &val3);
31524   if (!SWIG_IsOK(ecode3)) {
31525     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeI" "', argument " "3"" of type '" "int""'");
31526   }
31527   arg3 = static_cast< int >(val3);
31528   ecode4 = SWIG_AsVal_int(obj3, &val4);
31529   if (!SWIG_IsOK(ecode4)) {
31530     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeI" "', argument " "4"" of type '" "int""'");
31531   }
31532   arg4 = static_cast< int >(val4);
31533   ecode5 = SWIG_AsVal_int(obj4, &val5);
31534   if (!SWIG_IsOK(ecode5)) {
31535     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeI" "', argument " "5"" of type '" "int""'");
31536   }
31537   arg5 = static_cast< int >(val5);
31538   result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4,arg5);
31539   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
31540   return resultobj;
31541 fail:
31542   return NULL;
31543 }
31544
31545
31546 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31547   PyObject *resultobj = 0;
31548   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
31549   int arg2 ;
31550   int arg3 ;
31551   int arg4 ;
31552   int arg5 ;
31553   void *argp1 = 0 ;
31554   int res1 = 0 ;
31555   int val2 ;
31556   int ecode2 = 0 ;
31557   int val3 ;
31558   int ecode3 = 0 ;
31559   int val4 ;
31560   int ecode4 = 0 ;
31561   int val5 ;
31562   int ecode5 = 0 ;
31563   PyObject * obj0 = 0 ;
31564   PyObject * obj1 = 0 ;
31565   PyObject * obj2 = 0 ;
31566   PyObject * obj3 = 0 ;
31567   PyObject * obj4 = 0 ;
31568   Hex::Edge *result = 0 ;
31569
31570   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31571   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
31572   if (!SWIG_IsOK(res1)) {
31573     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
31574   }
31575   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
31576   ecode2 = SWIG_AsVal_int(obj1, &val2);
31577   if (!SWIG_IsOK(ecode2)) {
31578     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeJ" "', argument " "2"" of type '" "int""'");
31579   }
31580   arg2 = static_cast< int >(val2);
31581   ecode3 = SWIG_AsVal_int(obj2, &val3);
31582   if (!SWIG_IsOK(ecode3)) {
31583     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeJ" "', argument " "3"" of type '" "int""'");
31584   }
31585   arg3 = static_cast< int >(val3);
31586   ecode4 = SWIG_AsVal_int(obj3, &val4);
31587   if (!SWIG_IsOK(ecode4)) {
31588     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeJ" "', argument " "4"" of type '" "int""'");
31589   }
31590   arg4 = static_cast< int >(val4);
31591   ecode5 = SWIG_AsVal_int(obj4, &val5);
31592   if (!SWIG_IsOK(ecode5)) {
31593     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeJ" "', argument " "5"" of type '" "int""'");
31594   }
31595   arg5 = static_cast< int >(val5);
31596   result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4,arg5);
31597   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
31598   return resultobj;
31599 fail:
31600   return NULL;
31601 }
31602
31603
31604 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31605   PyObject *resultobj = 0;
31606   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
31607   int arg2 ;
31608   int arg3 ;
31609   int arg4 ;
31610   int arg5 ;
31611   void *argp1 = 0 ;
31612   int res1 = 0 ;
31613   int val2 ;
31614   int ecode2 = 0 ;
31615   int val3 ;
31616   int ecode3 = 0 ;
31617   int val4 ;
31618   int ecode4 = 0 ;
31619   int val5 ;
31620   int ecode5 = 0 ;
31621   PyObject * obj0 = 0 ;
31622   PyObject * obj1 = 0 ;
31623   PyObject * obj2 = 0 ;
31624   PyObject * obj3 = 0 ;
31625   PyObject * obj4 = 0 ;
31626   Hex::Edge *result = 0 ;
31627
31628   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31629   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
31630   if (!SWIG_IsOK(res1)) {
31631     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
31632   }
31633   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
31634   ecode2 = SWIG_AsVal_int(obj1, &val2);
31635   if (!SWIG_IsOK(ecode2)) {
31636     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeK" "', argument " "2"" of type '" "int""'");
31637   }
31638   arg2 = static_cast< int >(val2);
31639   ecode3 = SWIG_AsVal_int(obj2, &val3);
31640   if (!SWIG_IsOK(ecode3)) {
31641     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeK" "', argument " "3"" of type '" "int""'");
31642   }
31643   arg3 = static_cast< int >(val3);
31644   ecode4 = SWIG_AsVal_int(obj3, &val4);
31645   if (!SWIG_IsOK(ecode4)) {
31646     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeK" "', argument " "4"" of type '" "int""'");
31647   }
31648   arg4 = static_cast< int >(val4);
31649   ecode5 = SWIG_AsVal_int(obj4, &val5);
31650   if (!SWIG_IsOK(ecode5)) {
31651     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeK" "', argument " "5"" of type '" "int""'");
31652   }
31653   arg5 = static_cast< int >(val5);
31654   result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4,arg5);
31655   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
31656   return resultobj;
31657 fail:
31658   return NULL;
31659 }
31660
31661
31662 SWIGINTERN PyObject *_wrap_BiCylinder_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31663   PyObject *resultobj = 0;
31664   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
31665   int arg2 ;
31666   int arg3 ;
31667   int arg4 ;
31668   int arg5 ;
31669   void *argp1 = 0 ;
31670   int res1 = 0 ;
31671   int val2 ;
31672   int ecode2 = 0 ;
31673   int val3 ;
31674   int ecode3 = 0 ;
31675   int val4 ;
31676   int ecode4 = 0 ;
31677   int val5 ;
31678   int ecode5 = 0 ;
31679   PyObject * obj0 = 0 ;
31680   PyObject * obj1 = 0 ;
31681   PyObject * obj2 = 0 ;
31682   PyObject * obj3 = 0 ;
31683   PyObject * obj4 = 0 ;
31684   Hex::Vertex *result = 0 ;
31685
31686   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getVertexIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31687   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
31688   if (!SWIG_IsOK(res1)) {
31689     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getVertexIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
31690   }
31691   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
31692   ecode2 = SWIG_AsVal_int(obj1, &val2);
31693   if (!SWIG_IsOK(ecode2)) {
31694     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getVertexIJK" "', argument " "2"" of type '" "int""'");
31695   }
31696   arg2 = static_cast< int >(val2);
31697   ecode3 = SWIG_AsVal_int(obj2, &val3);
31698   if (!SWIG_IsOK(ecode3)) {
31699     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getVertexIJK" "', argument " "3"" of type '" "int""'");
31700   }
31701   arg3 = static_cast< int >(val3);
31702   ecode4 = SWIG_AsVal_int(obj3, &val4);
31703   if (!SWIG_IsOK(ecode4)) {
31704     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getVertexIJK" "', argument " "4"" of type '" "int""'");
31705   }
31706   arg4 = static_cast< int >(val4);
31707   ecode5 = SWIG_AsVal_int(obj4, &val5);
31708   if (!SWIG_IsOK(ecode5)) {
31709     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getVertexIJK" "', argument " "5"" of type '" "int""'");
31710   }
31711   arg5 = static_cast< int >(val5);
31712   result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4,arg5);
31713   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31714   return resultobj;
31715 fail:
31716   return NULL;
31717 }
31718
31719
31720 SWIGINTERN PyObject *_wrap_delete_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31721   PyObject *resultobj = 0;
31722   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
31723   void *argp1 = 0 ;
31724   int res1 = 0 ;
31725   PyObject * obj0 = 0 ;
31726
31727   if (!PyArg_ParseTuple(args,(char *)"O:delete_BiCylinder",&obj0)) SWIG_fail;
31728   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_DISOWN |  0 );
31729   if (!SWIG_IsOK(res1)) {
31730     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCylinder" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
31731   }
31732   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
31733   delete arg1;
31734   resultobj = SWIG_Py_Void();
31735   return resultobj;
31736 fail:
31737   return NULL;
31738 }
31739
31740
31741 SWIGINTERN PyObject *BiCylinder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31742   PyObject *obj;
31743   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
31744   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__BiCylinder, SWIG_NewClientData(obj));
31745   return SWIG_Py_Void();
31746 }
31747
31748 SWIGINTERN PyObject *_wrap_NewShape_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31749   PyObject *resultobj = 0;
31750   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
31751   void *argp1 = 0 ;
31752   int res1 = 0 ;
31753   PyObject * obj0 = 0 ;
31754   int result;
31755
31756   if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countVertex",&obj0)) SWIG_fail;
31757   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
31758   if (!SWIG_IsOK(res1)) {
31759     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
31760   }
31761   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31762   result = (int)(arg1)->countVertex();
31763   resultobj = SWIG_From_int(static_cast< int >(result));
31764   return resultobj;
31765 fail:
31766   return NULL;
31767 }
31768
31769
31770 SWIGINTERN PyObject *_wrap_NewShape_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31771   PyObject *resultobj = 0;
31772   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
31773   void *argp1 = 0 ;
31774   int res1 = 0 ;
31775   PyObject * obj0 = 0 ;
31776   int result;
31777
31778   if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countEdge",&obj0)) SWIG_fail;
31779   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
31780   if (!SWIG_IsOK(res1)) {
31781     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
31782   }
31783   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31784   result = (int)(arg1)->countEdge();
31785   resultobj = SWIG_From_int(static_cast< int >(result));
31786   return resultobj;
31787 fail:
31788   return NULL;
31789 }
31790
31791
31792 SWIGINTERN PyObject *_wrap_NewShape_countFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31793   PyObject *resultobj = 0;
31794   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
31795   void *argp1 = 0 ;
31796   int res1 = 0 ;
31797   PyObject * obj0 = 0 ;
31798   int result;
31799
31800   if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countFace",&obj0)) SWIG_fail;
31801   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
31802   if (!SWIG_IsOK(res1)) {
31803     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
31804   }
31805   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31806   result = (int)(arg1)->countFace();
31807   resultobj = SWIG_From_int(static_cast< int >(result));
31808   return resultobj;
31809 fail:
31810   return NULL;
31811 }
31812
31813
31814 SWIGINTERN PyObject *_wrap_NewShape_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31815   PyObject *resultobj = 0;
31816   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
31817   int arg2 ;
31818   void *argp1 = 0 ;
31819   int res1 = 0 ;
31820   int val2 ;
31821   int ecode2 = 0 ;
31822   PyObject * obj0 = 0 ;
31823   PyObject * obj1 = 0 ;
31824   int result;
31825
31826   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getVertex",&obj0,&obj1)) SWIG_fail;
31827   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
31828   if (!SWIG_IsOK(res1)) {
31829     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
31830   }
31831   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31832   ecode2 = SWIG_AsVal_int(obj1, &val2);
31833   if (!SWIG_IsOK(ecode2)) {
31834     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getVertex" "', argument " "2"" of type '" "int""'");
31835   }
31836   arg2 = static_cast< int >(val2);
31837   result = (int)(arg1)->getVertex(arg2);
31838   resultobj = SWIG_From_int(static_cast< int >(result));
31839   return resultobj;
31840 fail:
31841   return NULL;
31842 }
31843
31844
31845 SWIGINTERN PyObject *_wrap_NewShape_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31846   PyObject *resultobj = 0;
31847   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
31848   int arg2 ;
31849   void *argp1 = 0 ;
31850   int res1 = 0 ;
31851   int val2 ;
31852   int ecode2 = 0 ;
31853   PyObject * obj0 = 0 ;
31854   PyObject * obj1 = 0 ;
31855   int result;
31856
31857   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getEdge",&obj0,&obj1)) SWIG_fail;
31858   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
31859   if (!SWIG_IsOK(res1)) {
31860     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
31861   }
31862   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31863   ecode2 = SWIG_AsVal_int(obj1, &val2);
31864   if (!SWIG_IsOK(ecode2)) {
31865     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getEdge" "', argument " "2"" of type '" "int""'");
31866   }
31867   arg2 = static_cast< int >(val2);
31868   result = (int)(arg1)->getEdge(arg2);
31869   resultobj = SWIG_From_int(static_cast< int >(result));
31870   return resultobj;
31871 fail:
31872   return NULL;
31873 }
31874
31875
31876 SWIGINTERN PyObject *_wrap_NewShape_getFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31877   PyObject *resultobj = 0;
31878   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
31879   int arg2 ;
31880   void *argp1 = 0 ;
31881   int res1 = 0 ;
31882   int val2 ;
31883   int ecode2 = 0 ;
31884   PyObject * obj0 = 0 ;
31885   PyObject * obj1 = 0 ;
31886   int result;
31887
31888   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getFace",&obj0,&obj1)) SWIG_fail;
31889   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
31890   if (!SWIG_IsOK(res1)) {
31891     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
31892   }
31893   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31894   ecode2 = SWIG_AsVal_int(obj1, &val2);
31895   if (!SWIG_IsOK(ecode2)) {
31896     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getFace" "', argument " "2"" of type '" "int""'");
31897   }
31898   arg2 = static_cast< int >(val2);
31899   result = (int)(arg1)->getFace(arg2);
31900   resultobj = SWIG_From_int(static_cast< int >(result));
31901   return resultobj;
31902 fail:
31903   return NULL;
31904 }
31905
31906
31907 SWIGINTERN PyObject *_wrap_NewShape_getNameVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31908   PyObject *resultobj = 0;
31909   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
31910   int arg2 ;
31911   void *argp1 = 0 ;
31912   int res1 = 0 ;
31913   int val2 ;
31914   int ecode2 = 0 ;
31915   PyObject * obj0 = 0 ;
31916   PyObject * obj1 = 0 ;
31917   cpchar result;
31918
31919   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameVertex",&obj0,&obj1)) SWIG_fail;
31920   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
31921   if (!SWIG_IsOK(res1)) {
31922     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
31923   }
31924   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31925   ecode2 = SWIG_AsVal_int(obj1, &val2);
31926   if (!SWIG_IsOK(ecode2)) {
31927     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameVertex" "', argument " "2"" of type '" "int""'");
31928   }
31929   arg2 = static_cast< int >(val2);
31930   result = (cpchar)(arg1)->getNameVertex(arg2);
31931   resultobj = SWIG_FromCharPtr((const char *)result);
31932   return resultobj;
31933 fail:
31934   return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_NewShape_getNameEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31939   PyObject *resultobj = 0;
31940   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
31941   int arg2 ;
31942   void *argp1 = 0 ;
31943   int res1 = 0 ;
31944   int val2 ;
31945   int ecode2 = 0 ;
31946   PyObject * obj0 = 0 ;
31947   PyObject * obj1 = 0 ;
31948   cpchar result;
31949
31950   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameEdge",&obj0,&obj1)) SWIG_fail;
31951   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
31952   if (!SWIG_IsOK(res1)) {
31953     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
31954   }
31955   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31956   ecode2 = SWIG_AsVal_int(obj1, &val2);
31957   if (!SWIG_IsOK(ecode2)) {
31958     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameEdge" "', argument " "2"" of type '" "int""'");
31959   }
31960   arg2 = static_cast< int >(val2);
31961   result = (cpchar)(arg1)->getNameEdge(arg2);
31962   resultobj = SWIG_FromCharPtr((const char *)result);
31963   return resultobj;
31964 fail:
31965   return NULL;
31966 }
31967
31968
31969 SWIGINTERN PyObject *_wrap_NewShape_getNameFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31970   PyObject *resultobj = 0;
31971   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
31972   int arg2 ;
31973   void *argp1 = 0 ;
31974   int res1 = 0 ;
31975   int val2 ;
31976   int ecode2 = 0 ;
31977   PyObject * obj0 = 0 ;
31978   PyObject * obj1 = 0 ;
31979   cpchar result;
31980
31981   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameFace",&obj0,&obj1)) SWIG_fail;
31982   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
31983   if (!SWIG_IsOK(res1)) {
31984     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
31985   }
31986   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31987   ecode2 = SWIG_AsVal_int(obj1, &val2);
31988   if (!SWIG_IsOK(ecode2)) {
31989     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameFace" "', argument " "2"" of type '" "int""'");
31990   }
31991   arg2 = static_cast< int >(val2);
31992   result = (cpchar)(arg1)->getNameFace(arg2);
31993   resultobj = SWIG_FromCharPtr((const char *)result);
31994   return resultobj;
31995 fail:
31996   return NULL;
31997 }
31998
31999
32000 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32001   PyObject *resultobj = 0;
32002   Hex::Document *arg1 = (Hex::Document *) 0 ;
32003   Hex::EnumShape arg2 ;
32004   void *argp1 = 0 ;
32005   int res1 = 0 ;
32006   int val2 ;
32007   int ecode2 = 0 ;
32008   PyObject * obj0 = 0 ;
32009   PyObject * obj1 = 0 ;
32010   Hex::NewShape *result = 0 ;
32011
32012   if (!PyArg_ParseTuple(args,(char *)"OO:new_NewShape",&obj0,&obj1)) SWIG_fail;
32013   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
32014   if (!SWIG_IsOK(res1)) {
32015     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
32016   }
32017   arg1 = reinterpret_cast< Hex::Document * >(argp1);
32018   ecode2 = SWIG_AsVal_int(obj1, &val2);
32019   if (!SWIG_IsOK(ecode2)) {
32020     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewShape" "', argument " "2"" of type '" "Hex::EnumShape""'");
32021   }
32022   arg2 = static_cast< Hex::EnumShape >(val2);
32023   result = (Hex::NewShape *)new Hex::NewShape(arg1,arg2);
32024   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_NEW |  0 );
32025   return resultobj;
32026 fail:
32027   return NULL;
32028 }
32029
32030
32031 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32032   PyObject *resultobj = 0;
32033   Hex::Document *arg1 = (Hex::Document *) 0 ;
32034   void *argp1 = 0 ;
32035   int res1 = 0 ;
32036   PyObject * obj0 = 0 ;
32037   Hex::NewShape *result = 0 ;
32038
32039   if (!PyArg_ParseTuple(args,(char *)"O:new_NewShape",&obj0)) SWIG_fail;
32040   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
32041   if (!SWIG_IsOK(res1)) {
32042     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
32043   }
32044   arg1 = reinterpret_cast< Hex::Document * >(argp1);
32045   result = (Hex::NewShape *)new Hex::NewShape(arg1);
32046   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_NEW |  0 );
32047   return resultobj;
32048 fail:
32049   return NULL;
32050 }
32051
32052
32053 SWIGINTERN PyObject *_wrap_new_NewShape(PyObject *self, PyObject *args) {
32054   int argc;
32055   PyObject *argv[3];
32056   int ii;
32057
32058   if (!PyTuple_Check(args)) SWIG_fail;
32059   argc = (int)PyObject_Length(args);
32060   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
32061     argv[ii] = PyTuple_GET_ITEM(args,ii);
32062   }
32063   if (argc == 1) {
32064     int _v;
32065     void *vptr = 0;
32066     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
32067     _v = SWIG_CheckState(res);
32068     if (_v) {
32069       return _wrap_new_NewShape__SWIG_1(self, args);
32070     }
32071   }
32072   if (argc == 2) {
32073     int _v;
32074     void *vptr = 0;
32075     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
32076     _v = SWIG_CheckState(res);
32077     if (_v) {
32078       {
32079         int res = SWIG_AsVal_int(argv[1], NULL);
32080         _v = SWIG_CheckState(res);
32081       }
32082       if (_v) {
32083         return _wrap_new_NewShape__SWIG_0(self, args);
32084       }
32085     }
32086   }
32087
32088 fail:
32089   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NewShape'.\n"
32090     "  Possible C/C++ prototypes are:\n"
32091     "    Hex::NewShape(Hex::Document *,Hex::EnumShape)\n"
32092     "    Hex::NewShape(Hex::Document *)\n");
32093   return NULL;
32094 }
32095
32096
32097 SWIGINTERN PyObject *_wrap_delete_NewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32098   PyObject *resultobj = 0;
32099   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
32100   void *argp1 = 0 ;
32101   int res1 = 0 ;
32102   PyObject * obj0 = 0 ;
32103
32104   if (!PyArg_ParseTuple(args,(char *)"O:delete_NewShape",&obj0)) SWIG_fail;
32105   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_DISOWN |  0 );
32106   if (!SWIG_IsOK(res1)) {
32107     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewShape" "', argument " "1"" of type '" "Hex::NewShape *""'");
32108   }
32109   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
32110   delete arg1;
32111   resultobj = SWIG_Py_Void();
32112   return resultobj;
32113 fail:
32114   return NULL;
32115 }
32116
32117
32118 SWIGINTERN PyObject *NewShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32119   PyObject *obj;
32120   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
32121   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__NewShape, SWIG_NewClientData(obj));
32122   return SWIG_Py_Void();
32123 }
32124
32125 SWIGINTERN PyObject *_wrap_Group_addElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32126   PyObject *resultobj = 0;
32127   Hex::Group *arg1 = (Hex::Group *) 0 ;
32128   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
32129   void *argp1 = 0 ;
32130   int res1 = 0 ;
32131   void *argp2 = 0 ;
32132   int res2 = 0 ;
32133   PyObject * obj0 = 0 ;
32134   PyObject * obj1 = 0 ;
32135   int result;
32136
32137   if (!PyArg_ParseTuple(args,(char *)"OO:Group_addElement",&obj0,&obj1)) SWIG_fail;
32138   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
32139   if (!SWIG_IsOK(res1)) {
32140     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_addElement" "', argument " "1"" of type '" "Hex::Group *""'");
32141   }
32142   arg1 = reinterpret_cast< Hex::Group * >(argp1);
32143   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
32144   if (!SWIG_IsOK(res2)) {
32145     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_addElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
32146   }
32147   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
32148   result = (int)(arg1)->addElement(arg2);
32149   resultobj = SWIG_From_int(static_cast< int >(result));
32150   return resultobj;
32151 fail:
32152   return NULL;
32153 }
32154
32155
32156 SWIGINTERN PyObject *_wrap_Group_countElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32157   PyObject *resultobj = 0;
32158   Hex::Group *arg1 = (Hex::Group *) 0 ;
32159   void *argp1 = 0 ;
32160   int res1 = 0 ;
32161   PyObject * obj0 = 0 ;
32162   int result;
32163
32164   if (!PyArg_ParseTuple(args,(char *)"O:Group_countElement",&obj0)) SWIG_fail;
32165   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
32166   if (!SWIG_IsOK(res1)) {
32167     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_countElement" "', argument " "1"" of type '" "Hex::Group *""'");
32168   }
32169   arg1 = reinterpret_cast< Hex::Group * >(argp1);
32170   result = (int)(arg1)->countElement();
32171   resultobj = SWIG_From_int(static_cast< int >(result));
32172   return resultobj;
32173 fail:
32174   return NULL;
32175 }
32176
32177
32178 SWIGINTERN PyObject *_wrap_Group_getKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32179   PyObject *resultobj = 0;
32180   Hex::Group *arg1 = (Hex::Group *) 0 ;
32181   void *argp1 = 0 ;
32182   int res1 = 0 ;
32183   PyObject * obj0 = 0 ;
32184   Hex::EnumGroup result;
32185
32186   if (!PyArg_ParseTuple(args,(char *)"O:Group_getKind",&obj0)) SWIG_fail;
32187   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
32188   if (!SWIG_IsOK(res1)) {
32189     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getKind" "', argument " "1"" of type '" "Hex::Group *""'");
32190   }
32191   arg1 = reinterpret_cast< Hex::Group * >(argp1);
32192   result = (Hex::EnumGroup)(arg1)->getKind();
32193   resultobj = SWIG_From_int(static_cast< int >(result));
32194   return resultobj;
32195 fail:
32196   return NULL;
32197 }
32198
32199
32200 SWIGINTERN PyObject *_wrap_Group_removeElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32201   PyObject *resultobj = 0;
32202   Hex::Group *arg1 = (Hex::Group *) 0 ;
32203   int arg2 ;
32204   void *argp1 = 0 ;
32205   int res1 = 0 ;
32206   int val2 ;
32207   int ecode2 = 0 ;
32208   PyObject * obj0 = 0 ;
32209   PyObject * obj1 = 0 ;
32210   int result;
32211
32212   if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
32213   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
32214   if (!SWIG_IsOK(res1)) {
32215     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
32216   }
32217   arg1 = reinterpret_cast< Hex::Group * >(argp1);
32218   ecode2 = SWIG_AsVal_int(obj1, &val2);
32219   if (!SWIG_IsOK(ecode2)) {
32220     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "int""'");
32221   }
32222   arg2 = static_cast< int >(val2);
32223   result = (int)(arg1)->removeElement(arg2);
32224   resultobj = SWIG_From_int(static_cast< int >(result));
32225   return resultobj;
32226 fail:
32227   return NULL;
32228 }
32229
32230
32231 SWIGINTERN PyObject *_wrap_Group_clearElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32232   PyObject *resultobj = 0;
32233   Hex::Group *arg1 = (Hex::Group *) 0 ;
32234   void *argp1 = 0 ;
32235   int res1 = 0 ;
32236   PyObject * obj0 = 0 ;
32237
32238   if (!PyArg_ParseTuple(args,(char *)"O:Group_clearElement",&obj0)) SWIG_fail;
32239   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
32240   if (!SWIG_IsOK(res1)) {
32241     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_clearElement" "', argument " "1"" of type '" "Hex::Group *""'");
32242   }
32243   arg1 = reinterpret_cast< Hex::Group * >(argp1);
32244   (arg1)->clearElement();
32245   resultobj = SWIG_Py_Void();
32246   return resultobj;
32247 fail:
32248   return NULL;
32249 }
32250
32251
32252 SWIGINTERN PyObject *_wrap_Group_removeElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32253   PyObject *resultobj = 0;
32254   Hex::Group *arg1 = (Hex::Group *) 0 ;
32255   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
32256   void *argp1 = 0 ;
32257   int res1 = 0 ;
32258   void *argp2 = 0 ;
32259   int res2 = 0 ;
32260   PyObject * obj0 = 0 ;
32261   PyObject * obj1 = 0 ;
32262   int result;
32263
32264   if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
32265   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
32266   if (!SWIG_IsOK(res1)) {
32267     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
32268   }
32269   arg1 = reinterpret_cast< Hex::Group * >(argp1);
32270   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
32271   if (!SWIG_IsOK(res2)) {
32272     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
32273   }
32274   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
32275   result = (int)(arg1)->removeElement(arg2);
32276   resultobj = SWIG_From_int(static_cast< int >(result));
32277   return resultobj;
32278 fail:
32279   return NULL;
32280 }
32281
32282
32283 SWIGINTERN PyObject *_wrap_Group_removeElement(PyObject *self, PyObject *args) {
32284   int argc;
32285   PyObject *argv[3];
32286   int ii;
32287
32288   if (!PyTuple_Check(args)) SWIG_fail;
32289   argc = (int)PyObject_Length(args);
32290   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
32291     argv[ii] = PyTuple_GET_ITEM(args,ii);
32292   }
32293   if (argc == 2) {
32294     int _v;
32295     void *vptr = 0;
32296     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
32297     _v = SWIG_CheckState(res);
32298     if (_v) {
32299       void *vptr = 0;
32300       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
32301       _v = SWIG_CheckState(res);
32302       if (_v) {
32303         return _wrap_Group_removeElement__SWIG_1(self, args);
32304       }
32305     }
32306   }
32307   if (argc == 2) {
32308     int _v;
32309     void *vptr = 0;
32310     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
32311     _v = SWIG_CheckState(res);
32312     if (_v) {
32313       {
32314         int res = SWIG_AsVal_int(argv[1], NULL);
32315         _v = SWIG_CheckState(res);
32316       }
32317       if (_v) {
32318         return _wrap_Group_removeElement__SWIG_0(self, args);
32319       }
32320     }
32321   }
32322
32323 fail:
32324   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Group_removeElement'.\n"
32325     "  Possible C/C++ prototypes are:\n"
32326     "    removeElement(Hex::Group *,int)\n"
32327     "    removeElement(Hex::Group *,Hex::EltBase *)\n");
32328   return NULL;
32329 }
32330
32331
32332 SWIGINTERN PyObject *_wrap_Group_getElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32333   PyObject *resultobj = 0;
32334   Hex::Group *arg1 = (Hex::Group *) 0 ;
32335   int arg2 ;
32336   void *argp1 = 0 ;
32337   int res1 = 0 ;
32338   int val2 ;
32339   int ecode2 = 0 ;
32340   PyObject * obj0 = 0 ;
32341   PyObject * obj1 = 0 ;
32342   Hex::EltBase *result = 0 ;
32343
32344   if (!PyArg_ParseTuple(args,(char *)"OO:Group_getElement",&obj0,&obj1)) SWIG_fail;
32345   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
32346   if (!SWIG_IsOK(res1)) {
32347     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getElement" "', argument " "1"" of type '" "Hex::Group *""'");
32348   }
32349   arg1 = reinterpret_cast< Hex::Group * >(argp1);
32350   ecode2 = SWIG_AsVal_int(obj1, &val2);
32351   if (!SWIG_IsOK(ecode2)) {
32352     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_getElement" "', argument " "2"" of type '" "int""'");
32353   }
32354   arg2 = static_cast< int >(val2);
32355   result = (Hex::EltBase *)(arg1)->getElement(arg2);
32356   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 |  0 );
32357   return resultobj;
32358 fail:
32359   return NULL;
32360 }
32361
32362
32363 SWIGINTERN PyObject *_wrap_new_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32364   PyObject *resultobj = 0;
32365   Hex::Document *arg1 = (Hex::Document *) 0 ;
32366   cpchar arg2 = (cpchar) 0 ;
32367   Hex::EnumGroup arg3 ;
32368   void *argp1 = 0 ;
32369   int res1 = 0 ;
32370   int res2 ;
32371   char *buf2 = 0 ;
32372   int alloc2 = 0 ;
32373   int val3 ;
32374   int ecode3 = 0 ;
32375   PyObject * obj0 = 0 ;
32376   PyObject * obj1 = 0 ;
32377   PyObject * obj2 = 0 ;
32378   Hex::Group *result = 0 ;
32379
32380   if (!PyArg_ParseTuple(args,(char *)"OOO:new_Group",&obj0,&obj1,&obj2)) SWIG_fail;
32381   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
32382   if (!SWIG_IsOK(res1)) {
32383     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Group" "', argument " "1"" of type '" "Hex::Document *""'");
32384   }
32385   arg1 = reinterpret_cast< Hex::Document * >(argp1);
32386   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32387   if (!SWIG_IsOK(res2)) {
32388     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Group" "', argument " "2"" of type '" "cpchar""'");
32389   }
32390   arg2 = reinterpret_cast< cpchar >(buf2);
32391   ecode3 = SWIG_AsVal_int(obj2, &val3);
32392   if (!SWIG_IsOK(ecode3)) {
32393     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Group" "', argument " "3"" of type '" "Hex::EnumGroup""'");
32394   }
32395   arg3 = static_cast< Hex::EnumGroup >(val3);
32396   result = (Hex::Group *)new Hex::Group(arg1,arg2,arg3);
32397   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, SWIG_POINTER_NEW |  0 );
32398   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32399   return resultobj;
32400 fail:
32401   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32402   return NULL;
32403 }
32404
32405
32406 SWIGINTERN PyObject *_wrap_delete_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32407   PyObject *resultobj = 0;
32408   Hex::Group *arg1 = (Hex::Group *) 0 ;
32409   void *argp1 = 0 ;
32410   int res1 = 0 ;
32411   PyObject * obj0 = 0 ;
32412
32413   if (!PyArg_ParseTuple(args,(char *)"O:delete_Group",&obj0)) SWIG_fail;
32414   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, SWIG_POINTER_DISOWN |  0 );
32415   if (!SWIG_IsOK(res1)) {
32416     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Group" "', argument " "1"" of type '" "Hex::Group *""'");
32417   }
32418   arg1 = reinterpret_cast< Hex::Group * >(argp1);
32419   delete arg1;
32420   resultobj = SWIG_Py_Void();
32421   return resultobj;
32422 fail:
32423   return NULL;
32424 }
32425
32426
32427 SWIGINTERN PyObject *Group_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32428   PyObject *obj;
32429   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
32430   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Group, SWIG_NewClientData(obj));
32431   return SWIG_Py_Void();
32432 }
32433
32434 static PyMethodDef SwigMethods[] = {
32435          { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
32436          { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL},
32437          { (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL},
32438          { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
32439          { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
32440          { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
32441          { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
32442          { (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL},
32443          { (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL},
32444          { (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL},
32445          { (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL},
32446          { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
32447          { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
32448          { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
32449          { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
32450          { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
32451          { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
32452          { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
32453          { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
32454          { (char *)"VectorHexas_iterator", _wrap_VectorHexas_iterator, METH_VARARGS, NULL},
32455          { (char *)"VectorHexas___nonzero__", _wrap_VectorHexas___nonzero__, METH_VARARGS, NULL},
32456          { (char *)"VectorHexas___bool__", _wrap_VectorHexas___bool__, METH_VARARGS, NULL},
32457          { (char *)"VectorHexas___len__", _wrap_VectorHexas___len__, METH_VARARGS, NULL},
32458          { (char *)"VectorHexas_pop", _wrap_VectorHexas_pop, METH_VARARGS, NULL},
32459          { (char *)"VectorHexas___getslice__", _wrap_VectorHexas___getslice__, METH_VARARGS, NULL},
32460          { (char *)"VectorHexas___setslice__", _wrap_VectorHexas___setslice__, METH_VARARGS, NULL},
32461          { (char *)"VectorHexas___delslice__", _wrap_VectorHexas___delslice__, METH_VARARGS, NULL},
32462          { (char *)"VectorHexas___delitem__", _wrap_VectorHexas___delitem__, METH_VARARGS, NULL},
32463          { (char *)"VectorHexas___getitem__", _wrap_VectorHexas___getitem__, METH_VARARGS, NULL},
32464          { (char *)"VectorHexas___setitem__", _wrap_VectorHexas___setitem__, METH_VARARGS, NULL},
32465          { (char *)"VectorHexas_append", _wrap_VectorHexas_append, METH_VARARGS, NULL},
32466          { (char *)"VectorHexas_empty", _wrap_VectorHexas_empty, METH_VARARGS, NULL},
32467          { (char *)"VectorHexas_size", _wrap_VectorHexas_size, METH_VARARGS, NULL},
32468          { (char *)"VectorHexas_clear", _wrap_VectorHexas_clear, METH_VARARGS, NULL},
32469          { (char *)"VectorHexas_swap", _wrap_VectorHexas_swap, METH_VARARGS, NULL},
32470          { (char *)"VectorHexas_get_allocator", _wrap_VectorHexas_get_allocator, METH_VARARGS, NULL},
32471          { (char *)"VectorHexas_begin", _wrap_VectorHexas_begin, METH_VARARGS, NULL},
32472          { (char *)"VectorHexas_end", _wrap_VectorHexas_end, METH_VARARGS, NULL},
32473          { (char *)"VectorHexas_rbegin", _wrap_VectorHexas_rbegin, METH_VARARGS, NULL},
32474          { (char *)"VectorHexas_rend", _wrap_VectorHexas_rend, METH_VARARGS, NULL},
32475          { (char *)"VectorHexas_pop_back", _wrap_VectorHexas_pop_back, METH_VARARGS, NULL},
32476          { (char *)"VectorHexas_erase", _wrap_VectorHexas_erase, METH_VARARGS, NULL},
32477          { (char *)"new_VectorHexas", _wrap_new_VectorHexas, METH_VARARGS, NULL},
32478          { (char *)"VectorHexas_push_back", _wrap_VectorHexas_push_back, METH_VARARGS, NULL},
32479          { (char *)"VectorHexas_front", _wrap_VectorHexas_front, METH_VARARGS, NULL},
32480          { (char *)"VectorHexas_back", _wrap_VectorHexas_back, METH_VARARGS, NULL},
32481          { (char *)"VectorHexas_assign", _wrap_VectorHexas_assign, METH_VARARGS, NULL},
32482          { (char *)"VectorHexas_resize", _wrap_VectorHexas_resize, METH_VARARGS, NULL},
32483          { (char *)"VectorHexas_insert", _wrap_VectorHexas_insert, METH_VARARGS, NULL},
32484          { (char *)"VectorHexas_reserve", _wrap_VectorHexas_reserve, METH_VARARGS, NULL},
32485          { (char *)"VectorHexas_capacity", _wrap_VectorHexas_capacity, METH_VARARGS, NULL},
32486          { (char *)"delete_VectorHexas", _wrap_delete_VectorHexas, METH_VARARGS, NULL},
32487          { (char *)"VectorHexas_swigregister", VectorHexas_swigregister, METH_VARARGS, NULL},
32488          { (char *)"VectorQuads_iterator", _wrap_VectorQuads_iterator, METH_VARARGS, NULL},
32489          { (char *)"VectorQuads___nonzero__", _wrap_VectorQuads___nonzero__, METH_VARARGS, NULL},
32490          { (char *)"VectorQuads___bool__", _wrap_VectorQuads___bool__, METH_VARARGS, NULL},
32491          { (char *)"VectorQuads___len__", _wrap_VectorQuads___len__, METH_VARARGS, NULL},
32492          { (char *)"VectorQuads_pop", _wrap_VectorQuads_pop, METH_VARARGS, NULL},
32493          { (char *)"VectorQuads___getslice__", _wrap_VectorQuads___getslice__, METH_VARARGS, NULL},
32494          { (char *)"VectorQuads___setslice__", _wrap_VectorQuads___setslice__, METH_VARARGS, NULL},
32495          { (char *)"VectorQuads___delslice__", _wrap_VectorQuads___delslice__, METH_VARARGS, NULL},
32496          { (char *)"VectorQuads___delitem__", _wrap_VectorQuads___delitem__, METH_VARARGS, NULL},
32497          { (char *)"VectorQuads___getitem__", _wrap_VectorQuads___getitem__, METH_VARARGS, NULL},
32498          { (char *)"VectorQuads___setitem__", _wrap_VectorQuads___setitem__, METH_VARARGS, NULL},
32499          { (char *)"VectorQuads_append", _wrap_VectorQuads_append, METH_VARARGS, NULL},
32500          { (char *)"VectorQuads_empty", _wrap_VectorQuads_empty, METH_VARARGS, NULL},
32501          { (char *)"VectorQuads_size", _wrap_VectorQuads_size, METH_VARARGS, NULL},
32502          { (char *)"VectorQuads_clear", _wrap_VectorQuads_clear, METH_VARARGS, NULL},
32503          { (char *)"VectorQuads_swap", _wrap_VectorQuads_swap, METH_VARARGS, NULL},
32504          { (char *)"VectorQuads_get_allocator", _wrap_VectorQuads_get_allocator, METH_VARARGS, NULL},
32505          { (char *)"VectorQuads_begin", _wrap_VectorQuads_begin, METH_VARARGS, NULL},
32506          { (char *)"VectorQuads_end", _wrap_VectorQuads_end, METH_VARARGS, NULL},
32507          { (char *)"VectorQuads_rbegin", _wrap_VectorQuads_rbegin, METH_VARARGS, NULL},
32508          { (char *)"VectorQuads_rend", _wrap_VectorQuads_rend, METH_VARARGS, NULL},
32509          { (char *)"VectorQuads_pop_back", _wrap_VectorQuads_pop_back, METH_VARARGS, NULL},
32510          { (char *)"VectorQuads_erase", _wrap_VectorQuads_erase, METH_VARARGS, NULL},
32511          { (char *)"new_VectorQuads", _wrap_new_VectorQuads, METH_VARARGS, NULL},
32512          { (char *)"VectorQuads_push_back", _wrap_VectorQuads_push_back, METH_VARARGS, NULL},
32513          { (char *)"VectorQuads_front", _wrap_VectorQuads_front, METH_VARARGS, NULL},
32514          { (char *)"VectorQuads_back", _wrap_VectorQuads_back, METH_VARARGS, NULL},
32515          { (char *)"VectorQuads_assign", _wrap_VectorQuads_assign, METH_VARARGS, NULL},
32516          { (char *)"VectorQuads_resize", _wrap_VectorQuads_resize, METH_VARARGS, NULL},
32517          { (char *)"VectorQuads_insert", _wrap_VectorQuads_insert, METH_VARARGS, NULL},
32518          { (char *)"VectorQuads_reserve", _wrap_VectorQuads_reserve, METH_VARARGS, NULL},
32519          { (char *)"VectorQuads_capacity", _wrap_VectorQuads_capacity, METH_VARARGS, NULL},
32520          { (char *)"delete_VectorQuads", _wrap_delete_VectorQuads, METH_VARARGS, NULL},
32521          { (char *)"VectorQuads_swigregister", VectorQuads_swigregister, METH_VARARGS, NULL},
32522          { (char *)"VectorEdges_iterator", _wrap_VectorEdges_iterator, METH_VARARGS, NULL},
32523          { (char *)"VectorEdges___nonzero__", _wrap_VectorEdges___nonzero__, METH_VARARGS, NULL},
32524          { (char *)"VectorEdges___bool__", _wrap_VectorEdges___bool__, METH_VARARGS, NULL},
32525          { (char *)"VectorEdges___len__", _wrap_VectorEdges___len__, METH_VARARGS, NULL},
32526          { (char *)"VectorEdges_pop", _wrap_VectorEdges_pop, METH_VARARGS, NULL},
32527          { (char *)"VectorEdges___getslice__", _wrap_VectorEdges___getslice__, METH_VARARGS, NULL},
32528          { (char *)"VectorEdges___setslice__", _wrap_VectorEdges___setslice__, METH_VARARGS, NULL},
32529          { (char *)"VectorEdges___delslice__", _wrap_VectorEdges___delslice__, METH_VARARGS, NULL},
32530          { (char *)"VectorEdges___delitem__", _wrap_VectorEdges___delitem__, METH_VARARGS, NULL},
32531          { (char *)"VectorEdges___getitem__", _wrap_VectorEdges___getitem__, METH_VARARGS, NULL},
32532          { (char *)"VectorEdges___setitem__", _wrap_VectorEdges___setitem__, METH_VARARGS, NULL},
32533          { (char *)"VectorEdges_append", _wrap_VectorEdges_append, METH_VARARGS, NULL},
32534          { (char *)"VectorEdges_empty", _wrap_VectorEdges_empty, METH_VARARGS, NULL},
32535          { (char *)"VectorEdges_size", _wrap_VectorEdges_size, METH_VARARGS, NULL},
32536          { (char *)"VectorEdges_clear", _wrap_VectorEdges_clear, METH_VARARGS, NULL},
32537          { (char *)"VectorEdges_swap", _wrap_VectorEdges_swap, METH_VARARGS, NULL},
32538          { (char *)"VectorEdges_get_allocator", _wrap_VectorEdges_get_allocator, METH_VARARGS, NULL},
32539          { (char *)"VectorEdges_begin", _wrap_VectorEdges_begin, METH_VARARGS, NULL},
32540          { (char *)"VectorEdges_end", _wrap_VectorEdges_end, METH_VARARGS, NULL},
32541          { (char *)"VectorEdges_rbegin", _wrap_VectorEdges_rbegin, METH_VARARGS, NULL},
32542          { (char *)"VectorEdges_rend", _wrap_VectorEdges_rend, METH_VARARGS, NULL},
32543          { (char *)"VectorEdges_pop_back", _wrap_VectorEdges_pop_back, METH_VARARGS, NULL},
32544          { (char *)"VectorEdges_erase", _wrap_VectorEdges_erase, METH_VARARGS, NULL},
32545          { (char *)"new_VectorEdges", _wrap_new_VectorEdges, METH_VARARGS, NULL},
32546          { (char *)"VectorEdges_push_back", _wrap_VectorEdges_push_back, METH_VARARGS, NULL},
32547          { (char *)"VectorEdges_front", _wrap_VectorEdges_front, METH_VARARGS, NULL},
32548          { (char *)"VectorEdges_back", _wrap_VectorEdges_back, METH_VARARGS, NULL},
32549          { (char *)"VectorEdges_assign", _wrap_VectorEdges_assign, METH_VARARGS, NULL},
32550          { (char *)"VectorEdges_resize", _wrap_VectorEdges_resize, METH_VARARGS, NULL},
32551          { (char *)"VectorEdges_insert", _wrap_VectorEdges_insert, METH_VARARGS, NULL},
32552          { (char *)"VectorEdges_reserve", _wrap_VectorEdges_reserve, METH_VARARGS, NULL},
32553          { (char *)"VectorEdges_capacity", _wrap_VectorEdges_capacity, METH_VARARGS, NULL},
32554          { (char *)"delete_VectorEdges", _wrap_delete_VectorEdges, METH_VARARGS, NULL},
32555          { (char *)"VectorEdges_swigregister", VectorEdges_swigregister, METH_VARARGS, NULL},
32556          { (char *)"VectorVertices_iterator", _wrap_VectorVertices_iterator, METH_VARARGS, NULL},
32557          { (char *)"VectorVertices___nonzero__", _wrap_VectorVertices___nonzero__, METH_VARARGS, NULL},
32558          { (char *)"VectorVertices___bool__", _wrap_VectorVertices___bool__, METH_VARARGS, NULL},
32559          { (char *)"VectorVertices___len__", _wrap_VectorVertices___len__, METH_VARARGS, NULL},
32560          { (char *)"VectorVertices_pop", _wrap_VectorVertices_pop, METH_VARARGS, NULL},
32561          { (char *)"VectorVertices___getslice__", _wrap_VectorVertices___getslice__, METH_VARARGS, NULL},
32562          { (char *)"VectorVertices___setslice__", _wrap_VectorVertices___setslice__, METH_VARARGS, NULL},
32563          { (char *)"VectorVertices___delslice__", _wrap_VectorVertices___delslice__, METH_VARARGS, NULL},
32564          { (char *)"VectorVertices___delitem__", _wrap_VectorVertices___delitem__, METH_VARARGS, NULL},
32565          { (char *)"VectorVertices___getitem__", _wrap_VectorVertices___getitem__, METH_VARARGS, NULL},
32566          { (char *)"VectorVertices___setitem__", _wrap_VectorVertices___setitem__, METH_VARARGS, NULL},
32567          { (char *)"VectorVertices_append", _wrap_VectorVertices_append, METH_VARARGS, NULL},
32568          { (char *)"VectorVertices_empty", _wrap_VectorVertices_empty, METH_VARARGS, NULL},
32569          { (char *)"VectorVertices_size", _wrap_VectorVertices_size, METH_VARARGS, NULL},
32570          { (char *)"VectorVertices_clear", _wrap_VectorVertices_clear, METH_VARARGS, NULL},
32571          { (char *)"VectorVertices_swap", _wrap_VectorVertices_swap, METH_VARARGS, NULL},
32572          { (char *)"VectorVertices_get_allocator", _wrap_VectorVertices_get_allocator, METH_VARARGS, NULL},
32573          { (char *)"VectorVertices_begin", _wrap_VectorVertices_begin, METH_VARARGS, NULL},
32574          { (char *)"VectorVertices_end", _wrap_VectorVertices_end, METH_VARARGS, NULL},
32575          { (char *)"VectorVertices_rbegin", _wrap_VectorVertices_rbegin, METH_VARARGS, NULL},
32576          { (char *)"VectorVertices_rend", _wrap_VectorVertices_rend, METH_VARARGS, NULL},
32577          { (char *)"VectorVertices_pop_back", _wrap_VectorVertices_pop_back, METH_VARARGS, NULL},
32578          { (char *)"VectorVertices_erase", _wrap_VectorVertices_erase, METH_VARARGS, NULL},
32579          { (char *)"new_VectorVertices", _wrap_new_VectorVertices, METH_VARARGS, NULL},
32580          { (char *)"VectorVertices_push_back", _wrap_VectorVertices_push_back, METH_VARARGS, NULL},
32581          { (char *)"VectorVertices_front", _wrap_VectorVertices_front, METH_VARARGS, NULL},
32582          { (char *)"VectorVertices_back", _wrap_VectorVertices_back, METH_VARARGS, NULL},
32583          { (char *)"VectorVertices_assign", _wrap_VectorVertices_assign, METH_VARARGS, NULL},
32584          { (char *)"VectorVertices_resize", _wrap_VectorVertices_resize, METH_VARARGS, NULL},
32585          { (char *)"VectorVertices_insert", _wrap_VectorVertices_insert, METH_VARARGS, NULL},
32586          { (char *)"VectorVertices_reserve", _wrap_VectorVertices_reserve, METH_VARARGS, NULL},
32587          { (char *)"VectorVertices_capacity", _wrap_VectorVertices_capacity, METH_VARARGS, NULL},
32588          { (char *)"delete_VectorVertices", _wrap_delete_VectorVertices, METH_VARARGS, NULL},
32589          { (char *)"VectorVertices_swigregister", VectorVertices_swigregister, METH_VARARGS, NULL},
32590          { (char *)"VectorShapes_iterator", _wrap_VectorShapes_iterator, METH_VARARGS, NULL},
32591          { (char *)"VectorShapes___nonzero__", _wrap_VectorShapes___nonzero__, METH_VARARGS, NULL},
32592          { (char *)"VectorShapes___bool__", _wrap_VectorShapes___bool__, METH_VARARGS, NULL},
32593          { (char *)"VectorShapes___len__", _wrap_VectorShapes___len__, METH_VARARGS, NULL},
32594          { (char *)"VectorShapes_pop", _wrap_VectorShapes_pop, METH_VARARGS, NULL},
32595          { (char *)"VectorShapes___getslice__", _wrap_VectorShapes___getslice__, METH_VARARGS, NULL},
32596          { (char *)"VectorShapes___setslice__", _wrap_VectorShapes___setslice__, METH_VARARGS, NULL},
32597          { (char *)"VectorShapes___delslice__", _wrap_VectorShapes___delslice__, METH_VARARGS, NULL},
32598          { (char *)"VectorShapes___delitem__", _wrap_VectorShapes___delitem__, METH_VARARGS, NULL},
32599          { (char *)"VectorShapes___getitem__", _wrap_VectorShapes___getitem__, METH_VARARGS, NULL},
32600          { (char *)"VectorShapes___setitem__", _wrap_VectorShapes___setitem__, METH_VARARGS, NULL},
32601          { (char *)"VectorShapes_append", _wrap_VectorShapes_append, METH_VARARGS, NULL},
32602          { (char *)"VectorShapes_empty", _wrap_VectorShapes_empty, METH_VARARGS, NULL},
32603          { (char *)"VectorShapes_size", _wrap_VectorShapes_size, METH_VARARGS, NULL},
32604          { (char *)"VectorShapes_clear", _wrap_VectorShapes_clear, METH_VARARGS, NULL},
32605          { (char *)"VectorShapes_swap", _wrap_VectorShapes_swap, METH_VARARGS, NULL},
32606          { (char *)"VectorShapes_get_allocator", _wrap_VectorShapes_get_allocator, METH_VARARGS, NULL},
32607          { (char *)"VectorShapes_begin", _wrap_VectorShapes_begin, METH_VARARGS, NULL},
32608          { (char *)"VectorShapes_end", _wrap_VectorShapes_end, METH_VARARGS, NULL},
32609          { (char *)"VectorShapes_rbegin", _wrap_VectorShapes_rbegin, METH_VARARGS, NULL},
32610          { (char *)"VectorShapes_rend", _wrap_VectorShapes_rend, METH_VARARGS, NULL},
32611          { (char *)"VectorShapes_pop_back", _wrap_VectorShapes_pop_back, METH_VARARGS, NULL},
32612          { (char *)"VectorShapes_erase", _wrap_VectorShapes_erase, METH_VARARGS, NULL},
32613          { (char *)"new_VectorShapes", _wrap_new_VectorShapes, METH_VARARGS, NULL},
32614          { (char *)"VectorShapes_push_back", _wrap_VectorShapes_push_back, METH_VARARGS, NULL},
32615          { (char *)"VectorShapes_front", _wrap_VectorShapes_front, METH_VARARGS, NULL},
32616          { (char *)"VectorShapes_back", _wrap_VectorShapes_back, METH_VARARGS, NULL},
32617          { (char *)"VectorShapes_assign", _wrap_VectorShapes_assign, METH_VARARGS, NULL},
32618          { (char *)"VectorShapes_resize", _wrap_VectorShapes_resize, METH_VARARGS, NULL},
32619          { (char *)"VectorShapes_insert", _wrap_VectorShapes_insert, METH_VARARGS, NULL},
32620          { (char *)"VectorShapes_reserve", _wrap_VectorShapes_reserve, METH_VARARGS, NULL},
32621          { (char *)"VectorShapes_capacity", _wrap_VectorShapes_capacity, METH_VARARGS, NULL},
32622          { (char *)"delete_VectorShapes", _wrap_delete_VectorShapes, METH_VARARGS, NULL},
32623          { (char *)"VectorShapes_swigregister", VectorShapes_swigregister, METH_VARARGS, NULL},
32624          { (char *)"VectorReal_iterator", _wrap_VectorReal_iterator, METH_VARARGS, NULL},
32625          { (char *)"VectorReal___nonzero__", _wrap_VectorReal___nonzero__, METH_VARARGS, NULL},
32626          { (char *)"VectorReal___bool__", _wrap_VectorReal___bool__, METH_VARARGS, NULL},
32627          { (char *)"VectorReal___len__", _wrap_VectorReal___len__, METH_VARARGS, NULL},
32628          { (char *)"VectorReal_pop", _wrap_VectorReal_pop, METH_VARARGS, NULL},
32629          { (char *)"VectorReal___getslice__", _wrap_VectorReal___getslice__, METH_VARARGS, NULL},
32630          { (char *)"VectorReal___setslice__", _wrap_VectorReal___setslice__, METH_VARARGS, NULL},
32631          { (char *)"VectorReal___delslice__", _wrap_VectorReal___delslice__, METH_VARARGS, NULL},
32632          { (char *)"VectorReal___delitem__", _wrap_VectorReal___delitem__, METH_VARARGS, NULL},
32633          { (char *)"VectorReal___getitem__", _wrap_VectorReal___getitem__, METH_VARARGS, NULL},
32634          { (char *)"VectorReal___setitem__", _wrap_VectorReal___setitem__, METH_VARARGS, NULL},
32635          { (char *)"VectorReal_append", _wrap_VectorReal_append, METH_VARARGS, NULL},
32636          { (char *)"VectorReal_empty", _wrap_VectorReal_empty, METH_VARARGS, NULL},
32637          { (char *)"VectorReal_size", _wrap_VectorReal_size, METH_VARARGS, NULL},
32638          { (char *)"VectorReal_clear", _wrap_VectorReal_clear, METH_VARARGS, NULL},
32639          { (char *)"VectorReal_swap", _wrap_VectorReal_swap, METH_VARARGS, NULL},
32640          { (char *)"VectorReal_get_allocator", _wrap_VectorReal_get_allocator, METH_VARARGS, NULL},
32641          { (char *)"VectorReal_begin", _wrap_VectorReal_begin, METH_VARARGS, NULL},
32642          { (char *)"VectorReal_end", _wrap_VectorReal_end, METH_VARARGS, NULL},
32643          { (char *)"VectorReal_rbegin", _wrap_VectorReal_rbegin, METH_VARARGS, NULL},
32644          { (char *)"VectorReal_rend", _wrap_VectorReal_rend, METH_VARARGS, NULL},
32645          { (char *)"VectorReal_pop_back", _wrap_VectorReal_pop_back, METH_VARARGS, NULL},
32646          { (char *)"VectorReal_erase", _wrap_VectorReal_erase, METH_VARARGS, NULL},
32647          { (char *)"new_VectorReal", _wrap_new_VectorReal, METH_VARARGS, NULL},
32648          { (char *)"VectorReal_push_back", _wrap_VectorReal_push_back, METH_VARARGS, NULL},
32649          { (char *)"VectorReal_front", _wrap_VectorReal_front, METH_VARARGS, NULL},
32650          { (char *)"VectorReal_back", _wrap_VectorReal_back, METH_VARARGS, NULL},
32651          { (char *)"VectorReal_assign", _wrap_VectorReal_assign, METH_VARARGS, NULL},
32652          { (char *)"VectorReal_resize", _wrap_VectorReal_resize, METH_VARARGS, NULL},
32653          { (char *)"VectorReal_insert", _wrap_VectorReal_insert, METH_VARARGS, NULL},
32654          { (char *)"VectorReal_reserve", _wrap_VectorReal_reserve, METH_VARARGS, NULL},
32655          { (char *)"VectorReal_capacity", _wrap_VectorReal_capacity, METH_VARARGS, NULL},
32656          { (char *)"delete_VectorReal", _wrap_delete_VectorReal, METH_VARARGS, NULL},
32657          { (char *)"VectorReal_swigregister", VectorReal_swigregister, METH_VARARGS, NULL},
32658          { (char *)"VectorInt_iterator", _wrap_VectorInt_iterator, METH_VARARGS, NULL},
32659          { (char *)"VectorInt___nonzero__", _wrap_VectorInt___nonzero__, METH_VARARGS, NULL},
32660          { (char *)"VectorInt___bool__", _wrap_VectorInt___bool__, METH_VARARGS, NULL},
32661          { (char *)"VectorInt___len__", _wrap_VectorInt___len__, METH_VARARGS, NULL},
32662          { (char *)"VectorInt_pop", _wrap_VectorInt_pop, METH_VARARGS, NULL},
32663          { (char *)"VectorInt___getslice__", _wrap_VectorInt___getslice__, METH_VARARGS, NULL},
32664          { (char *)"VectorInt___setslice__", _wrap_VectorInt___setslice__, METH_VARARGS, NULL},
32665          { (char *)"VectorInt___delslice__", _wrap_VectorInt___delslice__, METH_VARARGS, NULL},
32666          { (char *)"VectorInt___delitem__", _wrap_VectorInt___delitem__, METH_VARARGS, NULL},
32667          { (char *)"VectorInt___getitem__", _wrap_VectorInt___getitem__, METH_VARARGS, NULL},
32668          { (char *)"VectorInt___setitem__", _wrap_VectorInt___setitem__, METH_VARARGS, NULL},
32669          { (char *)"VectorInt_append", _wrap_VectorInt_append, METH_VARARGS, NULL},
32670          { (char *)"VectorInt_empty", _wrap_VectorInt_empty, METH_VARARGS, NULL},
32671          { (char *)"VectorInt_size", _wrap_VectorInt_size, METH_VARARGS, NULL},
32672          { (char *)"VectorInt_clear", _wrap_VectorInt_clear, METH_VARARGS, NULL},
32673          { (char *)"VectorInt_swap", _wrap_VectorInt_swap, METH_VARARGS, NULL},
32674          { (char *)"VectorInt_get_allocator", _wrap_VectorInt_get_allocator, METH_VARARGS, NULL},
32675          { (char *)"VectorInt_begin", _wrap_VectorInt_begin, METH_VARARGS, NULL},
32676          { (char *)"VectorInt_end", _wrap_VectorInt_end, METH_VARARGS, NULL},
32677          { (char *)"VectorInt_rbegin", _wrap_VectorInt_rbegin, METH_VARARGS, NULL},
32678          { (char *)"VectorInt_rend", _wrap_VectorInt_rend, METH_VARARGS, NULL},
32679          { (char *)"VectorInt_pop_back", _wrap_VectorInt_pop_back, METH_VARARGS, NULL},
32680          { (char *)"VectorInt_erase", _wrap_VectorInt_erase, METH_VARARGS, NULL},
32681          { (char *)"new_VectorInt", _wrap_new_VectorInt, METH_VARARGS, NULL},
32682          { (char *)"VectorInt_push_back", _wrap_VectorInt_push_back, METH_VARARGS, NULL},
32683          { (char *)"VectorInt_front", _wrap_VectorInt_front, METH_VARARGS, NULL},
32684          { (char *)"VectorInt_back", _wrap_VectorInt_back, METH_VARARGS, NULL},
32685          { (char *)"VectorInt_assign", _wrap_VectorInt_assign, METH_VARARGS, NULL},
32686          { (char *)"VectorInt_resize", _wrap_VectorInt_resize, METH_VARARGS, NULL},
32687          { (char *)"VectorInt_insert", _wrap_VectorInt_insert, METH_VARARGS, NULL},
32688          { (char *)"VectorInt_reserve", _wrap_VectorInt_reserve, METH_VARARGS, NULL},
32689          { (char *)"VectorInt_capacity", _wrap_VectorInt_capacity, METH_VARARGS, NULL},
32690          { (char *)"delete_VectorInt", _wrap_delete_VectorInt, METH_VARARGS, NULL},
32691          { (char *)"VectorInt_swigregister", VectorInt_swigregister, METH_VARARGS, NULL},
32692          { (char *)"get_temp_name", _wrap_get_temp_name, METH_VARARGS, NULL},
32693          { (char *)"fatal_error", _wrap_fatal_error, METH_VARARGS, NULL},
32694          { (char *)"prod_scalaire", _wrap_prod_scalaire, METH_VARARGS, NULL},
32695          { (char *)"prod_vectoriel", _wrap_prod_vectoriel, METH_VARARGS, NULL},
32696          { (char *)"prod_mixte", _wrap_prod_mixte, METH_VARARGS, NULL},
32697          { (char *)"deg2radians", _wrap_deg2radians, METH_VARARGS, NULL},
32698          { (char *)"rad2degres", _wrap_rad2degres, METH_VARARGS, NULL},
32699          { (char *)"calc_norme", _wrap_calc_norme, METH_VARARGS, NULL},
32700          { (char *)"calc_distance", _wrap_calc_distance, METH_VARARGS, NULL},
32701          { (char *)"calc_d2", _wrap_calc_d2, METH_VARARGS, NULL},
32702          { (char *)"calc_vecteur", _wrap_calc_vecteur, METH_VARARGS, NULL},
32703          { (char *)"copy_vecteur", _wrap_copy_vecteur, METH_VARARGS, NULL},
32704          { (char *)"calc_milieu", _wrap_calc_milieu, METH_VARARGS, NULL},
32705          { (char *)"normer_vecteur", _wrap_normer_vecteur, METH_VARARGS, NULL},
32706          { (char *)"carre", _wrap_carre, METH_VARARGS, NULL},
32707          { (char *)"same_coords", _wrap_same_coords, METH_VARARGS, NULL},
32708          { (char *)"requals", _wrap_requals, METH_VARARGS, NULL},
32709          { (char *)"on_debug", _wrap_on_debug, METH_VARARGS, NULL},
32710          { (char *)"in_test", _wrap_in_test, METH_VARARGS, NULL},
32711          { (char *)"niv_debug", _wrap_niv_debug, METH_VARARGS, NULL},
32712          { (char *)"set_minus", _wrap_set_minus, METH_VARARGS, NULL},
32713          { (char *)"special_option", _wrap_special_option, METH_VARARGS, NULL},
32714          { (char *)"set_special_option", _wrap_set_special_option, METH_VARARGS, NULL},
32715          { (char *)"sizeof_file", _wrap_sizeof_file, METH_VARARGS, NULL},
32716          { (char *)"read_file", _wrap_read_file, METH_VARARGS, NULL},
32717          { (char *)"get_time", _wrap_get_time, METH_VARARGS, NULL},
32718          { (char *)"make_basename", _wrap_make_basename, METH_VARARGS, NULL},
32719          { (char *)"EltBase_countHexa", _wrap_EltBase_countHexa, METH_VARARGS, NULL},
32720          { (char *)"EltBase_countQuad", _wrap_EltBase_countQuad, METH_VARARGS, NULL},
32721          { (char *)"EltBase_countEdge", _wrap_EltBase_countEdge, METH_VARARGS, NULL},
32722          { (char *)"EltBase_countVertex", _wrap_EltBase_countVertex, METH_VARARGS, NULL},
32723          { (char *)"EltBase_setError", _wrap_EltBase_setError, METH_VARARGS, NULL},
32724          { (char *)"EltBase_getError", _wrap_EltBase_getError, METH_VARARGS, NULL},
32725          { (char *)"EltBase_isValid", _wrap_EltBase_isValid, METH_VARARGS, NULL},
32726          { (char *)"EltBase_isBad", _wrap_EltBase_isBad, METH_VARARGS, NULL},
32727          { (char *)"EltBase_duplicate", _wrap_EltBase_duplicate, METH_VARARGS, NULL},
32728          { (char *)"EltBase_clearAssociation", _wrap_EltBase_clearAssociation, METH_VARARGS, NULL},
32729          { (char *)"EltBase_replaceEdge", _wrap_EltBase_replaceEdge, METH_VARARGS, NULL},
32730          { (char *)"EltBase_replaceVertex", _wrap_EltBase_replaceVertex, METH_VARARGS, NULL},
32731          { (char *)"new_EltBase", _wrap_new_EltBase, METH_VARARGS, NULL},
32732          { (char *)"delete_EltBase", _wrap_delete_EltBase, METH_VARARGS, NULL},
32733          { (char *)"EltBase_remove", _wrap_EltBase_remove, METH_VARARGS, NULL},
32734          { (char *)"EltBase_suppress", _wrap_EltBase_suppress, METH_VARARGS, NULL},
32735          { (char *)"EltBase_dump", _wrap_EltBase_dump, METH_VARARGS, NULL},
32736          { (char *)"EltBase_saveXml", _wrap_EltBase_saveXml, METH_VARARGS, NULL},
32737          { (char *)"EltBase_majReferences", _wrap_EltBase_majReferences, METH_VARARGS, NULL},
32738          { (char *)"EltBase_makeVarName", _wrap_EltBase_makeVarName, METH_VARARGS, NULL},
32739          { (char *)"EltBase_makeName", _wrap_EltBase_makeName, METH_VARARGS, NULL},
32740          { (char *)"EltBase_next", _wrap_EltBase_next, METH_VARARGS, NULL},
32741          { (char *)"EltBase_setNext", _wrap_EltBase_setNext, METH_VARARGS, NULL},
32742          { (char *)"EltBase_getId", _wrap_EltBase_getId, METH_VARARGS, NULL},
32743          { (char *)"EltBase_setId", _wrap_EltBase_setId, METH_VARARGS, NULL},
32744          { (char *)"EltBase_dad", _wrap_EltBase_dad, METH_VARARGS, NULL},
32745          { (char *)"EltBase_getType", _wrap_EltBase_getType, METH_VARARGS, NULL},
32746          { (char *)"EltBase_isHere", _wrap_EltBase_isHere, METH_VARARGS, NULL},
32747          { (char *)"EltBase_isDeleted", _wrap_EltBase_isDeleted, METH_VARARGS, NULL},
32748          { (char *)"EltBase_razReferences", _wrap_EltBase_razReferences, METH_VARARGS, NULL},
32749          { (char *)"EltBase_addParent", _wrap_EltBase_addParent, METH_VARARGS, NULL},
32750          { (char *)"EltBase_getNbrParents", _wrap_EltBase_getNbrParents, METH_VARARGS, NULL},
32751          { (char *)"EltBase_hasParents", _wrap_EltBase_hasParents, METH_VARARGS, NULL},
32752          { (char *)"EltBase_getFather", _wrap_EltBase_getFather, METH_VARARGS, NULL},
32753          { (char *)"EltBase_getMark", _wrap_EltBase_getMark, METH_VARARGS, NULL},
32754          { (char *)"EltBase_setMark", _wrap_EltBase_setMark, METH_VARARGS, NULL},
32755          { (char *)"EltBase_printName", _wrap_EltBase_printName, METH_VARARGS, NULL},
32756          { (char *)"EltBase_dumpRef", _wrap_EltBase_dumpRef, METH_VARARGS, NULL},
32757          { (char *)"EltBase_getName", _wrap_EltBase_getName, METH_VARARGS, NULL},
32758          { (char *)"EltBase_setName", _wrap_EltBase_setName, METH_VARARGS, NULL},
32759          { (char *)"EltBase_debug", _wrap_EltBase_debug, METH_VARARGS, NULL},
32760          { (char *)"EltBase_isAssociated", _wrap_EltBase_isAssociated, METH_VARARGS, NULL},
32761          { (char *)"EltBase_getNextName", _wrap_EltBase_getNextName, METH_VARARGS, NULL},
32762          { (char *)"EltBase_swigregister", EltBase_swigregister, METH_VARARGS, NULL},
32763          { (char *)"Vertex_getX", _wrap_Vertex_getX, METH_VARARGS, NULL},
32764          { (char *)"Vertex_getY", _wrap_Vertex_getY, METH_VARARGS, NULL},
32765          { (char *)"Vertex_getZ", _wrap_Vertex_getZ, METH_VARARGS, NULL},
32766          { (char *)"Vertex_setX", _wrap_Vertex_setX, METH_VARARGS, NULL},
32767          { (char *)"Vertex_setY", _wrap_Vertex_setY, METH_VARARGS, NULL},
32768          { (char *)"Vertex_setZ", _wrap_Vertex_setZ, METH_VARARGS, NULL},
32769          { (char *)"Vertex_getAssoX", _wrap_Vertex_getAssoX, METH_VARARGS, NULL},
32770          { (char *)"Vertex_getAssoY", _wrap_Vertex_getAssoY, METH_VARARGS, NULL},
32771          { (char *)"Vertex_getAssoZ", _wrap_Vertex_getAssoZ, METH_VARARGS, NULL},
32772          { (char *)"Vertex_setAssociation", _wrap_Vertex_setAssociation, METH_VARARGS, NULL},
32773          { (char *)"Vertex_clearAssociation", _wrap_Vertex_clearAssociation, METH_VARARGS, NULL},
32774          { (char *)"Vertex_setColor", _wrap_Vertex_setColor, METH_VARARGS, NULL},
32775          { (char *)"new_Vertex", _wrap_new_Vertex, METH_VARARGS, NULL},
32776          { (char *)"delete_Vertex", _wrap_delete_Vertex, METH_VARARGS, NULL},
32777          { (char *)"Vertex_swigregister", Vertex_swigregister, METH_VARARGS, NULL},
32778          { (char *)"Edge_getVertex", _wrap_Edge_getVertex, METH_VARARGS, NULL},
32779          { (char *)"Edge_addAssociation", _wrap_Edge_addAssociation, METH_VARARGS, NULL},
32780          { (char *)"Edge_setAssociation", _wrap_Edge_setAssociation, METH_VARARGS, NULL},
32781          { (char *)"Edge_findAssociation", _wrap_Edge_findAssociation, METH_VARARGS, NULL},
32782          { (char *)"Edge_clearAssociation", _wrap_Edge_clearAssociation, METH_VARARGS, NULL},
32783          { (char *)"Edge_setColor", _wrap_Edge_setColor, METH_VARARGS, NULL},
32784          { (char *)"Edge_getWay", _wrap_Edge_getWay, METH_VARARGS, NULL},
32785          { (char *)"Edge_getLength", _wrap_Edge_getLength, METH_VARARGS, NULL},
32786          { (char *)"new_Edge", _wrap_new_Edge, METH_VARARGS, NULL},
32787          { (char *)"delete_Edge", _wrap_delete_Edge, METH_VARARGS, NULL},
32788          { (char *)"Edge_swigregister", Edge_swigregister, METH_VARARGS, NULL},
32789          { (char *)"Quad_getEdge", _wrap_Quad_getEdge, METH_VARARGS, NULL},
32790          { (char *)"Quad_getVertex", _wrap_Quad_getVertex, METH_VARARGS, NULL},
32791          { (char *)"Quad_addAssociation", _wrap_Quad_addAssociation, METH_VARARGS, NULL},
32792          { (char *)"Quad_clearAssociation", _wrap_Quad_clearAssociation, METH_VARARGS, NULL},
32793          { (char *)"Quad_setColor", _wrap_Quad_setColor, METH_VARARGS, NULL},
32794          { (char *)"Quad_nearestVertex", _wrap_Quad_nearestVertex, METH_VARARGS, NULL},
32795          { (char *)"Quad_getCenter", _wrap_Quad_getCenter, METH_VARARGS, NULL},
32796          { (char *)"new_Quad", _wrap_new_Quad, METH_VARARGS, NULL},
32797          { (char *)"delete_Quad", _wrap_delete_Quad, METH_VARARGS, NULL},
32798          { (char *)"Quad_swigregister", Quad_swigregister, METH_VARARGS, NULL},
32799          { (char *)"Hexa_getQuad", _wrap_Hexa_getQuad, METH_VARARGS, NULL},
32800          { (char *)"Hexa_getEdge", _wrap_Hexa_getEdge, METH_VARARGS, NULL},
32801          { (char *)"Hexa_getVertex", _wrap_Hexa_getVertex, METH_VARARGS, NULL},
32802          { (char *)"Hexa_setColor", _wrap_Hexa_setColor, METH_VARARGS, NULL},
32803          { (char *)"new_Hexa", _wrap_new_Hexa, METH_VARARGS, NULL},
32804          { (char *)"delete_Hexa", _wrap_delete_Hexa, METH_VARARGS, NULL},
32805          { (char *)"Hexa_swigregister", Hexa_swigregister, METH_VARARGS, NULL},
32806          { (char *)"Vector_getDx", _wrap_Vector_getDx, METH_VARARGS, NULL},
32807          { (char *)"Vector_getDy", _wrap_Vector_getDy, METH_VARARGS, NULL},
32808          { (char *)"Vector_getDz", _wrap_Vector_getDz, METH_VARARGS, NULL},
32809          { (char *)"Vector_getNorm", _wrap_Vector_getNorm, METH_VARARGS, NULL},
32810          { (char *)"Vector_getAngleX", _wrap_Vector_getAngleX, METH_VARARGS, NULL},
32811          { (char *)"new_Vector", _wrap_new_Vector, METH_VARARGS, NULL},
32812          { (char *)"delete_Vector", _wrap_delete_Vector, METH_VARARGS, NULL},
32813          { (char *)"Vector_swigregister", Vector_swigregister, METH_VARARGS, NULL},
32814          { (char *)"new_Document", _wrap_new_Document, METH_VARARGS, NULL},
32815          { (char *)"Document_dump", _wrap_Document_dump, METH_VARARGS, NULL},
32816          { (char *)"Document_setName", _wrap_Document_setName, METH_VARARGS, NULL},
32817          { (char *)"Document_setLevel", _wrap_Document_setLevel, METH_VARARGS, NULL},
32818          { (char *)"Document_save", _wrap_Document_save, METH_VARARGS, NULL},
32819          { (char *)"Document_saveVtk", _wrap_Document_saveVtk, METH_VARARGS, NULL},
32820          { (char *)"Document_purge", _wrap_Document_purge, METH_VARARGS, NULL},
32821          { (char *)"Document_setTolerance", _wrap_Document_setTolerance, METH_VARARGS, NULL},
32822          { (char *)"Document_getTolerance", _wrap_Document_getTolerance, METH_VARARGS, NULL},
32823          { (char *)"Document_addVertex", _wrap_Document_addVertex, METH_VARARGS, NULL},
32824          { (char *)"Document_addEdge", _wrap_Document_addEdge, METH_VARARGS, NULL},
32825          { (char *)"Document_addEdgeVector", _wrap_Document_addEdgeVector, METH_VARARGS, NULL},
32826          { (char *)"Document_addQuad", _wrap_Document_addQuad, METH_VARARGS, NULL},
32827          { (char *)"Document_addQuadVertices", _wrap_Document_addQuadVertices, METH_VARARGS, NULL},
32828          { (char *)"Document_addHexa", _wrap_Document_addHexa, METH_VARARGS, NULL},
32829          { (char *)"Document_addHexaVertices", _wrap_Document_addHexaVertices, METH_VARARGS, NULL},
32830          { (char *)"Document_addHexa2Quads", _wrap_Document_addHexa2Quads, METH_VARARGS, NULL},
32831          { (char *)"Document_addHexa3Quads", _wrap_Document_addHexa3Quads, METH_VARARGS, NULL},
32832          { (char *)"Document_addHexa4Quads", _wrap_Document_addHexa4Quads, METH_VARARGS, NULL},
32833          { (char *)"Document_addHexa5Quads", _wrap_Document_addHexa5Quads, METH_VARARGS, NULL},
32834          { (char *)"Document_addVector", _wrap_Document_addVector, METH_VARARGS, NULL},
32835          { (char *)"Document_addVectorVertices", _wrap_Document_addVectorVertices, METH_VARARGS, NULL},
32836          { (char *)"Document_addLaws", _wrap_Document_addLaws, METH_VARARGS, NULL},
32837          { (char *)"Document_addHexaGroup", _wrap_Document_addHexaGroup, METH_VARARGS, NULL},
32838          { (char *)"Document_addQuadGroup", _wrap_Document_addQuadGroup, METH_VARARGS, NULL},
32839          { (char *)"Document_addQuadNodeGroup", _wrap_Document_addQuadNodeGroup, METH_VARARGS, NULL},
32840          { (char *)"Document_addHexaNodeGroup", _wrap_Document_addHexaNodeGroup, METH_VARARGS, NULL},
32841          { (char *)"Document_addEdgeGroup", _wrap_Document_addEdgeGroup, METH_VARARGS, NULL},
32842          { (char *)"Document_addEdgeNodeGroup", _wrap_Document_addEdgeNodeGroup, METH_VARARGS, NULL},
32843          { (char *)"Document_addVertexNodeGroup", _wrap_Document_addVertexNodeGroup, METH_VARARGS, NULL},
32844          { (char *)"Document_makeTranslation", _wrap_Document_makeTranslation, METH_VARARGS, NULL},
32845          { (char *)"Document_makeScale", _wrap_Document_makeScale, METH_VARARGS, NULL},
32846          { (char *)"Document_makeRotation", _wrap_Document_makeRotation, METH_VARARGS, NULL},
32847          { (char *)"Document_makeSymmetryPoint", _wrap_Document_makeSymmetryPoint, METH_VARARGS, NULL},
32848          { (char *)"Document_makeSymmetryLine", _wrap_Document_makeSymmetryLine, METH_VARARGS, NULL},
32849          { (char *)"Document_makeSymmetryPlane", _wrap_Document_makeSymmetryPlane, METH_VARARGS, NULL},
32850          { (char *)"Document_performTranslation", _wrap_Document_performTranslation, METH_VARARGS, NULL},
32851          { (char *)"Document_performScale", _wrap_Document_performScale, METH_VARARGS, NULL},
32852          { (char *)"Document_performRotation", _wrap_Document_performRotation, METH_VARARGS, NULL},
32853          { (char *)"Document_performSymmetryPoint", _wrap_Document_performSymmetryPoint, METH_VARARGS, NULL},
32854          { (char *)"Document_performSymmetryLine", _wrap_Document_performSymmetryLine, METH_VARARGS, NULL},
32855          { (char *)"Document_performSymmetryPlane", _wrap_Document_performSymmetryPlane, METH_VARARGS, NULL},
32856          { (char *)"Document_disconnectQuad", _wrap_Document_disconnectQuad, METH_VARARGS, NULL},
32857          { (char *)"Document_disconnectEdge", _wrap_Document_disconnectEdge, METH_VARARGS, NULL},
32858          { (char *)"Document_disconnectVertex", _wrap_Document_disconnectVertex, METH_VARARGS, NULL},
32859          { (char *)"Document_disconnectEdges", _wrap_Document_disconnectEdges, METH_VARARGS, NULL},
32860          { (char *)"Document_replace", _wrap_Document_replace, METH_VARARGS, NULL},
32861          { (char *)"Document_mergeVertices", _wrap_Document_mergeVertices, METH_VARARGS, NULL},
32862          { (char *)"Document_mergeEdges", _wrap_Document_mergeEdges, METH_VARARGS, NULL},
32863          { (char *)"Document_mergeQuads", _wrap_Document_mergeQuads, METH_VARARGS, NULL},
32864          { (char *)"Document_clearAssociation", _wrap_Document_clearAssociation, METH_VARARGS, NULL},
32865          { (char *)"Document_associateOpenedLine", _wrap_Document_associateOpenedLine, METH_VARARGS, NULL},
32866          { (char *)"Document_associateClosedLine", _wrap_Document_associateClosedLine, METH_VARARGS, NULL},
32867          { (char *)"Document_countHexa", _wrap_Document_countHexa, METH_VARARGS, NULL},
32868          { (char *)"Document_countQuad", _wrap_Document_countQuad, METH_VARARGS, NULL},
32869          { (char *)"Document_countEdge", _wrap_Document_countEdge, METH_VARARGS, NULL},
32870          { (char *)"Document_countVertex", _wrap_Document_countVertex, METH_VARARGS, NULL},
32871          { (char *)"Document_countVector", _wrap_Document_countVector, METH_VARARGS, NULL},
32872          { (char *)"Document_countGroup", _wrap_Document_countGroup, METH_VARARGS, NULL},
32873          { (char *)"Document_countLaw", _wrap_Document_countLaw, METH_VARARGS, NULL},
32874          { (char *)"Document_countPropagation", _wrap_Document_countPropagation, METH_VARARGS, NULL},
32875          { (char *)"Document_countShape", _wrap_Document_countShape, METH_VARARGS, NULL},
32876          { (char *)"Document_countUsedHexa", _wrap_Document_countUsedHexa, METH_VARARGS, NULL},
32877          { (char *)"Document_countUsedQuad", _wrap_Document_countUsedQuad, METH_VARARGS, NULL},
32878          { (char *)"Document_countUsedEdge", _wrap_Document_countUsedEdge, METH_VARARGS, NULL},
32879          { (char *)"Document_countUsedVertex", _wrap_Document_countUsedVertex, METH_VARARGS, NULL},
32880          { (char *)"Document_getHexa", _wrap_Document_getHexa, METH_VARARGS, NULL},
32881          { (char *)"Document_getQuad", _wrap_Document_getQuad, METH_VARARGS, NULL},
32882          { (char *)"Document_getEdge", _wrap_Document_getEdge, METH_VARARGS, NULL},
32883          { (char *)"Document_getVertex", _wrap_Document_getVertex, METH_VARARGS, NULL},
32884          { (char *)"Document_getUsedHexa", _wrap_Document_getUsedHexa, METH_VARARGS, NULL},
32885          { (char *)"Document_getUsedQuad", _wrap_Document_getUsedQuad, METH_VARARGS, NULL},
32886          { (char *)"Document_getUsedEdge", _wrap_Document_getUsedEdge, METH_VARARGS, NULL},
32887          { (char *)"Document_getUsedVertex", _wrap_Document_getUsedVertex, METH_VARARGS, NULL},
32888          { (char *)"Document_getVector", _wrap_Document_getVector, METH_VARARGS, NULL},
32889          { (char *)"Document_getShape", _wrap_Document_getShape, METH_VARARGS, NULL},
32890          { (char *)"Document_getGroup", _wrap_Document_getGroup, METH_VARARGS, NULL},
32891          { (char *)"Document_getLaw", _wrap_Document_getLaw, METH_VARARGS, NULL},
32892          { (char *)"Document_getPropagation", _wrap_Document_getPropagation, METH_VARARGS, NULL},
32893          { (char *)"Document_getFirstExplicitShape", _wrap_Document_getFirstExplicitShape, METH_VARARGS, NULL},
32894          { (char *)"Document_findEdge", _wrap_Document_findEdge, METH_VARARGS, NULL},
32895          { (char *)"Document_findQuad", _wrap_Document_findQuad, METH_VARARGS, NULL},
32896          { (char *)"Document_findHexa", _wrap_Document_findHexa, METH_VARARGS, NULL},
32897          { (char *)"Document_findGroup", _wrap_Document_findGroup, METH_VARARGS, NULL},
32898          { (char *)"Document_findLaw", _wrap_Document_findLaw, METH_VARARGS, NULL},
32899          { (char *)"Document_findPropagation", _wrap_Document_findPropagation, METH_VARARGS, NULL},
32900          { (char *)"Document_removeHexa", _wrap_Document_removeHexa, METH_VARARGS, NULL},
32901          { (char *)"Document_removeQuad", _wrap_Document_removeQuad, METH_VARARGS, NULL},
32902          { (char *)"Document_removeConnectedHexa", _wrap_Document_removeConnectedHexa, METH_VARARGS, NULL},
32903          { (char *)"Document_removeElements", _wrap_Document_removeElements, METH_VARARGS, NULL},
32904          { (char *)"Document_removeGroup", _wrap_Document_removeGroup, METH_VARARGS, NULL},
32905          { (char *)"Document_removeLaw", _wrap_Document_removeLaw, METH_VARARGS, NULL},
32906          { (char *)"Document_makeCartesianTop", _wrap_Document_makeCartesianTop, METH_VARARGS, NULL},
32907          { (char *)"Document_makeCartesianUni", _wrap_Document_makeCartesianUni, METH_VARARGS, NULL},
32908          { (char *)"Document_makeCartesian", _wrap_Document_makeCartesian, METH_VARARGS, NULL},
32909          { (char *)"Document_makeCylinderTop", _wrap_Document_makeCylinderTop, METH_VARARGS, NULL},
32910          { (char *)"Document_makeCylinderUni", _wrap_Document_makeCylinderUni, METH_VARARGS, NULL},
32911          { (char *)"Document_makeCylinder", _wrap_Document_makeCylinder, METH_VARARGS, NULL},
32912          { (char *)"Document_makePipeTop", _wrap_Document_makePipeTop, METH_VARARGS, NULL},
32913          { (char *)"Document_makePipeUni", _wrap_Document_makePipeUni, METH_VARARGS, NULL},
32914          { (char *)"Document_makePipe", _wrap_Document_makePipe, METH_VARARGS, NULL},
32915          { (char *)"Document_makeSphericalTop", _wrap_Document_makeSphericalTop, METH_VARARGS, NULL},
32916          { (char *)"Document_makeSphericalUni", _wrap_Document_makeSphericalUni, METH_VARARGS, NULL},
32917          { (char *)"Document_makeSpherical", _wrap_Document_makeSpherical, METH_VARARGS, NULL},
32918          { (char *)"Document_makeSphereTop", _wrap_Document_makeSphereTop, METH_VARARGS, NULL},
32919          { (char *)"Document_makeSphereUni", _wrap_Document_makeSphereUni, METH_VARARGS, NULL},
32920          { (char *)"Document_makeSphere", _wrap_Document_makeSphere, METH_VARARGS, NULL},
32921          { (char *)"Document_makeRindTop", _wrap_Document_makeRindTop, METH_VARARGS, NULL},
32922          { (char *)"Document_makeRindUni", _wrap_Document_makeRindUni, METH_VARARGS, NULL},
32923          { (char *)"Document_makeRind", _wrap_Document_makeRind, METH_VARARGS, NULL},
32924          { (char *)"Document_makeCylinders", _wrap_Document_makeCylinders, METH_VARARGS, NULL},
32925          { (char *)"Document_makePipes", _wrap_Document_makePipes, METH_VARARGS, NULL},
32926          { (char *)"Document_extrudeQuadTop", _wrap_Document_extrudeQuadTop, METH_VARARGS, NULL},
32927          { (char *)"Document_extrudeQuadUni", _wrap_Document_extrudeQuadUni, METH_VARARGS, NULL},
32928          { (char *)"Document_extrudeQuad", _wrap_Document_extrudeQuad, METH_VARARGS, NULL},
32929          { (char *)"Document_extrudeQuadsTop", _wrap_Document_extrudeQuadsTop, METH_VARARGS, NULL},
32930          { (char *)"Document_extrudeQuadsUni", _wrap_Document_extrudeQuadsUni, METH_VARARGS, NULL},
32931          { (char *)"Document_extrudeQuads", _wrap_Document_extrudeQuads, METH_VARARGS, NULL},
32932          { (char *)"Document_revolutionQuadUni", _wrap_Document_revolutionQuadUni, METH_VARARGS, NULL},
32933          { (char *)"Document_revolutionQuad", _wrap_Document_revolutionQuad, METH_VARARGS, NULL},
32934          { (char *)"Document_revolutionQuadsUni", _wrap_Document_revolutionQuadsUni, METH_VARARGS, NULL},
32935          { (char *)"Document_revolutionQuads", _wrap_Document_revolutionQuads, METH_VARARGS, NULL},
32936          { (char *)"Document_joinQuadUni", _wrap_Document_joinQuadUni, METH_VARARGS, NULL},
32937          { (char *)"Document_joinQuadsUni", _wrap_Document_joinQuadsUni, METH_VARARGS, NULL},
32938          { (char *)"Document_joinQuad", _wrap_Document_joinQuad, METH_VARARGS, NULL},
32939          { (char *)"Document_joinQuads", _wrap_Document_joinQuads, METH_VARARGS, NULL},
32940          { (char *)"Document_cutUni", _wrap_Document_cutUni, METH_VARARGS, NULL},
32941          { (char *)"Document_cut", _wrap_Document_cut, METH_VARARGS, NULL},
32942          { (char *)"Document_addGroup", _wrap_Document_addGroup, METH_VARARGS, NULL},
32943          { (char *)"Document_isSaved", _wrap_Document_isSaved, METH_VARARGS, NULL},
32944          { (char *)"Document_appendXml", _wrap_Document_appendXml, METH_VARARGS, NULL},
32945          { (char *)"Document_getXml", _wrap_Document_getXml, METH_VARARGS, NULL},
32946          { (char *)"Document_getLevel", _wrap_Document_getLevel, METH_VARARGS, NULL},
32947          { (char *)"Document_findVertex", _wrap_Document_findVertex, METH_VARARGS, NULL},
32948          { (char *)"Document_closeQuads", _wrap_Document_closeQuads, METH_VARARGS, NULL},
32949          { (char *)"Document_addLaw", _wrap_Document_addLaw, METH_VARARGS, NULL},
32950          { (char *)"Document_checkAssociations", _wrap_Document_checkAssociations, METH_VARARGS, NULL},
32951          { (char *)"Document_addShape", _wrap_Document_addShape, METH_VARARGS, NULL},
32952          { (char *)"delete_Document", _wrap_delete_Document, METH_VARARGS, NULL},
32953          { (char *)"Document_swigregister", Document_swigregister, METH_VARARGS, NULL},
32954          { (char *)"Propagation_getEdges", _wrap_Propagation_getEdges, METH_VARARGS, NULL},
32955          { (char *)"Propagation_getLaw", _wrap_Propagation_getLaw, METH_VARARGS, NULL},
32956          { (char *)"Propagation_getWay", _wrap_Propagation_getWay, METH_VARARGS, NULL},
32957          { (char *)"Propagation_setWay", _wrap_Propagation_setWay, METH_VARARGS, NULL},
32958          { (char *)"Propagation_setLaw", _wrap_Propagation_setLaw, METH_VARARGS, NULL},
32959          { (char *)"new_Propagation", _wrap_new_Propagation, METH_VARARGS, NULL},
32960          { (char *)"Propagation_saveXml", _wrap_Propagation_saveXml, METH_VARARGS, NULL},
32961          { (char *)"Propagation_addEdge", _wrap_Propagation_addEdge, METH_VARARGS, NULL},
32962          { (char *)"Propagation_majLaw", _wrap_Propagation_majLaw, METH_VARARGS, NULL},
32963          { (char *)"delete_Propagation", _wrap_delete_Propagation, METH_VARARGS, NULL},
32964          { (char *)"Propagation_swigregister", Propagation_swigregister, METH_VARARGS, NULL},
32965          { (char *)"hex_instance", _wrap_hex_instance, METH_VARARGS, NULL},
32966          { (char *)"Hex_getInstance", _wrap_Hex_getInstance, METH_VARARGS, NULL},
32967          { (char *)"Hex_countDocument", _wrap_Hex_countDocument, METH_VARARGS, NULL},
32968          { (char *)"Hex_getDocument", _wrap_Hex_getDocument, METH_VARARGS, NULL},
32969          { (char *)"Hex_removeDocument", _wrap_Hex_removeDocument, METH_VARARGS, NULL},
32970          { (char *)"Hex_addDocument", _wrap_Hex_addDocument, METH_VARARGS, NULL},
32971          { (char *)"Hex_loadDocument", _wrap_Hex_loadDocument, METH_VARARGS, NULL},
32972          { (char *)"Hex_findDocument", _wrap_Hex_findDocument, METH_VARARGS, NULL},
32973          { (char *)"Hex_what", _wrap_Hex_what, METH_VARARGS, NULL},
32974          { (char *)"Hex_sizeofMessage", _wrap_Hex_sizeofMessage, METH_VARARGS, NULL},
32975          { (char *)"Hex_getMessageLine", _wrap_Hex_getMessageLine, METH_VARARGS, NULL},
32976          { (char *)"new_Hex", _wrap_new_Hex, METH_VARARGS, NULL},
32977          { (char *)"delete_Hex", _wrap_delete_Hex, METH_VARARGS, NULL},
32978          { (char *)"Hex_swigregister", Hex_swigregister, METH_VARARGS, NULL},
32979          { (char *)"what", _wrap_what, METH_VARARGS, NULL},
32980          { (char *)"Elements_getHexa", _wrap_Elements_getHexa, METH_VARARGS, NULL},
32981          { (char *)"Elements_getQuad", _wrap_Elements_getQuad, METH_VARARGS, NULL},
32982          { (char *)"Elements_getEdge", _wrap_Elements_getEdge, METH_VARARGS, NULL},
32983          { (char *)"Elements_getVertex", _wrap_Elements_getVertex, METH_VARARGS, NULL},
32984          { (char *)"Elements_getHexaIJK", _wrap_Elements_getHexaIJK, METH_VARARGS, NULL},
32985          { (char *)"Elements_getQuadIJ", _wrap_Elements_getQuadIJ, METH_VARARGS, NULL},
32986          { (char *)"Elements_getQuadJK", _wrap_Elements_getQuadJK, METH_VARARGS, NULL},
32987          { (char *)"Elements_getQuadIK", _wrap_Elements_getQuadIK, METH_VARARGS, NULL},
32988          { (char *)"Elements_getEdgeI", _wrap_Elements_getEdgeI, METH_VARARGS, NULL},
32989          { (char *)"Elements_getEdgeJ", _wrap_Elements_getEdgeJ, METH_VARARGS, NULL},
32990          { (char *)"Elements_getEdgeK", _wrap_Elements_getEdgeK, METH_VARARGS, NULL},
32991          { (char *)"Elements_getVertexIJK", _wrap_Elements_getVertexIJK, METH_VARARGS, NULL},
32992          { (char *)"Elements_countHexa", _wrap_Elements_countHexa, METH_VARARGS, NULL},
32993          { (char *)"Elements_countQuad", _wrap_Elements_countQuad, METH_VARARGS, NULL},
32994          { (char *)"Elements_countEdge", _wrap_Elements_countEdge, METH_VARARGS, NULL},
32995          { (char *)"Elements_countVertex", _wrap_Elements_countVertex, METH_VARARGS, NULL},
32996          { (char *)"Elements_nearestVertex", _wrap_Elements_nearestVertex, METH_VARARGS, NULL},
32997          { (char *)"Elements_findVertex", _wrap_Elements_findVertex, METH_VARARGS, NULL},
32998          { (char *)"Elements_clearAssociation", _wrap_Elements_clearAssociation, METH_VARARGS, NULL},
32999          { (char *)"Elements_saveVtk", _wrap_Elements_saveVtk, METH_VARARGS, NULL},
33000          { (char *)"new_Elements", _wrap_new_Elements, METH_VARARGS, NULL},
33001          { (char *)"delete_Elements", _wrap_delete_Elements, METH_VARARGS, NULL},
33002          { (char *)"Elements_swigregister", Elements_swigregister, METH_VARARGS, NULL},
33003          { (char *)"new_BiCylinder", _wrap_new_BiCylinder, METH_VARARGS, NULL},
33004          { (char *)"BiCylinder_getHexaIJK", _wrap_BiCylinder_getHexaIJK, METH_VARARGS, NULL},
33005          { (char *)"BiCylinder_getQuadIJ", _wrap_BiCylinder_getQuadIJ, METH_VARARGS, NULL},
33006          { (char *)"BiCylinder_getQuadJK", _wrap_BiCylinder_getQuadJK, METH_VARARGS, NULL},
33007          { (char *)"BiCylinder_getQuadIK", _wrap_BiCylinder_getQuadIK, METH_VARARGS, NULL},
33008          { (char *)"BiCylinder_getEdgeI", _wrap_BiCylinder_getEdgeI, METH_VARARGS, NULL},
33009          { (char *)"BiCylinder_getEdgeJ", _wrap_BiCylinder_getEdgeJ, METH_VARARGS, NULL},
33010          { (char *)"BiCylinder_getEdgeK", _wrap_BiCylinder_getEdgeK, METH_VARARGS, NULL},
33011          { (char *)"BiCylinder_getVertexIJK", _wrap_BiCylinder_getVertexIJK, METH_VARARGS, NULL},
33012          { (char *)"delete_BiCylinder", _wrap_delete_BiCylinder, METH_VARARGS, NULL},
33013          { (char *)"BiCylinder_swigregister", BiCylinder_swigregister, METH_VARARGS, NULL},
33014          { (char *)"NewShape_countVertex", _wrap_NewShape_countVertex, METH_VARARGS, NULL},
33015          { (char *)"NewShape_countEdge", _wrap_NewShape_countEdge, METH_VARARGS, NULL},
33016          { (char *)"NewShape_countFace", _wrap_NewShape_countFace, METH_VARARGS, NULL},
33017          { (char *)"NewShape_getVertex", _wrap_NewShape_getVertex, METH_VARARGS, NULL},
33018          { (char *)"NewShape_getEdge", _wrap_NewShape_getEdge, METH_VARARGS, NULL},
33019          { (char *)"NewShape_getFace", _wrap_NewShape_getFace, METH_VARARGS, NULL},
33020          { (char *)"NewShape_getNameVertex", _wrap_NewShape_getNameVertex, METH_VARARGS, NULL},
33021          { (char *)"NewShape_getNameEdge", _wrap_NewShape_getNameEdge, METH_VARARGS, NULL},
33022          { (char *)"NewShape_getNameFace", _wrap_NewShape_getNameFace, METH_VARARGS, NULL},
33023          { (char *)"new_NewShape", _wrap_new_NewShape, METH_VARARGS, NULL},
33024          { (char *)"delete_NewShape", _wrap_delete_NewShape, METH_VARARGS, NULL},
33025          { (char *)"NewShape_swigregister", NewShape_swigregister, METH_VARARGS, NULL},
33026          { (char *)"Group_addElement", _wrap_Group_addElement, METH_VARARGS, NULL},
33027          { (char *)"Group_countElement", _wrap_Group_countElement, METH_VARARGS, NULL},
33028          { (char *)"Group_getKind", _wrap_Group_getKind, METH_VARARGS, NULL},
33029          { (char *)"Group_clearElement", _wrap_Group_clearElement, METH_VARARGS, NULL},
33030          { (char *)"Group_removeElement", _wrap_Group_removeElement, METH_VARARGS, NULL},
33031          { (char *)"Group_getElement", _wrap_Group_getElement, METH_VARARGS, NULL},
33032          { (char *)"new_Group", _wrap_new_Group, METH_VARARGS, NULL},
33033          { (char *)"delete_Group", _wrap_delete_Group, METH_VARARGS, NULL},
33034          { (char *)"Group_swigregister", Group_swigregister, METH_VARARGS, NULL},
33035          { NULL, NULL, 0, NULL }
33036 };
33037
33038
33039 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
33040
33041 static void *_p_Hex__VectorTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33042     return (void *)((Hex::EltBase *)  ((Hex::Vector *) x));
33043 }
33044 static void *_p_Hex__NewShapeTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33045     return (void *)((Hex::EltBase *)  ((Hex::NewShape *) x));
33046 }
33047 static void *_p_Hex__GroupTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33048     return (void *)((Hex::EltBase *)  ((Hex::Group *) x));
33049 }
33050 static void *_p_Hex__PropagationTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33051     return (void *)((Hex::EltBase *)  ((Hex::Propagation *) x));
33052 }
33053 static void *_p_Hex__VertexTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33054     return (void *)((Hex::EltBase *)  ((Hex::Vertex *) x));
33055 }
33056 static void *_p_Hex__HexaTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33057     return (void *)((Hex::EltBase *)  ((Hex::Hexa *) x));
33058 }
33059 static void *_p_Hex__EdgeTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33060     return (void *)((Hex::EltBase *)  ((Hex::Edge *) x));
33061 }
33062 static void *_p_Hex__QuadTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33063     return (void *)((Hex::EltBase *)  ((Hex::Quad *) x));
33064 }
33065 static void *_p_Hex__ElementsTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33066     return (void *)((Hex::EltBase *)  ((Hex::Elements *) x));
33067 }
33068 static void *_p_Hex__DocumentTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33069     return (void *)((Hex::EltBase *)  ((Hex::Document *) x));
33070 }
33071 static void *_p_Hex__BiCylinderTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33072     return (void *)((Hex::EltBase *) (Hex::Elements *) ((Hex::BiCylinder *) x));
33073 }
33074 static void *_p_Hex__BiCylinderTo_p_Hex__Elements(void *x, int *SWIGUNUSEDPARM(newmemory)) {
33075     return (void *)((Hex::Elements *)  ((Hex::BiCylinder *) x));
33076 }
33077 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *|pfile", 0, 0, (void*)0, 0};
33078 static swig_type_info _swigt__p_Hex__BiCylinder = {"_p_Hex__BiCylinder", "Hex::BiCylinder *", 0, 0, (void*)0, 0};
33079 static swig_type_info _swigt__p_Hex__Document = {"_p_Hex__Document", "Hex::Document *", 0, 0, (void*)0, 0};
33080 static swig_type_info _swigt__p_Hex__Edge = {"_p_Hex__Edge", "Hex::Edge *", 0, 0, (void*)0, 0};
33081 static swig_type_info _swigt__p_Hex__Elements = {"_p_Hex__Elements", "Hex::Elements *", 0, 0, (void*)0, 0};
33082 static swig_type_info _swigt__p_Hex__EltBase = {"_p_Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
33083 static swig_type_info _swigt__p_Hex__Group = {"_p_Hex__Group", "Hex::Group *", 0, 0, (void*)0, 0};
33084 static swig_type_info _swigt__p_Hex__Hex = {"_p_Hex__Hex", "Hex::Hex *", 0, 0, (void*)0, 0};
33085 static swig_type_info _swigt__p_Hex__Hex__EltBase = {"_p_Hex__Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
33086 static swig_type_info _swigt__p_Hex__Hexa = {"_p_Hex__Hexa", "Hex::Hexa *", 0, 0, (void*)0, 0};
33087 static swig_type_info _swigt__p_Hex__Law = {"_p_Hex__Law", "Hex::Law *", 0, 0, (void*)0, 0};
33088 static swig_type_info _swigt__p_Hex__NewShape = {"_p_Hex__NewShape", "Hex::NewShape *", 0, 0, (void*)0, 0};
33089 static swig_type_info _swigt__p_Hex__Propagation = {"_p_Hex__Propagation", "Hex::Propagation *", 0, 0, (void*)0, 0};
33090 static swig_type_info _swigt__p_Hex__Quad = {"_p_Hex__Quad", "Hex::Quad *", 0, 0, (void*)0, 0};
33091 static swig_type_info _swigt__p_Hex__Shape = {"_p_Hex__Shape", "Hex::Shape *|Hex::OldShape *", 0, 0, (void*)0, 0};
33092 static swig_type_info _swigt__p_Hex__Vector = {"_p_Hex__Vector", "Hex::Vector *", 0, 0, (void*)0, 0};
33093 static swig_type_info _swigt__p_Hex__Vertex = {"_p_Hex__Vertex", "Hex::Vertex *", 0, 0, (void*)0, 0};
33094 static swig_type_info _swigt__p_Hex__XmlWriter = {"_p_Hex__XmlWriter", "Hex::XmlWriter *", 0, 0, (void*)0, 0};
33095 static swig_type_info _swigt__p_a_Hex__DIM3__double = {"_p_a_Hex__DIM3__double", "double (*)[Hex::DIM3]|Hex::Real3 *", 0, 0, (void*)0, 0};
33096 static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
33097 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
33098 static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
33099 static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
33100 static swig_type_info _swigt__p_double = {"_p_double", "double *|Hex::Real *", 0, 0, (void*)0, 0};
33101 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
33102 static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
33103 static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
33104 static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
33105 static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
33106 static swig_type_info _swigt__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t = {"_p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t", "std::vector< Hex::AssoEdge *,std::allocator< Hex::AssoEdge * > > *|Hex::AssoEdges *", 0, 0, (void*)0, 0};
33107 static swig_type_info _swigt__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t = {"_p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t", "Hex::EdgeShapes *|std::vector< Hex::EdgeShape *,std::allocator< Hex::EdgeShape * > > *", 0, 0, (void*)0, 0};
33108 static swig_type_info _swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t = {"_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t", "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *|std::vector< Hex::Edge * > *|Hex::Edges *", 0, 0, (void*)0, 0};
33109 static swig_type_info _swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type = {"_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type", "std::vector< Hex::Edge * >::allocator_type *|std::allocator< Hex::Edge * > *", 0, 0, (void*)0, 0};
33110 static swig_type_info _swigt__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t = {"_p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t", "std::vector< Hex::EltBase *,std::allocator< Hex::EltBase * > > *|Hex::TabElts *", 0, 0, (void*)0, 0};
33111 static swig_type_info _swigt__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t = {"_p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t", "Hex::FaceShapes *|std::vector< Hex::FaceShape *,std::allocator< Hex::FaceShape * > > *", 0, 0, (void*)0, 0};
33112 static swig_type_info _swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t = {"_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t", "Hex::Hexas *|std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *|std::vector< Hex::Hexa * > *", 0, 0, (void*)0, 0};
33113 static swig_type_info _swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type = {"_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type", "std::vector< Hex::Hexa * >::allocator_type *|std::allocator< Hex::Hexa * > *", 0, 0, (void*)0, 0};
33114 static swig_type_info _swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t = {"_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t", "Hex::NewShapes *|std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *|std::vector< Hex::NewShape * > *", 0, 0, (void*)0, 0};
33115 static swig_type_info _swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type = {"_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type", "std::vector< Hex::NewShape * >::allocator_type *|std::allocator< Hex::NewShape * > *", 0, 0, (void*)0, 0};
33116 static swig_type_info _swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t = {"_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t", "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *|std::vector< Hex::Quad * > *|Hex::Quads *", 0, 0, (void*)0, 0};
33117 static swig_type_info _swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type = {"_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type", "std::vector< Hex::Quad * >::allocator_type *|std::allocator< Hex::Quad * > *", 0, 0, (void*)0, 0};
33118 static swig_type_info _swigt__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t = {"_p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t", "Hex::Shapes *|std::vector< Hex::Shape *,std::allocator< Hex::Shape * > > *", 0, 0, (void*)0, 0};
33119 static swig_type_info _swigt__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t = {"_p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t", "Hex::SubShapes *|std::vector< Hex::SubShape *,std::allocator< Hex::SubShape * > > *", 0, 0, (void*)0, 0};
33120 static swig_type_info _swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t = {"_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t", "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *|std::vector< Hex::Vertex * > *|Hex::Vertices *", 0, 0, (void*)0, 0};
33121 static swig_type_info _swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type = {"_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type", "std::vector< Hex::Vertex * >::allocator_type *|std::allocator< Hex::Vertex * > *", 0, 0, (void*)0, 0};
33122 static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|Hex::RealVector *|std::vector< double > *", 0, 0, (void*)0, 0};
33123 static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type = {"_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
33124 static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|Hex::IntVector *|std::vector< int > *", 0, 0, (void*)0, 0};
33125 static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type = {"_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0};
33126 static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "Hex::TabText *|std::vector< std::string,std::allocator< std::string > > *", 0, 0, (void*)0, 0};
33127 static swig_type_info _swigt__p_string = {"_p_string", "string *", 0, 0, (void*)0, 0};
33128 static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
33129 static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
33130 static swig_type_info _swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type = {"_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type", "std::vector< Hex::Edge * >::value_type|Hex::Edge *", 0, 0, (void*)0, 0};
33131 static swig_type_info _swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type = {"_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type", "Hex::Hexa *|std::vector< Hex::Hexa * >::value_type", 0, 0, (void*)0, 0};
33132 static swig_type_info _swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type = {"_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type", "std::vector< Hex::NewShape * >::value_type|Hex::NewShape *", 0, 0, (void*)0, 0};
33133 static swig_type_info _swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type = {"_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type", "std::vector< Hex::Quad * >::value_type|Hex::Quad *", 0, 0, (void*)0, 0};
33134 static swig_type_info _swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type = {"_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type", "std::vector< Hex::Vertex * >::value_type|Hex::Vertex *", 0, 0, (void*)0, 0};
33135
33136 static swig_type_info *swig_type_initial[] = {
33137   &_swigt__p_FILE,
33138   &_swigt__p_Hex__BiCylinder,
33139   &_swigt__p_Hex__Document,
33140   &_swigt__p_Hex__Edge,
33141   &_swigt__p_Hex__Elements,
33142   &_swigt__p_Hex__EltBase,
33143   &_swigt__p_Hex__Group,
33144   &_swigt__p_Hex__Hex,
33145   &_swigt__p_Hex__Hex__EltBase,
33146   &_swigt__p_Hex__Hexa,
33147   &_swigt__p_Hex__Law,
33148   &_swigt__p_Hex__NewShape,
33149   &_swigt__p_Hex__Propagation,
33150   &_swigt__p_Hex__Quad,
33151   &_swigt__p_Hex__Shape,
33152   &_swigt__p_Hex__Vector,
33153   &_swigt__p_Hex__Vertex,
33154   &_swigt__p_Hex__XmlWriter,
33155   &_swigt__p_a_Hex__DIM3__double,
33156   &_swigt__p_allocator_type,
33157   &_swigt__p_char,
33158   &_swigt__p_const_reference,
33159   &_swigt__p_difference_type,
33160   &_swigt__p_double,
33161   &_swigt__p_int,
33162   &_swigt__p_p_PyObject,
33163   &_swigt__p_reference,
33164   &_swigt__p_size_type,
33165   &_swigt__p_std__invalid_argument,
33166   &_swigt__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t,
33167   &_swigt__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t,
33168   &_swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t,
33169   &_swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type,
33170   &_swigt__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t,
33171   &_swigt__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t,
33172   &_swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t,
33173   &_swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type,
33174   &_swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t,
33175   &_swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type,
33176   &_swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t,
33177   &_swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type,
33178   &_swigt__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t,
33179   &_swigt__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t,
33180   &_swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t,
33181   &_swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type,
33182   &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
33183   &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type,
33184   &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
33185   &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type,
33186   &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
33187   &_swigt__p_string,
33188   &_swigt__p_swig__SwigPyIterator,
33189   &_swigt__p_value_type,
33190   &_swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type,
33191   &_swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type,
33192   &_swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type,
33193   &_swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type,
33194   &_swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type,
33195 };
33196
33197 static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
33198 static swig_cast_info _swigc__p_Hex__BiCylinder[] = {  {&_swigt__p_Hex__BiCylinder, 0, 0, 0},{0, 0, 0, 0}};
33199 static swig_cast_info _swigc__p_Hex__Document[] = {  {&_swigt__p_Hex__Document, 0, 0, 0},{0, 0, 0, 0}};
33200 static swig_cast_info _swigc__p_Hex__Edge[] = {  {&_swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
33201 static swig_cast_info _swigc__p_Hex__Elements[] = {  {&_swigt__p_Hex__Elements, 0, 0, 0},  {&_swigt__p_Hex__BiCylinder, _p_Hex__BiCylinderTo_p_Hex__Elements, 0, 0},{0, 0, 0, 0}};
33202 static swig_cast_info _swigc__p_Hex__EltBase[] = {  {&_swigt__p_Hex__Group, _p_Hex__GroupTo_p_Hex__EltBase, 0, 0},  {&_swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, _p_Hex__EdgeTo_p_Hex__EltBase, 0, 0},  {&_swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, _p_Hex__NewShapeTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Vertex, _p_Hex__VertexTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Elements, _p_Hex__ElementsTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__NewShape, _p_Hex__NewShapeTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Hexa, _p_Hex__HexaTo_p_Hex__EltBase, 0, 0},  {&_swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, _p_Hex__QuadTo_p_Hex__EltBase, 0, 0},  {&_swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, _p_Hex__VertexTo_p_Hex__EltBase, 0, 0},  {&_swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, _p_Hex__HexaTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Propagation, _p_Hex__PropagationTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Hex__EltBase, 0, 0, 0},  {&_swigt__p_Hex__EltBase, 0, 0, 0},  {&_swigt__p_Hex__Vector, _p_Hex__VectorTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__BiCylinder, _p_Hex__BiCylinderTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Document, _p_Hex__DocumentTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Edge, _p_Hex__EdgeTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Quad, _p_Hex__QuadTo_p_Hex__EltBase, 0, 0},{0, 0, 0, 0}};
33203 static swig_cast_info _swigc__p_Hex__Group[] = {  {&_swigt__p_Hex__Group, 0, 0, 0},{0, 0, 0, 0}};
33204 static swig_cast_info _swigc__p_Hex__Hex[] = {  {&_swigt__p_Hex__Hex, 0, 0, 0},{0, 0, 0, 0}};
33205 static swig_cast_info _swigc__p_Hex__Hex__EltBase[] = {  {&_swigt__p_Hex__Group, 0, 0, 0},  {&_swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0, 0, 0},  {&_swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Vertex, 0, 0, 0},  {&_swigt__p_Hex__Elements, 0, 0, 0},  {&_swigt__p_Hex__NewShape, 0, 0, 0},  {&_swigt__p_Hex__Hexa, 0, 0, 0},  {&_swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0, 0, 0},  {&_swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0, 0, 0},  {&_swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Propagation, 0, 0, 0},  {&_swigt__p_Hex__EltBase, 0, 0, 0},  {&_swigt__p_Hex__Hex__EltBase, 0, 0, 0},  {&_swigt__p_Hex__Vector, 0, 0, 0},  {&_swigt__p_Hex__BiCylinder, 0, 0, 0},  {&_swigt__p_Hex__Document, 0, 0, 0},  {&_swigt__p_Hex__Edge, 0, 0, 0},  {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
33206 static swig_cast_info _swigc__p_Hex__Hexa[] = {  {&_swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
33207 static swig_cast_info _swigc__p_Hex__Law[] = {  {&_swigt__p_Hex__Law, 0, 0, 0},{0, 0, 0, 0}};
33208 static swig_cast_info _swigc__p_Hex__NewShape[] = {  {&_swigt__p_Hex__NewShape, 0, 0, 0},  {&_swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
33209 static swig_cast_info _swigc__p_Hex__Propagation[] = {  {&_swigt__p_Hex__Propagation, 0, 0, 0},{0, 0, 0, 0}};
33210 static swig_cast_info _swigc__p_Hex__Quad[] = {  {&_swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
33211 static swig_cast_info _swigc__p_Hex__Shape[] = {  {&_swigt__p_Hex__Shape, 0, 0, 0},{0, 0, 0, 0}};
33212 static swig_cast_info _swigc__p_Hex__Vector[] = {  {&_swigt__p_Hex__Vector, 0, 0, 0},{0, 0, 0, 0}};
33213 static swig_cast_info _swigc__p_Hex__Vertex[] = {  {&_swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
33214 static swig_cast_info _swigc__p_Hex__XmlWriter[] = {  {&_swigt__p_Hex__XmlWriter, 0, 0, 0},{0, 0, 0, 0}};
33215 static swig_cast_info _swigc__p_a_Hex__DIM3__double[] = {  {&_swigt__p_a_Hex__DIM3__double, 0, 0, 0},{0, 0, 0, 0}};
33216 static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
33217 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
33218 static swig_cast_info _swigc__p_const_reference[] = {  {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
33219 static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
33220 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
33221 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
33222 static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
33223 static swig_cast_info _swigc__p_reference[] = {  {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
33224 static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
33225 static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
33226 static swig_cast_info _swigc__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
33227 static swig_cast_info _swigc__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
33228 static swig_cast_info _swigc__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
33229 static swig_cast_info _swigc__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
33230 static swig_cast_info _swigc__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
33231 static swig_cast_info _swigc__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
33232 static swig_cast_info _swigc__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
33233 static swig_cast_info _swigc__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
33234 static swig_cast_info _swigc__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
33235 static swig_cast_info _swigc__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
33236 static swig_cast_info _swigc__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
33237 static swig_cast_info _swigc__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
33238 static swig_cast_info _swigc__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
33239 static swig_cast_info _swigc__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
33240 static swig_cast_info _swigc__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
33241 static swig_cast_info _swigc__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
33242 static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t[] = {  {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
33243 static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type[] = {  {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
33244 static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = {  {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
33245 static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type[] = {  {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
33246 static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
33247 static swig_cast_info _swigc__p_string[] = {  {&_swigt__p_string, 0, 0, 0},{0, 0, 0, 0}};
33248 static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
33249 static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
33250 static swig_cast_info _swigc__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type[] = {  {&_swigt__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
33251 static swig_cast_info _swigc__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type[] = {  {&_swigt__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
33252 static swig_cast_info _swigc__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type[] = {  {&_swigt__p_Hex__NewShape, 0, 0, 0},  {&_swigt__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
33253 static swig_cast_info _swigc__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type[] = {  {&_swigt__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
33254 static swig_cast_info _swigc__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type[] = {  {&_swigt__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
33255
33256 static swig_cast_info *swig_cast_initial[] = {
33257   _swigc__p_FILE,
33258   _swigc__p_Hex__BiCylinder,
33259   _swigc__p_Hex__Document,
33260   _swigc__p_Hex__Edge,
33261   _swigc__p_Hex__Elements,
33262   _swigc__p_Hex__EltBase,
33263   _swigc__p_Hex__Group,
33264   _swigc__p_Hex__Hex,
33265   _swigc__p_Hex__Hex__EltBase,
33266   _swigc__p_Hex__Hexa,
33267   _swigc__p_Hex__Law,
33268   _swigc__p_Hex__NewShape,
33269   _swigc__p_Hex__Propagation,
33270   _swigc__p_Hex__Quad,
33271   _swigc__p_Hex__Shape,
33272   _swigc__p_Hex__Vector,
33273   _swigc__p_Hex__Vertex,
33274   _swigc__p_Hex__XmlWriter,
33275   _swigc__p_a_Hex__DIM3__double,
33276   _swigc__p_allocator_type,
33277   _swigc__p_char,
33278   _swigc__p_const_reference,
33279   _swigc__p_difference_type,
33280   _swigc__p_double,
33281   _swigc__p_int,
33282   _swigc__p_p_PyObject,
33283   _swigc__p_reference,
33284   _swigc__p_size_type,
33285   _swigc__p_std__invalid_argument,
33286   _swigc__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t,
33287   _swigc__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t,
33288   _swigc__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t,
33289   _swigc__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__allocator_type,
33290   _swigc__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t,
33291   _swigc__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t,
33292   _swigc__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t,
33293   _swigc__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__allocator_type,
33294   _swigc__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t,
33295   _swigc__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__allocator_type,
33296   _swigc__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t,
33297   _swigc__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__allocator_type,
33298   _swigc__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t,
33299   _swigc__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t,
33300   _swigc__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t,
33301   _swigc__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__allocator_type,
33302   _swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
33303   _swigc__p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type,
33304   _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
33305   _swigc__p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type,
33306   _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
33307   _swigc__p_string,
33308   _swigc__p_swig__SwigPyIterator,
33309   _swigc__p_value_type,
33310   _swigc__std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t__value_type,
33311   _swigc__std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t__value_type,
33312   _swigc__std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t__value_type,
33313   _swigc__std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t__value_type,
33314   _swigc__std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t__value_type,
33315 };
33316
33317
33318 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33319
33320 static swig_const_info swig_const_table[] = {
33321 {0, 0, 0, 0.0, 0, 0}};
33322
33323 #ifdef __cplusplus
33324 }
33325 #endif
33326 /* -----------------------------------------------------------------------------
33327  * Type initialization:
33328  * This problem is tough by the requirement that no dynamic
33329  * memory is used. Also, since swig_type_info structures store pointers to
33330  * swig_cast_info structures and swig_cast_info structures store pointers back
33331  * to swig_type_info structures, we need some lookup code at initialization.
33332  * The idea is that swig generates all the structures that are needed.
33333  * The runtime then collects these partially filled structures.
33334  * The SWIG_InitializeModule function takes these initial arrays out of
33335  * swig_module, and does all the lookup, filling in the swig_module.types
33336  * array with the correct data and linking the correct swig_cast_info
33337  * structures together.
33338  *
33339  * The generated swig_type_info structures are assigned staticly to an initial
33340  * array. We just loop through that array, and handle each type individually.
33341  * First we lookup if this type has been already loaded, and if so, use the
33342  * loaded structure instead of the generated one. Then we have to fill in the
33343  * cast linked list. The cast data is initially stored in something like a
33344  * two-dimensional array. Each row corresponds to a type (there are the same
33345  * number of rows as there are in the swig_type_initial array). Each entry in
33346  * a column is one of the swig_cast_info structures for that type.
33347  * The cast_initial array is actually an array of arrays, because each row has
33348  * a variable number of columns. So to actually build the cast linked list,
33349  * we find the array of casts associated with the type, and loop through it
33350  * adding the casts to the list. The one last trick we need to do is making
33351  * sure the type pointer in the swig_cast_info struct is correct.
33352  *
33353  * First off, we lookup the cast->type name to see if it is already loaded.
33354  * There are three cases to handle:
33355  *  1) If the cast->type has already been loaded AND the type we are adding
33356  *     casting info to has not been loaded (it is in this module), THEN we
33357  *     replace the cast->type pointer with the type pointer that has already
33358  *     been loaded.
33359  *  2) If BOTH types (the one we are adding casting info to, and the
33360  *     cast->type) are loaded, THEN the cast info has already been loaded by
33361  *     the previous module so we just ignore it.
33362  *  3) Finally, if cast->type has not already been loaded, then we add that
33363  *     swig_cast_info to the linked list (because the cast->type) pointer will
33364  *     be correct.
33365  * ----------------------------------------------------------------------------- */
33366
33367 #ifdef __cplusplus
33368 extern "C" {
33369 #if 0
33370 } /* c-mode */
33371 #endif
33372 #endif
33373
33374 #if 0
33375 #define SWIGRUNTIME_DEBUG
33376 #endif
33377
33378
33379 SWIGRUNTIME void
33380 SWIG_InitializeModule(void *clientdata) {
33381   size_t i;
33382   swig_module_info *module_head, *iter;
33383   int found, init;
33384
33385   clientdata = clientdata;
33386
33387   /* check to see if the circular list has been setup, if not, set it up */
33388   if (swig_module.next==0) {
33389     /* Initialize the swig_module */
33390     swig_module.type_initial = swig_type_initial;
33391     swig_module.cast_initial = swig_cast_initial;
33392     swig_module.next = &swig_module;
33393     init = 1;
33394   } else {
33395     init = 0;
33396   }
33397
33398   /* Try and load any already created modules */
33399   module_head = SWIG_GetModule(clientdata);
33400   if (!module_head) {
33401     /* This is the first module loaded for this interpreter */
33402     /* so set the swig module into the interpreter */
33403     SWIG_SetModule(clientdata, &swig_module);
33404     module_head = &swig_module;
33405   } else {
33406     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
33407     found=0;
33408     iter=module_head;
33409     do {
33410       if (iter==&swig_module) {
33411         found=1;
33412         break;
33413       }
33414       iter=iter->next;
33415     } while (iter!= module_head);
33416
33417     /* if the is found in the list, then all is done and we may leave */
33418     if (found) return;
33419     /* otherwise we must add out module into the list */
33420     swig_module.next = module_head->next;
33421     module_head->next = &swig_module;
33422   }
33423
33424   /* When multiple interpeters are used, a module could have already been initialized in
33425        a different interpreter, but not yet have a pointer in this interpreter.
33426        In this case, we do not want to continue adding types... everything should be
33427        set up already */
33428   if (init == 0) return;
33429
33430   /* Now work on filling in swig_module.types */
33431 #ifdef SWIGRUNTIME_DEBUG
33432   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
33433 #endif
33434   for (i = 0; i < swig_module.size; ++i) {
33435     swig_type_info *type = 0;
33436     swig_type_info *ret;
33437     swig_cast_info *cast;
33438
33439 #ifdef SWIGRUNTIME_DEBUG
33440     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
33441 #endif
33442
33443     /* if there is another module already loaded */
33444     if (swig_module.next != &swig_module) {
33445       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
33446     }
33447     if (type) {
33448       /* Overwrite clientdata field */
33449 #ifdef SWIGRUNTIME_DEBUG
33450       printf("SWIG_InitializeModule: found type %s\n", type->name);
33451 #endif
33452       if (swig_module.type_initial[i]->clientdata) {
33453         type->clientdata = swig_module.type_initial[i]->clientdata;
33454 #ifdef SWIGRUNTIME_DEBUG
33455         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
33456 #endif
33457       }
33458     } else {
33459       type = swig_module.type_initial[i];
33460     }
33461
33462     /* Insert casting types */
33463     cast = swig_module.cast_initial[i];
33464     while (cast->type) {
33465       /* Don't need to add information already in the list */
33466       ret = 0;
33467 #ifdef SWIGRUNTIME_DEBUG
33468       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
33469 #endif
33470       if (swig_module.next != &swig_module) {
33471         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
33472 #ifdef SWIGRUNTIME_DEBUG
33473         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
33474 #endif
33475       }
33476       if (ret) {
33477         if (type == swig_module.type_initial[i]) {
33478 #ifdef SWIGRUNTIME_DEBUG
33479           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
33480 #endif
33481           cast->type = ret;
33482           ret = 0;
33483         } else {
33484           /* Check for casting already in the list */
33485           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
33486 #ifdef SWIGRUNTIME_DEBUG
33487           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
33488 #endif
33489           if (!ocast) ret = 0;
33490         }
33491       }
33492
33493       if (!ret) {
33494 #ifdef SWIGRUNTIME_DEBUG
33495         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
33496 #endif
33497         if (type->cast) {
33498           type->cast->prev = cast;
33499           cast->next = type->cast;
33500         }
33501         type->cast = cast;
33502       }
33503       cast++;
33504     }
33505     /* Set entry in modules->types array equal to the type */
33506     swig_module.types[i] = type;
33507   }
33508   swig_module.types[i] = 0;
33509
33510 #ifdef SWIGRUNTIME_DEBUG
33511   printf("**** SWIG_InitializeModule: Cast List ******\n");
33512   for (i = 0; i < swig_module.size; ++i) {
33513     int j = 0;
33514     swig_cast_info *cast = swig_module.cast_initial[i];
33515     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
33516     while (cast->type) {
33517       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
33518       cast++;
33519       ++j;
33520     }
33521     printf("---- Total casts: %d\n",j);
33522   }
33523   printf("**** SWIG_InitializeModule: Cast List ******\n");
33524 #endif
33525 }
33526
33527 /* This function will propagate the clientdata field of type to
33528 * any new swig_type_info structures that have been added into the list
33529 * of equivalent types.  It is like calling
33530 * SWIG_TypeClientData(type, clientdata) a second time.
33531 */
33532 SWIGRUNTIME void
33533 SWIG_PropagateClientData(void) {
33534   size_t i;
33535   swig_cast_info *equiv;
33536   static int init_run = 0;
33537
33538   if (init_run) return;
33539   init_run = 1;
33540
33541   for (i = 0; i < swig_module.size; i++) {
33542     if (swig_module.types[i]->clientdata) {
33543       equiv = swig_module.types[i]->cast;
33544       while (equiv) {
33545         if (!equiv->converter) {
33546           if (equiv->type && !equiv->type->clientdata)
33547           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
33548         }
33549         equiv = equiv->next;
33550       }
33551     }
33552   }
33553 }
33554
33555 #ifdef __cplusplus
33556 #if 0
33557 {
33558   /* c-mode */
33559 #endif
33560 }
33561 #endif
33562
33563
33564
33565 #ifdef __cplusplus
33566 extern "C" {
33567 #endif
33568
33569   /* Python-specific SWIG API */
33570 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
33571 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33572 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
33573
33574   /* -----------------------------------------------------------------------------
33575    * global variable support code.
33576    * ----------------------------------------------------------------------------- */
33577
33578   typedef struct swig_globalvar {
33579     char       *name;                  /* Name of global variable */
33580     PyObject *(*get_attr)(void);       /* Return the current value */
33581     int       (*set_attr)(PyObject *); /* Set the value */
33582     struct swig_globalvar *next;
33583   } swig_globalvar;
33584
33585   typedef struct swig_varlinkobject {
33586     PyObject_HEAD
33587     swig_globalvar *vars;
33588   } swig_varlinkobject;
33589
33590   SWIGINTERN PyObject *
33591   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
33592 #if PY_VERSION_HEX >= 0x03000000
33593     return PyUnicode_InternFromString("<Swig global variables>");
33594 #else
33595     return PyString_FromString("<Swig global variables>");
33596 #endif
33597   }
33598
33599   SWIGINTERN PyObject *
33600   swig_varlink_str(swig_varlinkobject *v) {
33601 #if PY_VERSION_HEX >= 0x03000000
33602     PyObject *str = PyUnicode_InternFromString("(");
33603     PyObject *tail;
33604     PyObject *joined;
33605     swig_globalvar *var;
33606     for (var = v->vars; var; var=var->next) {
33607       tail = PyUnicode_FromString(var->name);
33608       joined = PyUnicode_Concat(str, tail);
33609       Py_DecRef(str);
33610       Py_DecRef(tail);
33611       str = joined;
33612       if (var->next) {
33613         tail = PyUnicode_InternFromString(", ");
33614         joined = PyUnicode_Concat(str, tail);
33615         Py_DecRef(str);
33616         Py_DecRef(tail);
33617         str = joined;
33618       }
33619     }
33620     tail = PyUnicode_InternFromString(")");
33621     joined = PyUnicode_Concat(str, tail);
33622     Py_DecRef(str);
33623     Py_DecRef(tail);
33624     str = joined;
33625 #else
33626     PyObject *str = PyString_FromString("(");
33627     swig_globalvar *var;
33628     for (var = v->vars; var; var=var->next) {
33629       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
33630       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
33631     }
33632     PyString_ConcatAndDel(&str,PyString_FromString(")"));
33633 #endif
33634     return str;
33635   }
33636
33637   SWIGINTERN int
33638   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
33639     char *tmp;
33640     PyObject *str = swig_varlink_str(v);
33641     fprintf(fp,"Swig global variables ");
33642     fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
33643     SWIG_Python_str_DelForPy3(tmp);
33644     Py_DECREF(str);
33645     return 0;
33646   }
33647
33648   SWIGINTERN void
33649   swig_varlink_dealloc(swig_varlinkobject *v) {
33650     swig_globalvar *var = v->vars;
33651     while (var) {
33652       swig_globalvar *n = var->next;
33653       free(var->name);
33654       free(var);
33655       var = n;
33656     }
33657   }
33658
33659   SWIGINTERN PyObject *
33660   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33661     PyObject *res = NULL;
33662     swig_globalvar *var = v->vars;
33663     while (var) {
33664       if (strcmp(var->name,n) == 0) {
33665         res = (*var->get_attr)();
33666         break;
33667       }
33668       var = var->next;
33669     }
33670     if (res == NULL && !PyErr_Occurred()) {
33671       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33672     }
33673     return res;
33674   }
33675
33676   SWIGINTERN int
33677   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33678     int res = 1;
33679     swig_globalvar *var = v->vars;
33680     while (var) {
33681       if (strcmp(var->name,n) == 0) {
33682         res = (*var->set_attr)(p);
33683         break;
33684       }
33685       var = var->next;
33686     }
33687     if (res == 1 && !PyErr_Occurred()) {
33688       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33689     }
33690     return res;
33691   }
33692
33693   SWIGINTERN PyTypeObject*
33694   swig_varlink_type(void) {
33695     static char varlink__doc__[] = "Swig var link object";
33696     static PyTypeObject varlink_type;
33697     static int type_init = 0;
33698     if (!type_init) {
33699       const PyTypeObject tmp
33700       = {
33701         /* PyObject header changed in Python 3 */
33702 #if PY_VERSION_HEX >= 0x03000000
33703         PyVarObject_HEAD_INIT(&PyType_Type, 0)
33704 #else
33705         PyObject_HEAD_INIT(NULL)
33706         0,                                  /* Number of items in variable part (ob_size) */
33707 #endif
33708         (char *)"swigvarlink",              /* Type name (tp_name) */
33709         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
33710         0,                                  /* Itemsize (tp_itemsize) */
33711         (destructor) swig_varlink_dealloc,  /* Deallocator (tp_dealloc) */
33712         (printfunc) swig_varlink_print,     /* Print (tp_print) */
33713         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33714         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33715         0,                                  /* tp_compare */
33716         (reprfunc) swig_varlink_repr,       /* tp_repr */
33717         0,                                  /* tp_as_number */
33718         0,                                  /* tp_as_sequence */
33719         0,                                  /* tp_as_mapping */
33720         0,                                  /* tp_hash */
33721         0,                                  /* tp_call */
33722         (reprfunc) swig_varlink_str,        /* tp_str */
33723         0,                                  /* tp_getattro */
33724         0,                                  /* tp_setattro */
33725         0,                                  /* tp_as_buffer */
33726         0,                                  /* tp_flags */
33727         varlink__doc__,                     /* tp_doc */
33728         0,                                  /* tp_traverse */
33729         0,                                  /* tp_clear */
33730         0,                                  /* tp_richcompare */
33731         0,                                  /* tp_weaklistoffset */
33732 #if PY_VERSION_HEX >= 0x02020000
33733         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33734 #endif
33735 #if PY_VERSION_HEX >= 0x02030000
33736         0,                                  /* tp_del */
33737 #endif
33738 #ifdef COUNT_ALLOCS
33739         0,0,0,0                             /* tp_alloc -> tp_next */
33740 #endif
33741       };
33742       varlink_type = tmp;
33743       /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
33744 #if PY_VERSION_HEX < 0x03000000
33745       varlink_type.ob_type = &PyType_Type;
33746 #endif
33747       type_init = 1;
33748     }
33749     return &varlink_type;
33750   }
33751
33752   /* Create a variable linking object for use later */
33753   SWIGINTERN PyObject *
33754   SWIG_Python_newvarlink(void) {
33755     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
33756     if (result) {
33757       result->vars = 0;
33758     }
33759     return ((PyObject*) result);
33760   }
33761
33762   SWIGINTERN void
33763   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33764     swig_varlinkobject *v = (swig_varlinkobject *) p;
33765     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33766     if (gv) {
33767       size_t size = strlen(name)+1;
33768       gv->name = (char *)malloc(size);
33769       if (gv->name) {
33770         strncpy(gv->name,name,size);
33771         gv->get_attr = get_attr;
33772         gv->set_attr = set_attr;
33773         gv->next = v->vars;
33774       }
33775     }
33776     v->vars = gv;
33777   }
33778
33779   SWIGINTERN PyObject *
33780   SWIG_globals(void) {
33781     static PyObject *_SWIG_globals = 0;
33782     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
33783     return _SWIG_globals;
33784   }
33785
33786   /* -----------------------------------------------------------------------------
33787    * constants/methods manipulation
33788    * ----------------------------------------------------------------------------- */
33789
33790   /* Install Constants */
33791   SWIGINTERN void
33792   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33793     PyObject *obj = 0;
33794     size_t i;
33795     for (i = 0; constants[i].type; ++i) {
33796       switch(constants[i].type) {
33797       case SWIG_PY_POINTER:
33798         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33799         break;
33800       case SWIG_PY_BINARY:
33801         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33802         break;
33803       default:
33804         obj = 0;
33805         break;
33806       }
33807       if (obj) {
33808         PyDict_SetItemString(d, constants[i].name, obj);
33809         Py_DECREF(obj);
33810       }
33811     }
33812   }
33813
33814   /* -----------------------------------------------------------------------------*/
33815   /* Fix SwigMethods to carry the callback ptrs when needed */
33816   /* -----------------------------------------------------------------------------*/
33817
33818   SWIGINTERN void
33819   SWIG_Python_FixMethods(PyMethodDef *methods,
33820     swig_const_info *const_table,
33821     swig_type_info **types,
33822     swig_type_info **types_initial) {
33823     size_t i;
33824     for (i = 0; methods[i].ml_name; ++i) {
33825       const char *c = methods[i].ml_doc;
33826       if (c && (c = strstr(c, "swig_ptr: "))) {
33827         int j;
33828         swig_const_info *ci = 0;
33829         const char *name = c + 10;
33830         for (j = 0; const_table[j].type; ++j) {
33831           if (strncmp(const_table[j].name, name,
33832               strlen(const_table[j].name)) == 0) {
33833             ci = &(const_table[j]);
33834             break;
33835           }
33836         }
33837         if (ci) {
33838           size_t shift = (ci->ptype) - types;
33839           swig_type_info *ty = types_initial[shift];
33840           size_t ldoc = (c - methods[i].ml_doc);
33841           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33842           char *ndoc = (char*)malloc(ldoc + lptr + 10);
33843           if (ndoc) {
33844             char *buff = ndoc;
33845             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
33846             if (ptr) {
33847               strncpy(buff, methods[i].ml_doc, ldoc);
33848               buff += ldoc;
33849               strncpy(buff, "swig_ptr: ", 10);
33850               buff += 10;
33851               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33852               methods[i].ml_doc = ndoc;
33853             }
33854           }
33855         }
33856       }
33857     }
33858   }
33859
33860 #ifdef __cplusplus
33861 }
33862 #endif
33863
33864 /* -----------------------------------------------------------------------------*
33865  *  Partial Init method
33866  * -----------------------------------------------------------------------------*/
33867
33868 #ifdef __cplusplus
33869 extern "C"
33870 #endif
33871
33872 SWIGEXPORT
33873 #if PY_VERSION_HEX >= 0x03000000
33874 PyObject*
33875 #else
33876 void
33877 #endif
33878 SWIG_init(void) {
33879   PyObject *m, *d;
33880 #if PY_VERSION_HEX >= 0x03000000
33881   static struct PyModuleDef SWIG_module = {
33882     PyModuleDef_HEAD_INIT,
33883     (char *) SWIG_name,
33884     NULL,
33885     -1,
33886     SwigMethods,
33887     NULL,
33888     NULL,
33889     NULL,
33890     NULL
33891   };
33892 #endif
33893
33894   /* Fix SwigMethods to carry the callback ptrs when needed */
33895   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
33896
33897 #if PY_VERSION_HEX >= 0x03000000
33898   m = PyModule_Create(&SWIG_module);
33899 #else
33900   m = Py_InitModule((char *) SWIG_name, SwigMethods);
33901 #endif
33902   d = PyModule_GetDict(m);
33903
33904   SWIG_InitializeModule(0);
33905   SWIG_InstallConstants(d,swig_const_table);
33906
33907
33908   SWIG_Python_SetConstant(d, "HOK",SWIG_From_int(static_cast< int >(0)));
33909   SWIG_Python_SetConstant(d, "HERR",SWIG_From_int(static_cast< int >(1)));
33910   SWIG_Python_SetConstant(d, "NOTHING",SWIG_From_int(static_cast< int >(-1)));
33911   SWIG_Python_SetConstant(d, "EOL",SWIG_From_char(static_cast< char >('\n')));
33912   SWIG_Python_SetConstant(d, "EOS",SWIG_From_int(static_cast< int >(0)));
33913   SWIG_Python_SetConstant(d, "CHVIDE",SWIG_FromCharPtr(""));
33914   SWIG_Python_SetConstant(d, "ZEROR",SWIG_From_double(static_cast< double >(0.0)));
33915   SWIG_Python_SetConstant(d, "UNR",SWIG_From_double(static_cast< double >(1.0)));
33916   SWIG_Python_SetConstant(d, "DEMI",SWIG_From_double(static_cast< double >(0.5)));
33917   SWIG_Python_SetConstant(d, "DIM2",SWIG_From_int(static_cast< int >(2)));
33918   SWIG_Python_SetConstant(d, "M_PI",SWIG_From_double(static_cast< double >(3.14159265358979323846)));
33919   SWIG_Python_SetConstant(d, "Degre2Radian",SWIG_From_double(static_cast< double >(3.14159265358979323846/180)));
33920   SWIG_Python_SetConstant(d, "dir_x",SWIG_From_int(static_cast< int >(Hex::dir_x)));
33921   SWIG_Python_SetConstant(d, "dir_y",SWIG_From_int(static_cast< int >(Hex::dir_y)));
33922   SWIG_Python_SetConstant(d, "dir_z",SWIG_From_int(static_cast< int >(Hex::dir_z)));
33923   SWIG_Python_SetConstant(d, "DIM3",SWIG_From_int(static_cast< int >(Hex::DIM3)));
33924   SWIG_Python_SetConstant(d, "EL_NONE",SWIG_From_int(static_cast< int >(Hex::EL_NONE)));
33925   SWIG_Python_SetConstant(d, "EL_VERTEX",SWIG_From_int(static_cast< int >(Hex::EL_VERTEX)));
33926   SWIG_Python_SetConstant(d, "EL_EDGE",SWIG_From_int(static_cast< int >(Hex::EL_EDGE)));
33927   SWIG_Python_SetConstant(d, "EL_QUAD",SWIG_From_int(static_cast< int >(Hex::EL_QUAD)));
33928   SWIG_Python_SetConstant(d, "EL_HEXA",SWIG_From_int(static_cast< int >(Hex::EL_HEXA)));
33929   SWIG_Python_SetConstant(d, "EL_VECTOR",SWIG_From_int(static_cast< int >(Hex::EL_VECTOR)));
33930   SWIG_Python_SetConstant(d, "EL_GRID",SWIG_From_int(static_cast< int >(Hex::EL_GRID)));
33931   SWIG_Python_SetConstant(d, "EL_CYLINDER",SWIG_From_int(static_cast< int >(Hex::EL_CYLINDER)));
33932   SWIG_Python_SetConstant(d, "EL_PIPE",SWIG_From_int(static_cast< int >(Hex::EL_PIPE)));
33933   SWIG_Python_SetConstant(d, "EL_GROUP",SWIG_From_int(static_cast< int >(Hex::EL_GROUP)));
33934   SWIG_Python_SetConstant(d, "EL_LAW",SWIG_From_int(static_cast< int >(Hex::EL_LAW)));
33935   SWIG_Python_SetConstant(d, "EL_SHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SHAPE)));
33936   SWIG_Python_SetConstant(d, "EL_SUBSHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SUBSHAPE)));
33937   SWIG_Python_SetConstant(d, "EL_PROPAGATION",SWIG_From_int(static_cast< int >(Hex::EL_PROPAGATION)));
33938   SWIG_Python_SetConstant(d, "EL_DOCU",SWIG_From_int(static_cast< int >(Hex::EL_DOCU)));
33939   SWIG_Python_SetConstant(d, "EL_REMOVED",SWIG_From_int(static_cast< int >(Hex::EL_REMOVED)));
33940   SWIG_Python_SetConstant(d, "EL_MAXI",SWIG_From_int(static_cast< int >(Hex::EL_MAXI)));
33941   PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
33942   SWIG_addvarlink(SWIG_globals(),(char*)"ABR_TYPES",Swig_var_ABR_TYPES_get, Swig_var_ABR_TYPES_set);
33943   SWIG_Python_SetConstant(d, "HexaCell",SWIG_From_int(static_cast< int >(Hex::HexaCell)));
33944   SWIG_Python_SetConstant(d, "QuadCell",SWIG_From_int(static_cast< int >(Hex::QuadCell)));
33945   SWIG_Python_SetConstant(d, "EdgeCell",SWIG_From_int(static_cast< int >(Hex::EdgeCell)));
33946   SWIG_Python_SetConstant(d, "HexaNode",SWIG_From_int(static_cast< int >(Hex::HexaNode)));
33947   SWIG_Python_SetConstant(d, "QuadNode",SWIG_From_int(static_cast< int >(Hex::QuadNode)));
33948   SWIG_Python_SetConstant(d, "EdgeNode",SWIG_From_int(static_cast< int >(Hex::EdgeNode)));
33949   SWIG_Python_SetConstant(d, "VertexNode",SWIG_From_int(static_cast< int >(Hex::VertexNode)));
33950   SWIG_Python_SetConstant(d, "SH_NONE",SWIG_From_int(static_cast< int >(Hex::SH_NONE)));
33951   SWIG_Python_SetConstant(d, "SH_IMPORT",SWIG_From_int(static_cast< int >(Hex::SH_IMPORT)));
33952   SWIG_Python_SetConstant(d, "SH_CYLINDER",SWIG_From_int(static_cast< int >(Hex::SH_CYLINDER)));
33953   SWIG_Python_SetConstant(d, "SH_INTER",SWIG_From_int(static_cast< int >(Hex::SH_INTER)));
33954   SWIG_Python_SetConstant(d, "SH_SPHERE",SWIG_From_int(static_cast< int >(Hex::SH_SPHERE)));
33955   SWIG_Python_SetConstant(d, "SH_CLOUD",SWIG_From_int(static_cast< int >(Hex::SH_CLOUD)));
33956   SWIG_Python_SetConstant(d, "SH_EXTRUD",SWIG_From_int(static_cast< int >(Hex::SH_EXTRUD)));
33957   SWIG_Python_SetConstant(d, "CYL_NOFILL",SWIG_From_int(static_cast< int >(Hex::CYL_NOFILL)));
33958   SWIG_Python_SetConstant(d, "CYL_CL4",SWIG_From_int(static_cast< int >(Hex::CYL_CL4)));
33959   SWIG_Python_SetConstant(d, "CYL_CL6",SWIG_From_int(static_cast< int >(Hex::CYL_CL6)));
33960   SWIG_Python_SetConstant(d, "CYL_CLOSED",SWIG_From_int(static_cast< int >(Hex::CYL_CLOSED)));
33961   SWIG_Python_SetConstant(d, "CYL_PEER",SWIG_From_int(static_cast< int >(Hex::CYL_PEER)));
33962   SWIG_Python_SetConstant(d, "CYL_ODD",SWIG_From_int(static_cast< int >(Hex::CYL_ODD)));
33963   SWIG_Python_SetConstant(d, "GR_NONE",SWIG_From_int(static_cast< int >(Hex::GR_NONE)));
33964   SWIG_Python_SetConstant(d, "GR_CARTESIAN",SWIG_From_int(static_cast< int >(Hex::GR_CARTESIAN)));
33965   SWIG_Python_SetConstant(d, "GR_CYLINDRIC",SWIG_From_int(static_cast< int >(Hex::GR_CYLINDRIC)));
33966   SWIG_Python_SetConstant(d, "GR_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_SPHERIC)));
33967   SWIG_Python_SetConstant(d, "GR_JOINT",SWIG_From_int(static_cast< int >(Hex::GR_JOINT)));
33968   SWIG_Python_SetConstant(d, "GR_BICYL",SWIG_From_int(static_cast< int >(Hex::GR_BICYL)));
33969   SWIG_Python_SetConstant(d, "GR_BIPIPE",SWIG_From_int(static_cast< int >(Hex::GR_BIPIPE)));
33970   SWIG_Python_SetConstant(d, "GR_REPLACE",SWIG_From_int(static_cast< int >(Hex::GR_REPLACE)));
33971   SWIG_Python_SetConstant(d, "GR_HEMISPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_HEMISPHERIC)));
33972   SWIG_Python_SetConstant(d, "GR_RIND",SWIG_From_int(static_cast< int >(Hex::GR_RIND)));
33973   SWIG_Python_SetConstant(d, "GR_PART_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_PART_SPHERIC)));
33974   SWIG_Python_SetConstant(d, "GR_PART_RIND",SWIG_From_int(static_cast< int >(Hex::GR_PART_RIND)));
33975   SWIG_Python_SetConstant(d, "S_E",SWIG_From_int(static_cast< int >(Hex::S_E)));
33976   SWIG_Python_SetConstant(d, "S_NE",SWIG_From_int(static_cast< int >(Hex::S_NE)));
33977   SWIG_Python_SetConstant(d, "S_N",SWIG_From_int(static_cast< int >(Hex::S_N)));
33978   SWIG_Python_SetConstant(d, "S_NW",SWIG_From_int(static_cast< int >(Hex::S_NW)));
33979   SWIG_Python_SetConstant(d, "S_W",SWIG_From_int(static_cast< int >(Hex::S_W)));
33980   SWIG_Python_SetConstant(d, "S_SW",SWIG_From_int(static_cast< int >(Hex::S_SW)));
33981   SWIG_Python_SetConstant(d, "S_S",SWIG_From_int(static_cast< int >(Hex::S_S)));
33982   SWIG_Python_SetConstant(d, "S_SE",SWIG_From_int(static_cast< int >(Hex::S_SE)));
33983   SWIG_Python_SetConstant(d, "S_MAXI",SWIG_From_int(static_cast< int >(Hex::S_MAXI)));
33984   SWIG_Python_SetConstant(d, "Uniform",SWIG_From_int(static_cast< int >(Hex::Uniform)));
33985   SWIG_Python_SetConstant(d, "Arithmetic",SWIG_From_int(static_cast< int >(Hex::Arithmetic)));
33986   SWIG_Python_SetConstant(d, "Geometric",SWIG_From_int(static_cast< int >(Hex::Geometric)));
33987   SWIG_Python_SetConstant(d, "OR_FRONT",SWIG_From_int(static_cast< int >(Hex::OR_FRONT)));
33988   SWIG_Python_SetConstant(d, "OR_LEFT",SWIG_From_int(static_cast< int >(Hex::OR_LEFT)));
33989   SWIG_Python_SetConstant(d, "OR_RIGHT",SWIG_From_int(static_cast< int >(Hex::OR_RIGHT)));
33990   SWIG_Python_SetConstant(d, "OR_BACK",SWIG_From_int(static_cast< int >(Hex::OR_BACK)));
33991   SWIG_Python_SetConstant(d, "IS_NONE",SWIG_From_int(static_cast< int >(Hex::IS_NONE)));
33992   SWIG_Python_SetConstant(d, "IS_MARRIED",SWIG_From_int(static_cast< int >(Hex::IS_MARRIED)));
33993   SWIG_Python_SetConstant(d, "NO_COUNTED",SWIG_From_int(static_cast< int >(Hex::NO_COUNTED)));
33994   SWIG_Python_SetConstant(d, "NO_USED",SWIG_From_int(static_cast< int >(Hex::NO_USED)));
33995   SWIG_Python_SetConstant(d, "IS_USED",SWIG_From_int(static_cast< int >(Hex::IS_USED)));
33996   SWIG_Python_SetConstant(d, "V_AMONT",SWIG_From_int(static_cast< int >(Hex::V_AMONT)));
33997   SWIG_Python_SetConstant(d, "V_AVAL",SWIG_From_int(static_cast< int >(Hex::V_AVAL)));
33998   SWIG_Python_SetConstant(d, "V_TWO",SWIG_From_int(static_cast< int >(Hex::V_TWO)));
33999   SWIG_Python_SetConstant(d, "E_A",SWIG_From_int(static_cast< int >(Hex::E_A)));
34000   SWIG_Python_SetConstant(d, "E_B",SWIG_From_int(static_cast< int >(Hex::E_B)));
34001   SWIG_Python_SetConstant(d, "E_C",SWIG_From_int(static_cast< int >(Hex::E_C)));
34002   SWIG_Python_SetConstant(d, "E_D",SWIG_From_int(static_cast< int >(Hex::E_D)));
34003   SWIG_Python_SetConstant(d, "QUAD4",SWIG_From_int(static_cast< int >(Hex::QUAD4)));
34004   SWIG_Python_SetConstant(d, "Q_A",SWIG_From_int(static_cast< int >(Hex::Q_A)));
34005   SWIG_Python_SetConstant(d, "Q_B",SWIG_From_int(static_cast< int >(Hex::Q_B)));
34006   SWIG_Python_SetConstant(d, "Q_C",SWIG_From_int(static_cast< int >(Hex::Q_C)));
34007   SWIG_Python_SetConstant(d, "Q_D",SWIG_From_int(static_cast< int >(Hex::Q_D)));
34008   SWIG_Python_SetConstant(d, "Q_E",SWIG_From_int(static_cast< int >(Hex::Q_E)));
34009   SWIG_Python_SetConstant(d, "Q_F",SWIG_From_int(static_cast< int >(Hex::Q_F)));
34010   SWIG_Python_SetConstant(d, "HQ_MAXI",SWIG_From_int(static_cast< int >(Hex::HQ_MAXI)));
34011   SWIG_Python_SetConstant(d, "E_AC",SWIG_From_int(static_cast< int >(Hex::E_AC)));
34012   SWIG_Python_SetConstant(d, "E_AD",SWIG_From_int(static_cast< int >(Hex::E_AD)));
34013   SWIG_Python_SetConstant(d, "E_BC",SWIG_From_int(static_cast< int >(Hex::E_BC)));
34014   SWIG_Python_SetConstant(d, "E_BD",SWIG_From_int(static_cast< int >(Hex::E_BD)));
34015   SWIG_Python_SetConstant(d, "E_AE",SWIG_From_int(static_cast< int >(Hex::E_AE)));
34016   SWIG_Python_SetConstant(d, "E_AF",SWIG_From_int(static_cast< int >(Hex::E_AF)));
34017   SWIG_Python_SetConstant(d, "E_BE",SWIG_From_int(static_cast< int >(Hex::E_BE)));
34018   SWIG_Python_SetConstant(d, "E_BF",SWIG_From_int(static_cast< int >(Hex::E_BF)));
34019   SWIG_Python_SetConstant(d, "E_CE",SWIG_From_int(static_cast< int >(Hex::E_CE)));
34020   SWIG_Python_SetConstant(d, "E_CF",SWIG_From_int(static_cast< int >(Hex::E_CF)));
34021   SWIG_Python_SetConstant(d, "E_DE",SWIG_From_int(static_cast< int >(Hex::E_DE)));
34022   SWIG_Python_SetConstant(d, "E_DF",SWIG_From_int(static_cast< int >(Hex::E_DF)));
34023   SWIG_Python_SetConstant(d, "HE_MAXI",SWIG_From_int(static_cast< int >(Hex::HE_MAXI)));
34024   SWIG_Python_SetConstant(d, "V_ACE",SWIG_From_int(static_cast< int >(Hex::V_ACE)));
34025   SWIG_Python_SetConstant(d, "V_ACF",SWIG_From_int(static_cast< int >(Hex::V_ACF)));
34026   SWIG_Python_SetConstant(d, "V_ADE",SWIG_From_int(static_cast< int >(Hex::V_ADE)));
34027   SWIG_Python_SetConstant(d, "V_ADF",SWIG_From_int(static_cast< int >(Hex::V_ADF)));
34028   SWIG_Python_SetConstant(d, "V_BCE",SWIG_From_int(static_cast< int >(Hex::V_BCE)));
34029   SWIG_Python_SetConstant(d, "V_BCF",SWIG_From_int(static_cast< int >(Hex::V_BCF)));
34030   SWIG_Python_SetConstant(d, "V_BDE",SWIG_From_int(static_cast< int >(Hex::V_BDE)));
34031   SWIG_Python_SetConstant(d, "V_BDF",SWIG_From_int(static_cast< int >(Hex::V_BDF)));
34032   SWIG_Python_SetConstant(d, "HV_MAXI",SWIG_From_int(static_cast< int >(Hex::HV_MAXI)));
34033   SWIG_Python_SetConstant(d, "Q_INSIDE",SWIG_From_int(static_cast< int >(Hex::Q_INSIDE)));
34034   SWIG_Python_SetConstant(d, "Q_DIRECT",SWIG_From_int(static_cast< int >(Hex::Q_DIRECT)));
34035   SWIG_Python_SetConstant(d, "Q_INVERSE",SWIG_From_int(static_cast< int >(Hex::Q_INVERSE)));
34036   SWIG_Python_SetConstant(d, "Q_UNDEFINED",SWIG_From_int(static_cast< int >(Hex::Q_UNDEFINED)));
34037   SWIG_Python_SetConstant(d, "Q_WAITING",SWIG_From_int(static_cast< int >(Hex::Q_WAITING)));
34038   SWIG_Python_SetConstant(d, "KS_Line",SWIG_From_int(static_cast< int >(Hex::KS_Line)));
34039   SWIG_Python_SetConstant(d, "KS_Circle",SWIG_From_int(static_cast< int >(Hex::KS_Circle)));
34040   SWIG_Python_SetConstant(d, "KS_Ellipse",SWIG_From_int(static_cast< int >(Hex::KS_Ellipse)));
34041   SWIG_Python_SetConstant(d, "KS_Hyperbola",SWIG_From_int(static_cast< int >(Hex::KS_Hyperbola)));
34042   SWIG_Python_SetConstant(d, "KS_Parabola",SWIG_From_int(static_cast< int >(Hex::KS_Parabola)));
34043   SWIG_Python_SetConstant(d, "KS_BezierCurve",SWIG_From_int(static_cast< int >(Hex::KS_BezierCurve)));
34044   SWIG_Python_SetConstant(d, "KS_BSplineCurve",SWIG_From_int(static_cast< int >(Hex::KS_BSplineCurve)));
34045   SWIG_Python_SetConstant(d, "KS_OtherCurve",SWIG_From_int(static_cast< int >(Hex::KS_OtherCurve)));
34046   SWIG_Python_SetConstant(d, "KS_None",SWIG_From_int(static_cast< int >(Hex::KS_None)));
34047   SWIG_Python_SetConstant(d, "CylSmall",SWIG_From_int(static_cast< int >(Hex::CylSmall)));
34048   SWIG_Python_SetConstant(d, "CylBig",SWIG_From_int(static_cast< int >(Hex::CylBig)));
34049   SWIG_Python_SetConstant(d, "NxInt",SWIG_From_int(static_cast< int >(Hex::NxInt)));
34050   SWIG_Python_SetConstant(d, "NxExt",SWIG_From_int(static_cast< int >(Hex::NxExt)));
34051   SWIG_addvarlink(SWIG_globals(),(char*)"Epsil",Swig_var_Epsil_get, Swig_var_Epsil_set);
34052   SWIG_addvarlink(SWIG_globals(),(char*)"UnEpsil",Swig_var_UnEpsil_get, Swig_var_UnEpsil_set);
34053   SWIG_addvarlink(SWIG_globals(),(char*)"Epsil2",Swig_var_Epsil2_get, Swig_var_Epsil2_set);
34054 #if PY_VERSION_HEX >= 0x03000000
34055   return m;
34056 #else
34057   return;
34058 #endif
34059 }
34060