src/HEXABLOCK_SWIG/hexablock_swig_wrap.cc

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.31
   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 #ifdef __cplusplus
  15 template<class T> class SwigValueWrapper {
  16     T *tt;
  17 public:
  18     SwigValueWrapper() : tt(0) { }
  19     SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
  20     SwigValueWrapper(const T& t) : tt(new T(t)) { }
  21     ~SwigValueWrapper() { delete tt; }
  22     SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
  23     operator T&() const { return *tt; }
  24     T *operator&() { return tt; }
  25 private:
  26     SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27 };
  28 #endif
  29
  30 /* -----------------------------------------------------------------------------
  31  *  This section contains generic SWIG labels for method/variable
  32  *  declarations/attributes, and other compiler dependent labels.
  33  * ----------------------------------------------------------------------------- */
  34
  35 /* template workaround for compilers that cannot correctly implement the C++ standard */
  36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  37 # if defined(__SUNPRO_CC)
  38 #   if (__SUNPRO_CC <= 0x560)
  39 #     define SWIGTEMPLATEDISAMBIGUATOR template
  40 #   else
  41 #     define SWIGTEMPLATEDISAMBIGUATOR
  42 #   endif
  43 # else
  44 #   define SWIGTEMPLATEDISAMBIGUATOR
  45 # endif
  46 #endif
  47
  48 /* inline attribute */
  49 #ifndef SWIGINLINE
  50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  51 #   define SWIGINLINE inline
  52 # else
  53 #   define SWIGINLINE
  54 # endif
  55 #endif
  56
  57 /* attribute recognised by some compilers to avoid 'unused' warnings */
  58 #ifndef SWIGUNUSED
  59 # if defined(__GNUC__)
  60 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  61 #     define SWIGUNUSED __attribute__ ((__unused__))
  62 #   else
  63 #     define SWIGUNUSED
  64 #   endif
  65 # elif defined(__ICC)
  66 #   define SWIGUNUSED __attribute__ ((__unused__))
  67 # else
  68 #   define SWIGUNUSED
  69 # endif
  70 #endif
  71
  72 #ifndef SWIGUNUSEDPARM
  73 # ifdef __cplusplus
  74 #   define SWIGUNUSEDPARM(p)
  75 # else
  76 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  77 # endif
  78 #endif
  79
  80 /* internal SWIG method */
  81 #ifndef SWIGINTERN
  82 # define SWIGINTERN static SWIGUNUSED
  83 #endif
  84
  85 /* internal inline SWIG method */
  86 #ifndef SWIGINTERNINLINE
  87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  88 #endif
  89
  90 /* exporting methods */
  91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  92 #  ifndef GCC_HASCLASSVISIBILITY
  93 #    define GCC_HASCLASSVISIBILITY
  94 #  endif
  95 #endif
  96
  97 #ifndef SWIGEXPORT
  98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  99 #   if defined(STATIC_LINKED)
 100 #     define SWIGEXPORT
 101 #   else
 102 #     define SWIGEXPORT __declspec(dllexport)
 103 #   endif
 104 # else
 105 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 106 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 107 #   else
 108 #     define SWIGEXPORT
 109 #   endif
 110 # endif
 111 #endif
 112
 113 /* calling conventions for Windows */
 114 #ifndef SWIGSTDCALL
 115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 116 #   define SWIGSTDCALL __stdcall
 117 # else
 118 #   define SWIGSTDCALL
 119 # endif
 120 #endif
 121
 122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 124 # define _CRT_SECURE_NO_DEPRECATE
 125 #endif
 126
 127
 128 /* Python.h has to appear first */
 129 #include <Python.h>
 130
 131 /* -----------------------------------------------------------------------------
 132  * swigrun.swg
 133  *
 134  * This file contains generic CAPI SWIG runtime support for pointer
 135  * type checking.
 136  * ----------------------------------------------------------------------------- */
 137
 138 /* This should only be incremented when either the layout of swig_type_info changes,
 139    or for whatever reason, the runtime changes incompatibly */
 140 #define SWIG_RUNTIME_VERSION "3"
 141
 142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 143 #ifdef SWIG_TYPE_TABLE
 144 # define SWIG_QUOTE_STRING(x) #x
 145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 147 #else
 148 # define SWIG_TYPE_TABLE_NAME
 149 #endif
 150
 151 /*
 152   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 153   creating a static or dynamic library from the swig runtime code.
 154   In 99.9% of the cases, swig just needs to declare them as 'static'.
 155
 156   But only do this if is strictly necessary, ie, if you have problems
 157   with your compiler or so.
 158 */
 159
 160 #ifndef SWIGRUNTIME
 161 # define SWIGRUNTIME SWIGINTERN
 162 #endif
 163
 164 #ifndef SWIGRUNTIMEINLINE
 165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 166 #endif
 167
 168 /*  Generic buffer size */
 169 #ifndef SWIG_BUFFER_SIZE
 170 # define SWIG_BUFFER_SIZE 1024
 171 #endif
 172
 173 /* Flags for pointer conversions */
 174 #define SWIG_POINTER_DISOWN        0x1
 175
 176 /* Flags for new pointer objects */
 177 #define SWIG_POINTER_OWN           0x1
 178
 179
 180 /*
 181    Flags/methods for returning states.
 182
 183    The swig conversion methods, as ConvertPtr, return and integer
 184    that tells if the conversion was successful or not. And if not,
 185    an error code can be returned (see swigerrors.swg for the codes).
 186
 187    Use the following macros/flags to set or process the returning
 188    states.
 189
 190    In old swig versions, you usually write code as:
 191
 192      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 193        // success code
 194      } else {
 195        //fail code
 196      }
 197
 198    Now you can be more explicit as:
 199
 200     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 201     if (SWIG_IsOK(res)) {
 202       // success code
 203     } else {
 204       // fail code
 205     }
 206
 207    that seems to be the same, but now you can also do
 208
 209     Type *ptr;
 210     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 211     if (SWIG_IsOK(res)) {
 212       // success code
 213       if (SWIG_IsNewObj(res) {
 214         ...
 215         delete *ptr;
 216       } else {
 217         ...
 218       }
 219     } else {
 220       // fail code
 221     }
 222
 223    I.e., now SWIG_ConvertPtr can return new objects and you can
 224    identify the case and take care of the deallocation. Of course that
 225    requires also to SWIG_ConvertPtr to return new result values, as
 226
 227       int SWIG_ConvertPtr(obj, ptr,...) {
 228         if (<obj is ok>) {
 229           if (<need new object>) {
 230             *ptr = <ptr to new allocated object>;
 231             return SWIG_NEWOBJ;
 232           } else {
 233             *ptr = <ptr to old object>;
 234             return SWIG_OLDOBJ;
 235           }
 236         } else {
 237           return SWIG_BADOBJ;
 238         }
 239       }
 240
 241    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 242    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 243    swig errors code.
 244
 245    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 246    allows to return the 'cast rank', for example, if you have this
 247
 248        int food(double)
 249        int fooi(int);
 250
 251    and you call
 252
 253       food(1)   // cast rank '1'  (1 -> 1.0)
 254       fooi(1)   // cast rank '0'
 255
 256    just use the SWIG_AddCast()/SWIG_CheckState()
 257
 258
 259  */
 260 #define SWIG_OK                    (0)
 261 #define SWIG_ERROR                 (-1)
 262 #define SWIG_IsOK(r)               (r >= 0)
 263 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 264
 265 /* The CastRankLimit says how many bits are used for the cast rank */
 266 #define SWIG_CASTRANKLIMIT         (1 << 8)
 267 /* The NewMask denotes the object was created (using new/malloc) */
 268 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 269 /* The TmpMask is for in/out typemaps that use temporal objects */
 270 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 271 /* Simple returning values */
 272 #define SWIG_BADOBJ                (SWIG_ERROR)
 273 #define SWIG_OLDOBJ                (SWIG_OK)
 274 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 275 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 276 /* Check, add and del mask methods */
 277 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 278 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 279 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 280 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 281 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 282 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 283
 284
 285 /* Cast-Rank Mode */
 286 #if defined(SWIG_CASTRANK_MODE)
 287 #  ifndef SWIG_TypeRank
 288 #    define SWIG_TypeRank             unsigned long
 289 #  endif
 290 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 291 #    define SWIG_MAXCASTRANK          (2)
 292 #  endif
 293 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 294 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
 296   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 297 }
 298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
 299   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
 300 }
 301 #else /* no cast-rank mode */
 302 #  define SWIG_AddCast
 303 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 304 #endif
 305
 306
 307
 308
 309 #include <string.h>
 310
 311 #ifdef __cplusplus
 312 extern "C" {
 313 #endif
 314
 315 typedef void *(*swig_converter_func)(void *);
 316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 317
 318 /* Structure to store inforomation on one type */
 319 typedef struct swig_type_info {
 320   const char             *name;                 /* mangled name of this type */
 321   const char             *str;                  /* human readable name of this type */
 322   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 323   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 324   void                   *clientdata;           /* language specific type data */
 325   int                    owndata;               /* flag if the structure owns the clientdata */
 326 } swig_type_info;
 327
 328 /* Structure to store a type and conversion function used for casting */
 329 typedef struct swig_cast_info {
 330   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 331   swig_converter_func     converter;            /* function to cast the void pointers */
 332   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 333   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 334 } swig_cast_info;
 335
 336 /* Structure used to store module information
 337  * Each module generates one structure like this, and the runtime collects
 338  * all of these structures and stores them in a circularly linked list.*/
 339 typedef struct swig_module_info {
 340   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 341   size_t                 size;                  /* Number of types in this module */
 342   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 343   swig_type_info         **type_initial;        /* Array of initially generated type structures */
 344   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 345   void                    *clientdata;          /* Language specific module data */
 346 } swig_module_info;
 347
 348 /*
 349   Compare two type names skipping the space characters, therefore
 350   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 351
 352   Return 0 when the two name types are equivalent, as in
 353   strncmp, but skipping ' '.
 354 */
 355 SWIGRUNTIME int
 356 SWIG_TypeNameComp(const char *f1, const char *l1,
 357                   const char *f2, const char *l2) {
 358   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 359     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 360     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 361     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 362   }
 363   return (l1 - f1) - (l2 - f2);
 364 }
 365
 366 /*
 367   Check type equivalence in a name list like <name1>|<name2>|...
 368   Return 0 if not equal, 1 if equal
 369 */
 370 SWIGRUNTIME int
 371 SWIG_TypeEquiv(const char *nb, const char *tb) {
 372   int equiv = 0;
 373   const char* te = tb + strlen(tb);
 374   const char* ne = nb;
 375   while (!equiv && *ne) {
 376     for (nb = ne; *ne; ++ne) {
 377       if (*ne == '|') break;
 378     }
 379     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 380     if (*ne) ++ne;
 381   }
 382   return equiv;
 383 }
 384
 385 /*
 386   Check type equivalence in a name list like <name1>|<name2>|...
 387   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 388 */
 389 SWIGRUNTIME int
 390 SWIG_TypeCompare(const char *nb, const char *tb) {
 391   int equiv = 0;
 392   const char* te = tb + strlen(tb);
 393   const char* ne = nb;
 394   while (!equiv && *ne) {
 395     for (nb = ne; *ne; ++ne) {
 396       if (*ne == '|') break;
 397     }
 398     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 399     if (*ne) ++ne;
 400   }
 401   return equiv;
 402 }
 403
 404
 405 /* think of this as a c++ template<> or a scheme macro */
 406 #define SWIG_TypeCheck_Template(comparison, ty)         \
 407   if (ty) {                                             \
 408     swig_cast_info *iter = ty->cast;                    \
 409     while (iter) {                                      \
 410       if (comparison) {                                 \
 411         if (iter == ty->cast) return iter;              \
 412         /* Move iter to the top of the linked list */   \
 413         iter->prev->next = iter->next;                  \
 414         if (iter->next)                                 \
 415           iter->next->prev = iter->prev;                \
 416         iter->next = ty->cast;                          \
 417         iter->prev = 0;                                 \
 418         if (ty->cast) ty->cast->prev = iter;            \
 419         ty->cast = iter;                                \
 420         return iter;                                    \
 421       }                                                 \
 422       iter = iter->next;                                \
 423     }                                                   \
 424   }                                                     \
 425   return 0
 426
 427 /*
 428   Check the typename
 429 */
 430 SWIGRUNTIME swig_cast_info *
 431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 432   SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 433 }
 434
 435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
 436 SWIGRUNTIME swig_cast_info *
 437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
 438   SWIG_TypeCheck_Template(iter->type == from, into);
 439 }
 440
 441 /*
 442   Cast a pointer up an inheritance hierarchy
 443 */
 444 SWIGRUNTIMEINLINE void *
 445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
 446   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
 447 }
 448
 449 /*
 450    Dynamic pointer casting. Down an inheritance hierarchy
 451 */
 452 SWIGRUNTIME swig_type_info *
 453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 454   swig_type_info *lastty = ty;
 455   if (!ty || !ty->dcast) return ty;
 456   while (ty && (ty->dcast)) {
 457     ty = (*ty->dcast)(ptr);
 458     if (ty) lastty = ty;
 459   }
 460   return lastty;
 461 }
 462
 463 /*
 464   Return the name associated with this type
 465 */
 466 SWIGRUNTIMEINLINE const char *
 467 SWIG_TypeName(const swig_type_info *ty) {
 468   return ty->name;
 469 }
 470
 471 /*
 472   Return the pretty name associated with this type,
 473   that is an unmangled type name in a form presentable to the user.
 474 */
 475 SWIGRUNTIME const char *
 476 SWIG_TypePrettyName(const swig_type_info *type) {
 477   /* The "str" field contains the equivalent pretty names of the
 478      type, separated by vertical-bar characters.  We choose
 479      to print the last name, as it is often (?) the most
 480      specific. */
 481   if (!type) return NULL;
 482   if (type->str != NULL) {
 483     const char *last_name = type->str;
 484     const char *s;
 485     for (s = type->str; *s; s++)
 486       if (*s == '|') last_name = s+1;
 487     return last_name;
 488   }
 489   else
 490     return type->name;
 491 }
 492
 493 /*
 494    Set the clientdata field for a type
 495 */
 496 SWIGRUNTIME void
 497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 498   swig_cast_info *cast = ti->cast;
 499   /* if (ti->clientdata == clientdata) return; */
 500   ti->clientdata = clientdata;
 501
 502   while (cast) {
 503     if (!cast->converter) {
 504       swig_type_info *tc = cast->type;
 505       if (!tc->clientdata) {
 506         SWIG_TypeClientData(tc, clientdata);
 507       }
 508     }
 509     cast = cast->next;
 510   }
 511 }
 512 SWIGRUNTIME void
 513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 514   SWIG_TypeClientData(ti, clientdata);
 515   ti->owndata = 1;
 516 }
 517
 518 /*
 519   Search for a swig_type_info structure only by mangled name
 520   Search is a O(log #types)
 521
 522   We start searching at module start, and finish searching when start == end.
 523   Note: if start == end at the beginning of the function, we go all the way around
 524   the circular list.
 525 */
 526 SWIGRUNTIME swig_type_info *
 527 SWIG_MangledTypeQueryModule(swig_module_info *start,
 528                             swig_module_info *end,
 529                             const char *name) {
 530   swig_module_info *iter = start;
 531   do {
 532     if (iter->size) {
 533       register size_t l = 0;
 534       register size_t r = iter->size - 1;
 535       do {
 536         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 537         register size_t i = (l + r) >> 1;
 538         const char *iname = iter->types[i]->name;
 539         if (iname) {
 540           register int compare = strcmp(name, iname);
 541           if (compare == 0) {
 542             return iter->types[i];
 543           } else if (compare < 0) {
 544             if (i) {
 545               r = i - 1;
 546             } else {
 547               break;
 548             }
 549           } else if (compare > 0) {
 550             l = i + 1;
 551           }
 552         } else {
 553           break; /* should never happen */
 554         }
 555       } while (l <= r);
 556     }
 557     iter = iter->next;
 558   } while (iter != end);
 559   return 0;
 560 }
 561
 562 /*
 563   Search for a swig_type_info structure for either a mangled name or a human readable name.
 564   It first searches the mangled names of the types, which is a O(log #types)
 565   If a type is not found it then searches the human readable names, which is O(#types).
 566
 567   We start searching at module start, and finish searching when start == end.
 568   Note: if start == end at the beginning of the function, we go all the way around
 569   the circular list.
 570 */
 571 SWIGRUNTIME swig_type_info *
 572 SWIG_TypeQueryModule(swig_module_info *start,
 573                      swig_module_info *end,
 574                      const char *name) {
 575   /* STEP 1: Search the name field using binary search */
 576   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 577   if (ret) {
 578     return ret;
 579   } else {
 580     /* STEP 2: If the type hasn't been found, do a complete search
 581        of the str field (the human readable name) */
 582     swig_module_info *iter = start;
 583     do {
 584       register size_t i = 0;
 585       for (; i < iter->size; ++i) {
 586         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 587           return iter->types[i];
 588       }
 589       iter = iter->next;
 590     } while (iter != end);
 591   }
 592
 593   /* neither found a match */
 594   return 0;
 595 }
 596
 597 /*
 598    Pack binary data into a string
 599 */
 600 SWIGRUNTIME char *
 601 SWIG_PackData(char *c, void *ptr, size_t sz) {
 602   static const char hex[17] = "0123456789abcdef";
 603   register const unsigned char *u = (unsigned char *) ptr;
 604   register const unsigned char *eu =  u + sz;
 605   for (; u != eu; ++u) {
 606     register unsigned char uu = *u;
 607     *(c++) = hex[(uu & 0xf0) >> 4];
 608     *(c++) = hex[uu & 0xf];
 609   }
 610   return c;
 611 }
 612
 613 /*
 614    Unpack binary data from a string
 615 */
 616 SWIGRUNTIME const char *
 617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 618   register unsigned char *u = (unsigned char *) ptr;
 619   register const unsigned char *eu = u + sz;
 620   for (; u != eu; ++u) {
 621     register char d = *(c++);
 622     register unsigned char uu;
 623     if ((d >= '0') && (d <= '9'))
 624       uu = ((d - '0') << 4);
 625     else if ((d >= 'a') && (d <= 'f'))
 626       uu = ((d - ('a'-10)) << 4);
 627     else
 628       return (char *) 0;
 629     d = *(c++);
 630     if ((d >= '0') && (d <= '9'))
 631       uu |= (d - '0');
 632     else if ((d >= 'a') && (d <= 'f'))
 633       uu |= (d - ('a'-10));
 634     else
 635       return (char *) 0;
 636     *u = uu;
 637   }
 638   return c;
 639 }
 640
 641 /*
 642    Pack 'void *' into a string buffer.
 643 */
 644 SWIGRUNTIME char *
 645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 646   char *r = buff;
 647   if ((2*sizeof(void *) + 2) > bsz) return 0;
 648   *(r++) = '_';
 649   r = SWIG_PackData(r,&ptr,sizeof(void *));
 650   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 651   strcpy(r,name);
 652   return buff;
 653 }
 654
 655 SWIGRUNTIME const char *
 656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 657   if (*c != '_') {
 658     if (strcmp(c,"NULL") == 0) {
 659       *ptr = (void *) 0;
 660       return name;
 661     } else {
 662       return 0;
 663     }
 664   }
 665   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 666 }
 667
 668 SWIGRUNTIME char *
 669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 670   char *r = buff;
 671   size_t lname = (name ? strlen(name) : 0);
 672   if ((2*sz + 2 + lname) > bsz) return 0;
 673   *(r++) = '_';
 674   r = SWIG_PackData(r,ptr,sz);
 675   if (lname) {
 676     strncpy(r,name,lname+1);
 677   } else {
 678     *r = 0;
 679   }
 680   return buff;
 681 }
 682
 683 SWIGRUNTIME const char *
 684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 685   if (*c != '_') {
 686     if (strcmp(c,"NULL") == 0) {
 687       memset(ptr,0,sz);
 688       return name;
 689     } else {
 690       return 0;
 691     }
 692   }
 693   return SWIG_UnpackData(++c,ptr,sz);
 694 }
 695
 696 #ifdef __cplusplus
 697 }
 698 #endif
 699
 700 /*  Errors in SWIG */
 701 #define  SWIG_UnknownError         -1
 702 #define  SWIG_IOError              -2
 703 #define  SWIG_RuntimeError         -3
 704 #define  SWIG_IndexError           -4
 705 #define  SWIG_TypeError            -5
 706 #define  SWIG_DivisionByZero       -6
 707 #define  SWIG_OverflowError        -7
 708 #define  SWIG_SyntaxError          -8
 709 #define  SWIG_ValueError           -9
 710 #define  SWIG_SystemError          -10
 711 #define  SWIG_AttributeError       -11
 712 #define  SWIG_MemoryError          -12
 713 #define  SWIG_NullReferenceError   -13
 714
 715
 716
 717
 718 /* Add PyOS_snprintf for old Pythons */
 719 #if PY_VERSION_HEX < 0x02020000
 720 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
 721 #  define PyOS_snprintf _snprintf
 722 # else
 723 #  define PyOS_snprintf snprintf
 724 # endif
 725 #endif
 726
 727 /* A crude PyString_FromFormat implementation for old Pythons */
 728 #if PY_VERSION_HEX < 0x02020000
 729
 730 #ifndef SWIG_PYBUFFER_SIZE
 731 # define SWIG_PYBUFFER_SIZE 1024
 732 #endif
 733
 734 static PyObject *
 735 PyString_FromFormat(const char *fmt, ...) {
 736   va_list ap;
 737   char buf[SWIG_PYBUFFER_SIZE * 2];
 738   int res;
 739   va_start(ap, fmt);
 740   res = vsnprintf(buf, sizeof(buf), fmt, ap);
 741   va_end(ap);
 742   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
 743 }
 744 #endif
 745
 746 /* Add PyObject_Del for old Pythons */
 747 #if PY_VERSION_HEX < 0x01060000
 748 # define PyObject_Del(op) PyMem_DEL((op))
 749 #endif
 750 #ifndef PyObject_DEL
 751 # define PyObject_DEL PyObject_Del
 752 #endif
 753
 754 /* A crude PyExc_StopIteration exception for old Pythons */
 755 #if PY_VERSION_HEX < 0x02020000
 756 # ifndef PyExc_StopIteration
 757 #  define PyExc_StopIteration PyExc_RuntimeError
 758 # endif
 759 # ifndef PyObject_GenericGetAttr
 760 #  define PyObject_GenericGetAttr 0
 761 # endif
 762 #endif
 763 /* Py_NotImplemented is defined in 2.1 and up. */
 764 #if PY_VERSION_HEX < 0x02010000
 765 # ifndef Py_NotImplemented
 766 #  define Py_NotImplemented PyExc_RuntimeError
 767 # endif
 768 #endif
 769
 770
 771 /* A crude PyString_AsStringAndSize implementation for old Pythons */
 772 #if PY_VERSION_HEX < 0x02010000
 773 # ifndef PyString_AsStringAndSize
 774 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
 775 # endif
 776 #endif
 777
 778 /* PySequence_Size for old Pythons */
 779 #if PY_VERSION_HEX < 0x02000000
 780 # ifndef PySequence_Size
 781 #  define PySequence_Size PySequence_Length
 782 # endif
 783 #endif
 784
 785
 786 /* PyBool_FromLong for old Pythons */
 787 #if PY_VERSION_HEX < 0x02030000
 788 static
 789 PyObject *PyBool_FromLong(long ok)
 790 {
 791   PyObject *result = ok ? Py_True : Py_False;
 792   Py_INCREF(result);
 793   return result;
 794 }
 795 #endif
 796
 797 /* Py_ssize_t for old Pythons */
 798 /* This code is as recommended by: */
 799 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
 800 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
 801 typedef int Py_ssize_t;
 802 # define PY_SSIZE_T_MAX INT_MAX
 803 # define PY_SSIZE_T_MIN INT_MIN
 804 #endif
 805
 806 /* -----------------------------------------------------------------------------
 807  * error manipulation
 808  * ----------------------------------------------------------------------------- */
 809
 810 SWIGRUNTIME PyObject*
 811 SWIG_Python_ErrorType(int code) {
 812   PyObject* type = 0;
 813   switch(code) {
 814   case SWIG_MemoryError:
 815     type = PyExc_MemoryError;
 816     break;
 817   case SWIG_IOError:
 818     type = PyExc_IOError;
 819     break;
 820   case SWIG_RuntimeError:
 821     type = PyExc_RuntimeError;
 822     break;
 823   case SWIG_IndexError:
 824     type = PyExc_IndexError;
 825     break;
 826   case SWIG_TypeError:
 827     type = PyExc_TypeError;
 828     break;
 829   case SWIG_DivisionByZero:
 830     type = PyExc_ZeroDivisionError;
 831     break;
 832   case SWIG_OverflowError:
 833     type = PyExc_OverflowError;
 834     break;
 835   case SWIG_SyntaxError:
 836     type = PyExc_SyntaxError;
 837     break;
 838   case SWIG_ValueError:
 839     type = PyExc_ValueError;
 840     break;
 841   case SWIG_SystemError:
 842     type = PyExc_SystemError;
 843     break;
 844   case SWIG_AttributeError:
 845     type = PyExc_AttributeError;
 846     break;
 847   default:
 848     type = PyExc_RuntimeError;
 849   }
 850   return type;
 851 }
 852
 853
 854 SWIGRUNTIME void
 855 SWIG_Python_AddErrorMsg(const char* mesg)
 856 {
 857   PyObject *type = 0;
 858   PyObject *value = 0;
 859   PyObject *traceback = 0;
 860
 861   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
 862   if (value) {
 863     PyObject *old_str = PyObject_Str(value);
 864     PyErr_Clear();
 865     Py_XINCREF(type);
 866     PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
 867     Py_DECREF(old_str);
 868     Py_DECREF(value);
 869   } else {
 870     PyErr_Format(PyExc_RuntimeError, mesg);
 871   }
 872 }
 873
 874
 875
 876 #if defined(SWIG_PYTHON_NO_THREADS)
 877 #  if defined(SWIG_PYTHON_THREADS)
 878 #    undef SWIG_PYTHON_THREADS
 879 #  endif
 880 #endif
 881 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
 882 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
 883 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
 884 #      define SWIG_PYTHON_USE_GIL
 885 #    endif
 886 #  endif
 887 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
 888 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
 889 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads()
 890 #    endif
 891 #    ifdef __cplusplus /* C++ code */
 892        class SWIG_Python_Thread_Block {
 893          bool status;
 894          PyGILState_STATE state;
 895        public:
 896          void end() { if (status) { PyGILState_Release(state); status = false;} }
 897          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
 898          ~SWIG_Python_Thread_Block() { end(); }
 899        };
 900        class SWIG_Python_Thread_Allow {
 901          bool status;
 902          PyThreadState *save;
 903        public:
 904          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
 905          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
 906          ~SWIG_Python_Thread_Allow() { end(); }
 907        };
 908 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
 909 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
 910 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
 911 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
 912 #    else /* C code */
 913 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
 914 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
 915 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
 916 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
 917 #    endif
 918 #  else /* Old thread way, not implemented, user must provide it */
 919 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
 920 #      define SWIG_PYTHON_INITIALIZE_THREADS
 921 #    endif
 922 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
 923 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 924 #    endif
 925 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
 926 #      define SWIG_PYTHON_THREAD_END_BLOCK
 927 #    endif
 928 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
 929 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 930 #    endif
 931 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
 932 #      define SWIG_PYTHON_THREAD_END_ALLOW
 933 #    endif
 934 #  endif
 935 #else /* No thread support */
 936 #  define SWIG_PYTHON_INITIALIZE_THREADS
 937 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 938 #  define SWIG_PYTHON_THREAD_END_BLOCK
 939 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 940 #  define SWIG_PYTHON_THREAD_END_ALLOW
 941 #endif
 942
 943 /* -----------------------------------------------------------------------------
 944  * Python API portion that goes into the runtime
 945  * ----------------------------------------------------------------------------- */
 946
 947 #ifdef __cplusplus
 948 extern "C" {
 949 #if 0
 950 } /* cc-mode */
 951 #endif
 952 #endif
 953
 954 /* -----------------------------------------------------------------------------
 955  * Constant declarations
 956  * ----------------------------------------------------------------------------- */
 957
 958 /* Constant Types */
 959 #define SWIG_PY_POINTER 4
 960 #define SWIG_PY_BINARY  5
 961
 962 /* Constant information structure */
 963 typedef struct swig_const_info {
 964   int type;
 965   char *name;
 966   long lvalue;
 967   double dvalue;
 968   void   *pvalue;
 969   swig_type_info **ptype;
 970 } swig_const_info;
 971
 972 #ifdef __cplusplus
 973 #if 0
 974 { /* cc-mode */
 975 #endif
 976 }
 977 #endif
 978
 979
 980 /* -----------------------------------------------------------------------------
 981  * See the LICENSE file for information on copyright, usage and redistribution
 982  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 983  *
 984  * pyrun.swg
 985  *
 986  * This file contains the runtime support for Python modules
 987  * and includes code for managing global variables and pointer
 988  * type checking.
 989  *
 990  * ----------------------------------------------------------------------------- */
 991
 992 /* Common SWIG API */
 993
 994 /* for raw pointers */
 995 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
 996 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
 997 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
 998 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
 999 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty)
1000 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
1001 #define swig_owntype                                    int
1002
1003 /* for raw packed data */
1004 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1005 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1006
1007 /* for class or struct pointers */
1008 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
1009 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
1010
1011 /* for C or C++ function pointers */
1012 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1013 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
1014
1015 /* for C++ member pointers, ie, member methods */
1016 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1017 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1018
1019
1020 /* Runtime API */
1021
1022 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1023 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1024 #define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
1025
1026 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
1027 #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg
1028 #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)
1029 #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1030 #define SWIG_fail                                       goto fail
1031
1032
1033 /* Runtime API implementation */
1034
1035 /* Error manipulation */
1036
1037 SWIGINTERN void
1038 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1039   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1040   PyErr_SetObject(errtype, obj);
1041   Py_DECREF(obj);
1042   SWIG_PYTHON_THREAD_END_BLOCK;
1043 }
1044
1045 SWIGINTERN void
1046 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1047   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1048   PyErr_SetString(errtype, (char *) msg);
1049   SWIG_PYTHON_THREAD_END_BLOCK;
1050 }
1051
1052 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1053
1054 /* Set a constant value */
1055
1056 SWIGINTERN void
1057 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1058   PyDict_SetItemString(d, (char*) name, obj);
1059   Py_DECREF(obj);
1060 }
1061
1062 /* Append a value to the result obj */
1063
1064 SWIGINTERN PyObject*
1065 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1066 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1067   if (!result) {
1068     result = obj;
1069   } else if (result == Py_None) {
1070     Py_DECREF(result);
1071     result = obj;
1072   } else {
1073     if (!PyList_Check(result)) {
1074       PyObject *o2 = result;
1075       result = PyList_New(1);
1076       PyList_SetItem(result, 0, o2);
1077     }
1078     PyList_Append(result,obj);
1079     Py_DECREF(obj);
1080   }
1081   return result;
1082 #else
1083   PyObject*   o2;
1084   PyObject*   o3;
1085   if (!result) {
1086     result = obj;
1087   } else if (result == Py_None) {
1088     Py_DECREF(result);
1089     result = obj;
1090   } else {
1091     if (!PyTuple_Check(result)) {
1092       o2 = result;
1093       result = PyTuple_New(1);
1094       PyTuple_SET_ITEM(result, 0, o2);
1095     }
1096     o3 = PyTuple_New(1);
1097     PyTuple_SET_ITEM(o3, 0, obj);
1098     o2 = result;
1099     result = PySequence_Concat(o2, o3);
1100     Py_DECREF(o2);
1101     Py_DECREF(o3);
1102   }
1103   return result;
1104 #endif
1105 }
1106
1107 /* Unpack the argument tuple */
1108
1109 SWIGINTERN int
1110 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1111 {
1112   if (!args) {
1113     if (!min && !max) {
1114       return 1;
1115     } else {
1116       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1117                    name, (min == max ? "" : "at least "), min);
1118       return 0;
1119     }
1120   }
1121   if (!PyTuple_Check(args)) {
1122     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1123     return 0;
1124   } else {
1125     register int l = PyTuple_GET_SIZE(args);
1126     if (l < min) {
1127       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1128                    name, (min == max ? "" : "at least "), min, l);
1129       return 0;
1130     } else if (l > max) {
1131       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1132                    name, (min == max ? "" : "at most "), max, l);
1133       return 0;
1134     } else {
1135       register int i;
1136       for (i = 0; i < l; ++i) {
1137         objs[i] = PyTuple_GET_ITEM(args, i);
1138       }
1139       for (; l < max; ++l) {
1140         objs[l] = 0;
1141       }
1142       return i + 1;
1143     }
1144   }
1145 }
1146
1147 /* A functor is a function object with one single object argument */
1148 #if PY_VERSION_HEX >= 0x02020000
1149 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
1150 #else
1151 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
1152 #endif
1153
1154 /*
1155   Helper for static pointer initialization for both C and C++ code, for example
1156   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1157 */
1158 #ifdef __cplusplus
1159 #define SWIG_STATIC_POINTER(var)  var
1160 #else
1161 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1162 #endif
1163
1164 /* -----------------------------------------------------------------------------
1165  * Pointer declarations
1166  * ----------------------------------------------------------------------------- */
1167
1168 /* Flags for new pointer objects */
1169 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
1170 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1171
1172 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1173
1174 #ifdef __cplusplus
1175 extern "C" {
1176 #if 0
1177 } /* cc-mode */
1178 #endif
1179 #endif
1180
1181 /*  How to access Py_None */
1182 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1183 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
1184 #    ifndef SWIG_PYTHON_BUILD_NONE
1185 #      define SWIG_PYTHON_BUILD_NONE
1186 #    endif
1187 #  endif
1188 #endif
1189
1190 #ifdef SWIG_PYTHON_BUILD_NONE
1191 #  ifdef Py_None
1192 #   undef Py_None
1193 #   define Py_None SWIG_Py_None()
1194 #  endif
1195 SWIGRUNTIMEINLINE PyObject *
1196 _SWIG_Py_None(void)
1197 {
1198   PyObject *none = Py_BuildValue((char*)"");
1199   Py_DECREF(none);
1200   return none;
1201 }
1202 SWIGRUNTIME PyObject *
1203 SWIG_Py_None(void)
1204 {
1205   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1206   return none;
1207 }
1208 #endif
1209
1210 /* The python void return value */
1211
1212 SWIGRUNTIMEINLINE PyObject *
1213 SWIG_Py_Void(void)
1214 {
1215   PyObject *none = Py_None;
1216   Py_INCREF(none);
1217   return none;
1218 }
1219
1220 /* PySwigClientData */
1221
1222 typedef struct {
1223   PyObject *klass;
1224   PyObject *newraw;
1225   PyObject *newargs;
1226   PyObject *destroy;
1227   int delargs;
1228   int implicitconv;
1229 } PySwigClientData;
1230
1231 SWIGRUNTIMEINLINE int
1232 SWIG_Python_CheckImplicit(swig_type_info *ty)
1233 {
1234   PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1235   return data ? data->implicitconv : 0;
1236 }
1237
1238 SWIGRUNTIMEINLINE PyObject *
1239 SWIG_Python_ExceptionType(swig_type_info *desc) {
1240   PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1241   PyObject *klass = data ? data->klass : 0;
1242   return (klass ? klass : PyExc_RuntimeError);
1243 }
1244
1245
1246 SWIGRUNTIME PySwigClientData *
1247 PySwigClientData_New(PyObject* obj)
1248 {
1249   if (!obj) {
1250     return 0;
1251   } else {
1252     PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1253     /* the klass element */
1254     data->klass = obj;
1255     Py_INCREF(data->klass);
1256     /* the newraw method and newargs arguments used to create a new raw instance */
1257     if (PyClass_Check(obj)) {
1258       data->newraw = 0;
1259       data->newargs = obj;
1260       Py_INCREF(obj);
1261     } else {
1262 #if (PY_VERSION_HEX < 0x02020000)
1263       data->newraw = 0;
1264 #else
1265       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1266 #endif
1267       if (data->newraw) {
1268         Py_INCREF(data->newraw);
1269         data->newargs = PyTuple_New(1);
1270         PyTuple_SetItem(data->newargs, 0, obj);
1271       } else {
1272         data->newargs = obj;
1273       }
1274       Py_INCREF(data->newargs);
1275     }
1276     /* the destroy method, aka as the C++ delete method */
1277     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1278     if (PyErr_Occurred()) {
1279       PyErr_Clear();
1280       data->destroy = 0;
1281     }
1282     if (data->destroy) {
1283       int flags;
1284       Py_INCREF(data->destroy);
1285       flags = PyCFunction_GET_FLAGS(data->destroy);
1286 #ifdef METH_O
1287       data->delargs = !(flags & (METH_O));
1288 #else
1289       data->delargs = 0;
1290 #endif
1291     } else {
1292       data->delargs = 0;
1293     }
1294     data->implicitconv = 0;
1295     return data;
1296   }
1297 }
1298
1299 SWIGRUNTIME void
1300 PySwigClientData_Del(PySwigClientData* data)
1301 {
1302   Py_XDECREF(data->newraw);
1303   Py_XDECREF(data->newargs);
1304   Py_XDECREF(data->destroy);
1305 }
1306
1307 /* =============== PySwigObject =====================*/
1308
1309 typedef struct {
1310   PyObject_HEAD
1311   void *ptr;
1312   swig_type_info *ty;
1313   int own;
1314   PyObject *next;
1315 } PySwigObject;
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_long(PySwigObject *v)
1319 {
1320   return PyLong_FromVoidPtr(v->ptr);
1321 }
1322
1323 SWIGRUNTIME PyObject *
1324 PySwigObject_format(const char* fmt, PySwigObject *v)
1325 {
1326   PyObject *res = NULL;
1327   PyObject *args = PyTuple_New(1);
1328   if (args) {
1329     if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1330       PyObject *ofmt = PyString_FromString(fmt);
1331       if (ofmt) {
1332         res = PyString_Format(ofmt,args);
1333         Py_DECREF(ofmt);
1334       }
1335       Py_DECREF(args);
1336     }
1337   }
1338   return res;
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_oct(PySwigObject *v)
1343 {
1344   return PySwigObject_format("%o",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 PySwigObject_hex(PySwigObject *v)
1349 {
1350   return PySwigObject_format("%x",v);
1351 }
1352
1353 SWIGRUNTIME PyObject *
1354 #ifdef METH_NOARGS
1355 PySwigObject_repr(PySwigObject *v)
1356 #else
1357 PySwigObject_repr(PySwigObject *v, PyObject *args)
1358 #endif
1359 {
1360   const char *name = SWIG_TypePrettyName(v->ty);
1361   PyObject *hex = PySwigObject_hex(v);
1362   PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1363   Py_DECREF(hex);
1364   if (v->next) {
1365 #ifdef METH_NOARGS
1366     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1367 #else
1368     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1369 #endif
1370     PyString_ConcatAndDel(&repr,nrep);
1371   }
1372   return repr;
1373 }
1374
1375 SWIGRUNTIME int
1376 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1377 {
1378 #ifdef METH_NOARGS
1379   PyObject *repr = PySwigObject_repr(v);
1380 #else
1381   PyObject *repr = PySwigObject_repr(v, NULL);
1382 #endif
1383   if (repr) {
1384     fputs(PyString_AsString(repr), fp);
1385     Py_DECREF(repr);
1386     return 0;
1387   } else {
1388     return 1;
1389   }
1390 }
1391
1392 SWIGRUNTIME PyObject *
1393 PySwigObject_str(PySwigObject *v)
1394 {
1395   char result[SWIG_BUFFER_SIZE];
1396   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1397     PyString_FromString(result) : 0;
1398 }
1399
1400 SWIGRUNTIME int
1401 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1402 {
1403   void *i = v->ptr;
1404   void *j = w->ptr;
1405   return (i < j) ? -1 : ((i > j) ? 1 : 0);
1406 }
1407
1408 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1409
1410 SWIGRUNTIME PyTypeObject*
1411 PySwigObject_type(void) {
1412   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1413   return type;
1414 }
1415
1416 SWIGRUNTIMEINLINE int
1417 PySwigObject_Check(PyObject *op) {
1418   return ((op)->ob_type == PySwigObject_type())
1419     || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1420 }
1421
1422 SWIGRUNTIME PyObject *
1423 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1424
1425 SWIGRUNTIME void
1426 PySwigObject_dealloc(PyObject *v)
1427 {
1428   PySwigObject *sobj = (PySwigObject *) v;
1429   PyObject *next = sobj->next;
1430   if (sobj->own) {
1431     swig_type_info *ty = sobj->ty;
1432     PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1433     PyObject *destroy = data ? data->destroy : 0;
1434     if (destroy) {
1435       /* destroy is always a VARARGS method */
1436       PyObject *res;
1437       if (data->delargs) {
1438         /* we need to create a temporal object to carry the destroy operation */
1439         PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1440         res = SWIG_Python_CallFunctor(destroy, tmp);
1441         Py_DECREF(tmp);
1442       } else {
1443         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1444         PyObject *mself = PyCFunction_GET_SELF(destroy);
1445         res = ((*meth)(mself, v));
1446       }
1447       Py_XDECREF(res);
1448     } else {
1449       const char *name = SWIG_TypePrettyName(ty);
1450 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1451       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1452 #endif
1453     }
1454   }
1455   Py_XDECREF(next);
1456   PyObject_DEL(v);
1457 }
1458
1459 SWIGRUNTIME PyObject*
1460 PySwigObject_append(PyObject* v, PyObject* next)
1461 {
1462   PySwigObject *sobj = (PySwigObject *) v;
1463 #ifndef METH_O
1464   PyObject *tmp = 0;
1465   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1466   next = tmp;
1467 #endif
1468   if (!PySwigObject_Check(next)) {
1469     return NULL;
1470   }
1471   sobj->next = next;
1472   Py_INCREF(next);
1473   return SWIG_Py_Void();
1474 }
1475
1476 SWIGRUNTIME PyObject*
1477 #ifdef METH_NOARGS
1478 PySwigObject_next(PyObject* v)
1479 #else
1480 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1481 #endif
1482 {
1483   PySwigObject *sobj = (PySwigObject *) v;
1484   if (sobj->next) {
1485     Py_INCREF(sobj->next);
1486     return sobj->next;
1487   } else {
1488     return SWIG_Py_Void();
1489   }
1490 }
1491
1492 SWIGINTERN PyObject*
1493 #ifdef METH_NOARGS
1494 PySwigObject_disown(PyObject *v)
1495 #else
1496 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1497 #endif
1498 {
1499   PySwigObject *sobj = (PySwigObject *)v;
1500   sobj->own = 0;
1501   return SWIG_Py_Void();
1502 }
1503
1504 SWIGINTERN PyObject*
1505 #ifdef METH_NOARGS
1506 PySwigObject_acquire(PyObject *v)
1507 #else
1508 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1509 #endif
1510 {
1511   PySwigObject *sobj = (PySwigObject *)v;
1512   sobj->own = SWIG_POINTER_OWN;
1513   return SWIG_Py_Void();
1514 }
1515
1516 SWIGINTERN PyObject*
1517 PySwigObject_own(PyObject *v, PyObject *args)
1518 {
1519   PyObject *val = 0;
1520 #if (PY_VERSION_HEX < 0x02020000)
1521   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1522 #else
1523   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1524 #endif
1525     {
1526       return NULL;
1527     }
1528   else
1529     {
1530       PySwigObject *sobj = (PySwigObject *)v;
1531       PyObject *obj = PyBool_FromLong(sobj->own);
1532       if (val) {
1533 #ifdef METH_NOARGS
1534         if (PyObject_IsTrue(val)) {
1535           PySwigObject_acquire(v);
1536         } else {
1537           PySwigObject_disown(v);
1538         }
1539 #else
1540         if (PyObject_IsTrue(val)) {
1541           PySwigObject_acquire(v,args);
1542         } else {
1543           PySwigObject_disown(v,args);
1544         }
1545 #endif
1546       }
1547       return obj;
1548     }
1549 }
1550
1551 #ifdef METH_O
1552 static PyMethodDef
1553 swigobject_methods[] = {
1554   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1555   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
1556   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1557   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
1558   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1559   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1560   {0, 0, 0, 0}
1561 };
1562 #else
1563 static PyMethodDef
1564 swigobject_methods[] = {
1565   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1566   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1567   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1568   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1569   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1570   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1571   {0, 0, 0, 0}
1572 };
1573 #endif
1574
1575 #if PY_VERSION_HEX < 0x02020000
1576 SWIGINTERN PyObject *
1577 PySwigObject_getattr(PySwigObject *sobj,char *name)
1578 {
1579   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1580 }
1581 #endif
1582
1583 SWIGRUNTIME PyTypeObject*
1584 _PySwigObject_type(void) {
1585   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1586
1587   static PyNumberMethods PySwigObject_as_number = {
1588     (binaryfunc)0, /*nb_add*/
1589     (binaryfunc)0, /*nb_subtract*/
1590     (binaryfunc)0, /*nb_multiply*/
1591     (binaryfunc)0, /*nb_divide*/
1592     (binaryfunc)0, /*nb_remainder*/
1593     (binaryfunc)0, /*nb_divmod*/
1594     (ternaryfunc)0,/*nb_power*/
1595     (unaryfunc)0,  /*nb_negative*/
1596     (unaryfunc)0,  /*nb_positive*/
1597     (unaryfunc)0,  /*nb_absolute*/
1598     (inquiry)0,    /*nb_nonzero*/
1599     0,             /*nb_invert*/
1600     0,             /*nb_lshift*/
1601     0,             /*nb_rshift*/
1602     0,             /*nb_and*/
1603     0,             /*nb_xor*/
1604     0,             /*nb_or*/
1605     (coercion)0,   /*nb_coerce*/
1606     (unaryfunc)PySwigObject_long, /*nb_int*/
1607     (unaryfunc)PySwigObject_long, /*nb_long*/
1608     (unaryfunc)0,                 /*nb_float*/
1609     (unaryfunc)PySwigObject_oct,  /*nb_oct*/
1610     (unaryfunc)PySwigObject_hex,  /*nb_hex*/
1611 #if PY_VERSION_HEX >= 0x02020000
1612     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1613 #elif PY_VERSION_HEX >= 0x02000000
1614     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1615 #endif
1616   };
1617
1618   static PyTypeObject pyswigobject_type;
1619   static int type_init = 0;
1620   if (!type_init) {
1621     const PyTypeObject tmp
1622       = {
1623         PyObject_HEAD_INIT(NULL)
1624         0,                                  /* ob_size */
1625         (char *)"PySwigObject",             /* tp_name */
1626         sizeof(PySwigObject),               /* tp_basicsize */
1627         0,                                  /* tp_itemsize */
1628         (destructor)PySwigObject_dealloc,   /* tp_dealloc */
1629         (printfunc)PySwigObject_print,      /* tp_print */
1630 #if PY_VERSION_HEX < 0x02020000
1631         (getattrfunc)PySwigObject_getattr,  /* tp_getattr */
1632 #else
1633         (getattrfunc)0,                     /* tp_getattr */
1634 #endif
1635         (setattrfunc)0,                     /* tp_setattr */
1636         (cmpfunc)PySwigObject_compare,      /* tp_compare */
1637         (reprfunc)PySwigObject_repr,        /* tp_repr */
1638         &PySwigObject_as_number,            /* tp_as_number */
1639         0,                                  /* tp_as_sequence */
1640         0,                                  /* tp_as_mapping */
1641         (hashfunc)0,                        /* tp_hash */
1642         (ternaryfunc)0,                     /* tp_call */
1643         (reprfunc)PySwigObject_str,         /* tp_str */
1644         PyObject_GenericGetAttr,            /* tp_getattro */
1645         0,                                  /* tp_setattro */
1646         0,                                  /* tp_as_buffer */
1647         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1648         swigobject_doc,                     /* tp_doc */
1649         0,                                  /* tp_traverse */
1650         0,                                  /* tp_clear */
1651         0,                                  /* tp_richcompare */
1652         0,                                  /* tp_weaklistoffset */
1653 #if PY_VERSION_HEX >= 0x02020000
1654         0,                                  /* tp_iter */
1655         0,                                  /* tp_iternext */
1656         swigobject_methods,                 /* tp_methods */
1657         0,                                  /* tp_members */
1658         0,                                  /* tp_getset */
1659         0,                                  /* tp_base */
1660         0,                                  /* tp_dict */
1661         0,                                  /* tp_descr_get */
1662         0,                                  /* tp_descr_set */
1663         0,                                  /* tp_dictoffset */
1664         0,                                  /* tp_init */
1665         0,                                  /* tp_alloc */
1666         0,                                  /* tp_new */
1667         0,                                  /* tp_free */
1668         0,                                  /* tp_is_gc */
1669         0,                                  /* tp_bases */
1670         0,                                  /* tp_mro */
1671         0,                                  /* tp_cache */
1672         0,                                  /* tp_subclasses */
1673         0,                                  /* tp_weaklist */
1674 #endif
1675 #if PY_VERSION_HEX >= 0x02030000
1676         0,                                  /* tp_del */
1677 #endif
1678 #ifdef COUNT_ALLOCS
1679         0,0,0,0                             /* tp_alloc -> tp_next */
1680 #endif
1681       };
1682     pyswigobject_type = tmp;
1683     pyswigobject_type.ob_type = &PyType_Type;
1684     type_init = 1;
1685   }
1686   return &pyswigobject_type;
1687 }
1688
1689 SWIGRUNTIME PyObject *
1690 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1691 {
1692   PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1693   if (sobj) {
1694     sobj->ptr  = ptr;
1695     sobj->ty   = ty;
1696     sobj->own  = own;
1697     sobj->next = 0;
1698   }
1699   return (PyObject *)sobj;
1700 }
1701
1702 /* -----------------------------------------------------------------------------
1703  * Implements a simple Swig Packed type, and use it instead of string
1704  * ----------------------------------------------------------------------------- */
1705
1706 typedef struct {
1707   PyObject_HEAD
1708   void *pack;
1709   swig_type_info *ty;
1710   size_t size;
1711 } PySwigPacked;
1712
1713 SWIGRUNTIME int
1714 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1715 {
1716   char result[SWIG_BUFFER_SIZE];
1717   fputs("<Swig Packed ", fp);
1718   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1719     fputs("at ", fp);
1720     fputs(result, fp);
1721   }
1722   fputs(v->ty->name,fp);
1723   fputs(">", fp);
1724   return 0;
1725 }
1726
1727 SWIGRUNTIME PyObject *
1728 PySwigPacked_repr(PySwigPacked *v)
1729 {
1730   char result[SWIG_BUFFER_SIZE];
1731   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1732     return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1733   } else {
1734     return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1735   }
1736 }
1737
1738 SWIGRUNTIME PyObject *
1739 PySwigPacked_str(PySwigPacked *v)
1740 {
1741   char result[SWIG_BUFFER_SIZE];
1742   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1743     return PyString_FromFormat("%s%s", result, v->ty->name);
1744   } else {
1745     return PyString_FromString(v->ty->name);
1746   }
1747 }
1748
1749 SWIGRUNTIME int
1750 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1751 {
1752   size_t i = v->size;
1753   size_t j = w->size;
1754   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1755   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1756 }
1757
1758 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1759
1760 SWIGRUNTIME PyTypeObject*
1761 PySwigPacked_type(void) {
1762   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1763   return type;
1764 }
1765
1766 SWIGRUNTIMEINLINE int
1767 PySwigPacked_Check(PyObject *op) {
1768   return ((op)->ob_type == _PySwigPacked_type())
1769     || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1770 }
1771
1772 SWIGRUNTIME void
1773 PySwigPacked_dealloc(PyObject *v)
1774 {
1775   if (PySwigPacked_Check(v)) {
1776     PySwigPacked *sobj = (PySwigPacked *) v;
1777     free(sobj->pack);
1778   }
1779   PyObject_DEL(v);
1780 }
1781
1782 SWIGRUNTIME PyTypeObject*
1783 _PySwigPacked_type(void) {
1784   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1785   static PyTypeObject pyswigpacked_type;
1786   static int type_init = 0;
1787   if (!type_init) {
1788     const PyTypeObject tmp
1789       = {
1790         PyObject_HEAD_INIT(NULL)
1791         0,                                  /* ob_size */
1792         (char *)"PySwigPacked",             /* tp_name */
1793         sizeof(PySwigPacked),               /* tp_basicsize */
1794         0,                                  /* tp_itemsize */
1795         (destructor)PySwigPacked_dealloc,   /* tp_dealloc */
1796         (printfunc)PySwigPacked_print,      /* tp_print */
1797         (getattrfunc)0,                     /* tp_getattr */
1798         (setattrfunc)0,                     /* tp_setattr */
1799         (cmpfunc)PySwigPacked_compare,      /* tp_compare */
1800         (reprfunc)PySwigPacked_repr,        /* tp_repr */
1801         0,                                  /* tp_as_number */
1802         0,                                  /* tp_as_sequence */
1803         0,                                  /* tp_as_mapping */
1804         (hashfunc)0,                        /* tp_hash */
1805         (ternaryfunc)0,                     /* tp_call */
1806         (reprfunc)PySwigPacked_str,         /* tp_str */
1807         PyObject_GenericGetAttr,            /* tp_getattro */
1808         0,                                  /* tp_setattro */
1809         0,                                  /* tp_as_buffer */
1810         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1811         swigpacked_doc,                     /* tp_doc */
1812         0,                                  /* tp_traverse */
1813         0,                                  /* tp_clear */
1814         0,                                  /* tp_richcompare */
1815         0,                                  /* tp_weaklistoffset */
1816 #if PY_VERSION_HEX >= 0x02020000
1817         0,                                  /* tp_iter */
1818         0,                                  /* tp_iternext */
1819         0,                                  /* tp_methods */
1820         0,                                  /* tp_members */
1821         0,                                  /* tp_getset */
1822         0,                                  /* tp_base */
1823         0,                                  /* tp_dict */
1824         0,                                  /* tp_descr_get */
1825         0,                                  /* tp_descr_set */
1826         0,                                  /* tp_dictoffset */
1827         0,                                  /* tp_init */
1828         0,                                  /* tp_alloc */
1829         0,                                  /* tp_new */
1830         0,                                  /* tp_free */
1831         0,                                  /* tp_is_gc */
1832         0,                                  /* tp_bases */
1833         0,                                  /* tp_mro */
1834         0,                                  /* tp_cache */
1835         0,                                  /* tp_subclasses */
1836         0,                                  /* tp_weaklist */
1837 #endif
1838 #if PY_VERSION_HEX >= 0x02030000
1839         0,                                  /* tp_del */
1840 #endif
1841 #ifdef COUNT_ALLOCS
1842         0,0,0,0                             /* tp_alloc -> tp_next */
1843 #endif
1844       };
1845     pyswigpacked_type = tmp;
1846     pyswigpacked_type.ob_type = &PyType_Type;
1847     type_init = 1;
1848   }
1849   return &pyswigpacked_type;
1850 }
1851
1852 SWIGRUNTIME PyObject *
1853 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1854 {
1855   PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1856   if (sobj) {
1857     void *pack = malloc(size);
1858     if (pack) {
1859       memcpy(pack, ptr, size);
1860       sobj->pack = pack;
1861       sobj->ty   = ty;
1862       sobj->size = size;
1863     } else {
1864       PyObject_DEL((PyObject *) sobj);
1865       sobj = 0;
1866     }
1867   }
1868   return (PyObject *) sobj;
1869 }
1870
1871 SWIGRUNTIME swig_type_info *
1872 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1873 {
1874   if (PySwigPacked_Check(obj)) {
1875     PySwigPacked *sobj = (PySwigPacked *)obj;
1876     if (sobj->size != size) return 0;
1877     memcpy(ptr, sobj->pack, size);
1878     return sobj->ty;
1879   } else {
1880     return 0;
1881   }
1882 }
1883
1884 /* -----------------------------------------------------------------------------
1885  * pointers/data manipulation
1886  * ----------------------------------------------------------------------------- */
1887
1888 SWIGRUNTIMEINLINE PyObject *
1889 _SWIG_This(void)
1890 {
1891   return PyString_FromString("this");
1892 }
1893
1894 SWIGRUNTIME PyObject *
1895 SWIG_This(void)
1896 {
1897   static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1898   return swig_this;
1899 }
1900
1901 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1902
1903 SWIGRUNTIME PySwigObject *
1904 SWIG_Python_GetSwigThis(PyObject *pyobj)
1905 {
1906   if (PySwigObject_Check(pyobj)) {
1907     return (PySwigObject *) pyobj;
1908   } else {
1909     PyObject *obj = 0;
1910 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1911     if (PyInstance_Check(pyobj)) {
1912       obj = _PyInstance_Lookup(pyobj, SWIG_This());
1913     } else {
1914       PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1915       if (dictptr != NULL) {
1916         PyObject *dict = *dictptr;
1917         obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1918       } else {
1919 #ifdef PyWeakref_CheckProxy
1920         if (PyWeakref_CheckProxy(pyobj)) {
1921           PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1922           return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1923         }
1924 #endif
1925         obj = PyObject_GetAttr(pyobj,SWIG_This());
1926         if (obj) {
1927           Py_DECREF(obj);
1928         } else {
1929           if (PyErr_Occurred()) PyErr_Clear();
1930           return 0;
1931         }
1932       }
1933     }
1934 #else
1935     obj = PyObject_GetAttr(pyobj,SWIG_This());
1936     if (obj) {
1937       Py_DECREF(obj);
1938     } else {
1939       if (PyErr_Occurred()) PyErr_Clear();
1940       return 0;
1941     }
1942 #endif
1943     if (obj && !PySwigObject_Check(obj)) {
1944       /* a PyObject is called 'this', try to get the 'real this'
1945          PySwigObject from it */
1946       return SWIG_Python_GetSwigThis(obj);
1947     }
1948     return (PySwigObject *)obj;
1949   }
1950 }
1951
1952 /* Acquire a pointer value */
1953
1954 SWIGRUNTIME int
1955 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1956   if (own) {
1957     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1958     if (sobj) {
1959       int oldown = sobj->own;
1960       sobj->own = own;
1961       return oldown;
1962     }
1963   }
1964   return 0;
1965 }
1966
1967 /* Convert a pointer value */
1968
1969 SWIGRUNTIME int
1970 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1971   if (!obj) return SWIG_ERROR;
1972   if (obj == Py_None) {
1973     if (ptr) *ptr = 0;
1974     return SWIG_OK;
1975   } else {
1976     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1977     while (sobj) {
1978       void *vptr = sobj->ptr;
1979       if (ty) {
1980         swig_type_info *to = sobj->ty;
1981         if (to == ty) {
1982           /* no type cast needed */
1983           if (ptr) *ptr = vptr;
1984           break;
1985         } else {
1986           swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1987           if (!tc) {
1988             sobj = (PySwigObject *)sobj->next;
1989           } else {
1990             if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1991             break;
1992           }
1993         }
1994       } else {
1995         if (ptr) *ptr = vptr;
1996         break;
1997       }
1998     }
1999     if (sobj) {
2000       if (own) *own = sobj->own;
2001       if (flags & SWIG_POINTER_DISOWN) {
2002         sobj->own = 0;
2003       }
2004       return SWIG_OK;
2005     } else {
2006       int res = SWIG_ERROR;
2007       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2008         PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2009         if (data && !data->implicitconv) {
2010           PyObject *klass = data->klass;
2011           if (klass) {
2012             PyObject *impconv;
2013             data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2014             impconv = SWIG_Python_CallFunctor(klass, obj);
2015             data->implicitconv = 0;
2016             if (PyErr_Occurred()) {
2017               PyErr_Clear();
2018               impconv = 0;
2019             }
2020             if (impconv) {
2021               PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2022               if (iobj) {
2023                 void *vptr;
2024                 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2025                 if (SWIG_IsOK(res)) {
2026                   if (ptr) {
2027                     *ptr = vptr;
2028                     /* transfer the ownership to 'ptr' */
2029                     iobj->own = 0;
2030                     res = SWIG_AddCast(res);
2031                     res = SWIG_AddNewMask(res);
2032                   } else {
2033                     res = SWIG_AddCast(res);
2034                   }
2035                 }
2036               }
2037               Py_DECREF(impconv);
2038             }
2039           }
2040         }
2041       }
2042       return res;
2043     }
2044   }
2045 }
2046
2047 /* Convert a function ptr value */
2048
2049 SWIGRUNTIME int
2050 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2051   if (!PyCFunction_Check(obj)) {
2052     return SWIG_ConvertPtr(obj, ptr, ty, 0);
2053   } else {
2054     void *vptr = 0;
2055
2056     /* here we get the method pointer for callbacks */
2057     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2058     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2059     if (desc) {
2060       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2061       if (!desc) return SWIG_ERROR;
2062     }
2063     if (ty) {
2064       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2065       if (!tc) return SWIG_ERROR;
2066       *ptr = SWIG_TypeCast(tc,vptr);
2067     } else {
2068       *ptr = vptr;
2069     }
2070     return SWIG_OK;
2071   }
2072 }
2073
2074 /* Convert a packed value value */
2075
2076 SWIGRUNTIME int
2077 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2078   swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2079   if (!to) return SWIG_ERROR;
2080   if (ty) {
2081     if (to != ty) {
2082       /* check type cast? */
2083       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2084       if (!tc) return SWIG_ERROR;
2085     }
2086   }
2087   return SWIG_OK;
2088 }
2089
2090 /* -----------------------------------------------------------------------------
2091  * Create a new pointer object
2092  * ----------------------------------------------------------------------------- */
2093
2094 /*
2095   Create a new instance object, whitout calling __init__, and set the
2096   'this' attribute.
2097 */
2098
2099 SWIGRUNTIME PyObject*
2100 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2101 {
2102 #if (PY_VERSION_HEX >= 0x02020000)
2103   PyObject *inst = 0;
2104   PyObject *newraw = data->newraw;
2105   if (newraw) {
2106     inst = PyObject_Call(newraw, data->newargs, NULL);
2107     if (inst) {
2108 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2109       PyObject **dictptr = _PyObject_GetDictPtr(inst);
2110       if (dictptr != NULL) {
2111         PyObject *dict = *dictptr;
2112         if (dict == NULL) {
2113           dict = PyDict_New();
2114           *dictptr = dict;
2115           PyDict_SetItem(dict, SWIG_This(), swig_this);
2116         }
2117       }
2118 #else
2119       PyObject *key = SWIG_This();
2120       PyObject_SetAttr(inst, key, swig_this);
2121 #endif
2122     }
2123   } else {
2124     PyObject *dict = PyDict_New();
2125     PyDict_SetItem(dict, SWIG_This(), swig_this);
2126     inst = PyInstance_NewRaw(data->newargs, dict);
2127     Py_DECREF(dict);
2128   }
2129   return inst;
2130 #else
2131 #if (PY_VERSION_HEX >= 0x02010000)
2132   PyObject *inst;
2133   PyObject *dict = PyDict_New();
2134   PyDict_SetItem(dict, SWIG_This(), swig_this);
2135   inst = PyInstance_NewRaw(data->newargs, dict);
2136   Py_DECREF(dict);
2137   return (PyObject *) inst;
2138 #else
2139   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2140   if (inst == NULL) {
2141     return NULL;
2142   }
2143   inst->in_class = (PyClassObject *)data->newargs;
2144   Py_INCREF(inst->in_class);
2145   inst->in_dict = PyDict_New();
2146   if (inst->in_dict == NULL) {
2147     Py_DECREF(inst);
2148     return NULL;
2149   }
2150 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2151   inst->in_weakreflist = NULL;
2152 #endif
2153 #ifdef Py_TPFLAGS_GC
2154   PyObject_GC_Init(inst);
2155 #endif
2156   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2157   return (PyObject *) inst;
2158 #endif
2159 #endif
2160 }
2161
2162 SWIGRUNTIME void
2163 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2164 {
2165  PyObject *dict;
2166 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2167  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2168  if (dictptr != NULL) {
2169    dict = *dictptr;
2170    if (dict == NULL) {
2171      dict = PyDict_New();
2172      *dictptr = dict;
2173    }
2174    PyDict_SetItem(dict, SWIG_This(), swig_this);
2175    return;
2176  }
2177 #endif
2178  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2179  PyDict_SetItem(dict, SWIG_This(), swig_this);
2180  Py_DECREF(dict);
2181 }
2182
2183
2184 SWIGINTERN PyObject *
2185 SWIG_Python_InitShadowInstance(PyObject *args) {
2186   PyObject *obj[2];
2187   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2188     return NULL;
2189   } else {
2190     PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2191     if (sthis) {
2192       PySwigObject_append((PyObject*) sthis, obj[1]);
2193     } else {
2194       SWIG_Python_SetSwigThis(obj[0], obj[1]);
2195     }
2196     return SWIG_Py_Void();
2197   }
2198 }
2199
2200 /* Create a new pointer object */
2201
2202 SWIGRUNTIME PyObject *
2203 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2204   if (!ptr) {
2205     return SWIG_Py_Void();
2206   } else {
2207     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2208     PyObject *robj = PySwigObject_New(ptr, type, own);
2209     PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2210     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2211       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2212       if (inst) {
2213         Py_DECREF(robj);
2214         robj = inst;
2215       }
2216     }
2217     return robj;
2218   }
2219 }
2220
2221 /* Create a new packed object */
2222
2223 SWIGRUNTIMEINLINE PyObject *
2224 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2225   return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2226 }
2227
2228 /* -----------------------------------------------------------------------------*
2229  *  Get type list
2230  * -----------------------------------------------------------------------------*/
2231
2232 #ifdef SWIG_LINK_RUNTIME
2233 void *SWIG_ReturnGlobalTypeList(void *);
2234 #endif
2235
2236 SWIGRUNTIME swig_module_info *
2237 SWIG_Python_GetModule(void) {
2238   static void *type_pointer = (void *)0;
2239   /* first check if module already created */
2240   if (!type_pointer) {
2241 #ifdef SWIG_LINK_RUNTIME
2242     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2243 #else
2244     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2245                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2246     if (PyErr_Occurred()) {
2247       PyErr_Clear();
2248       type_pointer = (void *)0;
2249     }
2250 #endif
2251   }
2252   return (swig_module_info *) type_pointer;
2253 }
2254
2255 #if PY_MAJOR_VERSION < 2
2256 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
2257    is copied out of Python/modsupport.c in python version 2.3.4 */
2258 SWIGINTERN int
2259 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2260 {
2261   PyObject *dict;
2262   if (!PyModule_Check(m)) {
2263     PyErr_SetString(PyExc_TypeError,
2264                     "PyModule_AddObject() needs module as first arg");
2265     return SWIG_ERROR;
2266   }
2267   if (!o) {
2268     PyErr_SetString(PyExc_TypeError,
2269                     "PyModule_AddObject() needs non-NULL value");
2270     return SWIG_ERROR;
2271   }
2272
2273   dict = PyModule_GetDict(m);
2274   if (dict == NULL) {
2275     /* Internal error -- modules must have a dict! */
2276     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2277                  PyModule_GetName(m));
2278     return SWIG_ERROR;
2279   }
2280   if (PyDict_SetItemString(dict, name, o))
2281     return SWIG_ERROR;
2282   Py_DECREF(o);
2283   return SWIG_OK;
2284 }
2285 #endif
2286
2287 SWIGRUNTIME void
2288 SWIG_Python_DestroyModule(void *vptr)
2289 {
2290   swig_module_info *swig_module = (swig_module_info *) vptr;
2291   swig_type_info **types = swig_module->types;
2292   size_t i;
2293   for (i =0; i < swig_module->size; ++i) {
2294     swig_type_info *ty = types[i];
2295     if (ty->owndata) {
2296       PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2297       if (data) PySwigClientData_Del(data);
2298     }
2299   }
2300   Py_DECREF(SWIG_This());
2301 }
2302
2303 SWIGRUNTIME void
2304 SWIG_Python_SetModule(swig_module_info *swig_module) {
2305   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2306
2307   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2308                                    swig_empty_runtime_method_table);
2309   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2310   if (pointer && module) {
2311     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2312   } else {
2313     Py_XDECREF(pointer);
2314   }
2315 }
2316
2317 /* The python cached type query */
2318 SWIGRUNTIME PyObject *
2319 SWIG_Python_TypeCache(void) {
2320   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2321   return cache;
2322 }
2323
2324 SWIGRUNTIME swig_type_info *
2325 SWIG_Python_TypeQuery(const char *type)
2326 {
2327   PyObject *cache = SWIG_Python_TypeCache();
2328   PyObject *key = PyString_FromString(type);
2329   PyObject *obj = PyDict_GetItem(cache, key);
2330   swig_type_info *descriptor;
2331   if (obj) {
2332     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2333   } else {
2334     swig_module_info *swig_module = SWIG_Python_GetModule();
2335     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2336     if (descriptor) {
2337       obj = PyCObject_FromVoidPtr(descriptor, NULL);
2338       PyDict_SetItem(cache, key, obj);
2339       Py_DECREF(obj);
2340     }
2341   }
2342   Py_DECREF(key);
2343   return descriptor;
2344 }
2345
2346 /*
2347    For backward compatibility only
2348 */
2349 #define SWIG_POINTER_EXCEPTION  0
2350 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2351 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2352
2353 SWIGRUNTIME int
2354 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2355 {
2356   if (PyErr_Occurred()) {
2357     PyObject *type = 0;
2358     PyObject *value = 0;
2359     PyObject *traceback = 0;
2360     PyErr_Fetch(&type, &value, &traceback);
2361     if (value) {
2362       PyObject *old_str = PyObject_Str(value);
2363       Py_XINCREF(type);
2364       PyErr_Clear();
2365       if (infront) {
2366         PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2367       } else {
2368         PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2369       }
2370       Py_DECREF(old_str);
2371     }
2372     return 1;
2373   } else {
2374     return 0;
2375   }
2376 }
2377
2378 SWIGRUNTIME int
2379 SWIG_Python_ArgFail(int argnum)
2380 {
2381   if (PyErr_Occurred()) {
2382     /* add information about failing argument */
2383     char mesg[256];
2384     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2385     return SWIG_Python_AddErrMesg(mesg, 1);
2386   } else {
2387     return 0;
2388   }
2389 }
2390
2391 SWIGRUNTIMEINLINE const char *
2392 PySwigObject_GetDesc(PyObject *self)
2393 {
2394   PySwigObject *v = (PySwigObject *)self;
2395   swig_type_info *ty = v ? v->ty : 0;
2396   return ty ? ty->str : (char*)"";
2397 }
2398
2399 SWIGRUNTIME void
2400 SWIG_Python_TypeError(const char *type, PyObject *obj)
2401 {
2402   if (type) {
2403 #if defined(SWIG_COBJECT_TYPES)
2404     if (obj && PySwigObject_Check(obj)) {
2405       const char *otype = (const char *) PySwigObject_GetDesc(obj);
2406       if (otype) {
2407         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2408                      type, otype);
2409         return;
2410       }
2411     } else
2412 #endif
2413     {
2414       const char *otype = (obj ? obj->ob_type->tp_name : 0);
2415       if (otype) {
2416         PyObject *str = PyObject_Str(obj);
2417         const char *cstr = str ? PyString_AsString(str) : 0;
2418         if (cstr) {
2419           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2420                        type, otype, cstr);
2421         } else {
2422           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2423                        type, otype);
2424         }
2425         Py_XDECREF(str);
2426         return;
2427       }
2428     }
2429     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2430   } else {
2431     PyErr_Format(PyExc_TypeError, "unexpected type is received");
2432   }
2433 }
2434
2435
2436 /* Convert a pointer value, signal an exception on a type mismatch */
2437 SWIGRUNTIME void *
2438 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2439   void *result;
2440   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2441     PyErr_Clear();
2442     if (flags & SWIG_POINTER_EXCEPTION) {
2443       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2444       SWIG_Python_ArgFail(argnum);
2445     }
2446   }
2447   return result;
2448 }
2449
2450
2451 #ifdef __cplusplus
2452 #if 0
2453 { /* cc-mode */
2454 #endif
2455 }
2456 #endif
2457
2458
2459
2460 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2461
2462 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2463
2464
2465
2466   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2467
2468
2469 /* -------- TYPES TABLE (BEGIN) -------- */
2470
2471 #define SWIGTYPE_p_FILE swig_types[0]
2472 #define SWIGTYPE_p_Hex__BiCylinder swig_types[1]
2473 #define SWIGTYPE_p_Hex__Document swig_types[2]
2474 #define SWIGTYPE_p_Hex__Edge swig_types[3]
2475 #define SWIGTYPE_p_Hex__Elements swig_types[4]
2476 #define SWIGTYPE_p_Hex__EltBase swig_types[5]
2477 #define SWIGTYPE_p_Hex__Group swig_types[6]
2478 #define SWIGTYPE_p_Hex__Hex swig_types[7]
2479 #define SWIGTYPE_p_Hex__Hex__EltBase swig_types[8]
2480 #define SWIGTYPE_p_Hex__Hexa swig_types[9]
2481 #define SWIGTYPE_p_Hex__Law swig_types[10]
2482 #define SWIGTYPE_p_Hex__NewShape swig_types[11]
2483 #define SWIGTYPE_p_Hex__Propagation swig_types[12]
2484 #define SWIGTYPE_p_Hex__Quad swig_types[13]
2485 #define SWIGTYPE_p_Hex__Shape swig_types[14]
2486 #define SWIGTYPE_p_Hex__Vector swig_types[15]
2487 #define SWIGTYPE_p_Hex__Vertex swig_types[16]
2488 #define SWIGTYPE_p_Hex__XmlWriter swig_types[17]
2489 #define SWIGTYPE_p_a_Hex__DIM3__double swig_types[18]
2490 #define SWIGTYPE_p_allocator_type swig_types[19]
2491 #define SWIGTYPE_p_char swig_types[20]
2492 #define SWIGTYPE_p_const_reference swig_types[21]
2493 #define SWIGTYPE_p_difference_type swig_types[22]
2494 #define SWIGTYPE_p_double swig_types[23]
2495 #define SWIGTYPE_p_int swig_types[24]
2496 #define SWIGTYPE_p_p_PyObject swig_types[25]
2497 #define SWIGTYPE_p_reference swig_types[26]
2498 #define SWIGTYPE_p_size_type swig_types[27]
2499 #define SWIGTYPE_p_std__invalid_argument swig_types[28]
2500 #define SWIGTYPE_p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t swig_types[29]
2501 #define SWIGTYPE_p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t swig_types[30]
2502 #define SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t swig_types[31]
2503 #define SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type swig_types[32]
2504 #define SWIGTYPE_p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t swig_types[33]
2505 #define SWIGTYPE_p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t swig_types[34]
2506 #define SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t swig_types[35]
2507 #define SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type swig_types[36]
2508 #define SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t swig_types[37]
2509 #define SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type swig_types[38]
2510 #define SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t swig_types[39]
2511 #define SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type swig_types[40]
2512 #define SWIGTYPE_p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t swig_types[41]
2513 #define SWIGTYPE_p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t swig_types[42]
2514 #define SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t swig_types[43]
2515 #define SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type swig_types[44]
2516 #define SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t swig_types[45]
2517 #define SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type swig_types[46]
2518 #define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t swig_types[47]
2519 #define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t__allocator_type swig_types[48]
2520 #define SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t swig_types[49]
2521 #define SWIGTYPE_p_string swig_types[50]
2522 #define SWIGTYPE_p_swig__PySwigIterator swig_types[51]
2523 #define SWIGTYPE_p_value_type swig_types[52]
2524 #define SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type swig_types[53]
2525 #define SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type swig_types[54]
2526 #define SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type swig_types[55]
2527 #define SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type swig_types[56]
2528 #define SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type swig_types[57]
2529 static swig_type_info *swig_types[59];
2530 static swig_module_info swig_module = {swig_types, 58, 0, 0, 0, 0};
2531 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2532 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2533
2534 /* -------- TYPES TABLE (END) -------- */
2535
2536 #if (PY_VERSION_HEX <= 0x02000000)
2537 # if !defined(SWIG_PYTHON_CLASSIC)
2538 #  error "This python version requires swig to be run with the '-classic' option"
2539 # endif
2540 #endif
2541
2542 /*-----------------------------------------------
2543               @(target):= _hexablock_swig.so
2544   ------------------------------------------------*/
2545 #define SWIG_init    init_hexablock_swig
2546
2547 #define SWIG_name    "_hexablock_swig"
2548
2549 #define SWIGVERSION 0x010331
2550 #define SWIG_VERSION SWIGVERSION
2551
2552
2553 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2554 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2555
2556
2557 #include <stdexcept>
2558
2559
2560 namespace swig {
2561   class PyObject_ptr {
2562   protected:
2563     PyObject *_obj;
2564
2565   public:
2566     PyObject_ptr() :_obj(0)
2567     {
2568     }
2569
2570     PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2571     {
2572       Py_XINCREF(_obj);
2573     }
2574
2575     PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2576     {
2577       if (initial_ref) Py_XINCREF(_obj);
2578     }
2579
2580     PyObject_ptr & operator=(const PyObject_ptr& item)
2581     {
2582       Py_XINCREF(item._obj);
2583       Py_XDECREF(_obj);
2584       _obj = item._obj;
2585       return *this;
2586     }
2587
2588     ~PyObject_ptr()
2589     {
2590       Py_XDECREF(_obj);
2591     }
2592
2593     operator PyObject *() const
2594     {
2595       return _obj;
2596     }
2597
2598     PyObject *operator->() const
2599     {
2600       return _obj;
2601     }
2602   };
2603 }
2604
2605
2606 namespace swig {
2607   struct PyObject_var : PyObject_ptr {
2608     PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2609
2610     PyObject_var & operator = (PyObject* obj)
2611     {
2612       Py_XDECREF(_obj);
2613       _obj = obj;
2614       return *this;
2615     }
2616   };
2617 }
2618
2619
2620 #include "Hex.hxx"
2621 #include "HexDocument.hxx"
2622 #include "HexPropagation.hxx"
2623 #include "HexElements.hxx"
2624 #include "HexQuad.hxx"
2625 #include "HexVertex.hxx"
2626 #include "HexHexa.hxx"
2627 #include "HexEdge.hxx"
2628 #include "HexVector.hxx"
2629 #include "HexBiCylinder.hxx"
2630 #include "HexNewShape.hxx"
2631 #include "HexGroup.hxx"
2632
2633
2634 #include <iostream>
2635
2636
2637 #include <stdexcept>
2638
2639
2640
2641 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
2642 #  define SWIG_STD_NOASSIGN_STL
2643 #  define SWIG_STD_NOINSERT_TEMPLATE_STL
2644 #  define SWIG_STD_NOITERATOR_TRAITS_STL
2645 #endif
2646
2647 #if defined(__GNUC__)
2648 #  if __GNUC__ == 2 && __GNUC_MINOR <= 96
2649 #     define SWIG_STD_NOMODERN_STL
2650 #  endif
2651 #endif
2652
2653
2654
2655
2656 #include <string>
2657 #include <stdexcept>
2658
2659
2660 namespace swig {
2661   struct stop_iteration {
2662   };
2663
2664   struct PySwigIterator {
2665   private:
2666     PyObject_ptr _seq;
2667
2668   protected:
2669     PySwigIterator(PyObject *seq) : _seq(seq)
2670     {
2671     }
2672
2673   public:
2674     virtual ~PySwigIterator() {}
2675
2676     // Access iterator method, required by Python
2677     virtual PyObject *value() const = 0;
2678
2679     // Forward iterator method, required by Python
2680     virtual PySwigIterator *incr(size_t n = 1) = 0;
2681
2682     // Backward iterator method, very common in C++, but not required in Python
2683     virtual PySwigIterator *decr(size_t n = 1)
2684     {
2685       throw stop_iteration();
2686     }
2687
2688     // Random access iterator methods, but not required in Python
2689     virtual ptrdiff_t distance(const PySwigIterator &x) const
2690     {
2691       throw std::invalid_argument("operation not supported");
2692     }
2693
2694     virtual bool equal (const PySwigIterator &x) const
2695     {
2696       throw std::invalid_argument("operation not supported");
2697     }
2698
2699     // C++ common/needed methods
2700     virtual PySwigIterator *copy() const = 0;
2701
2702     PyObject *next()
2703     {
2704       PyObject *obj = value();
2705       incr();
2706       return obj;
2707     }
2708
2709     PyObject *previous()
2710     {
2711       decr();
2712       return value();
2713     }
2714
2715     PySwigIterator *advance(ptrdiff_t n)
2716     {
2717       return  (n > 0) ?  incr(n) : decr(-n);
2718     }
2719
2720     bool operator == (const PySwigIterator& x)  const
2721     {
2722       return equal(x);
2723     }
2724
2725     bool operator != (const PySwigIterator& x) const
2726     {
2727       return ! operator==(x);
2728     }
2729
2730     PySwigIterator& operator += (ptrdiff_t n)
2731     {
2732       return *advance(n);
2733     }
2734
2735     PySwigIterator& operator -= (ptrdiff_t n)
2736     {
2737       return *advance(-n);
2738     }
2739
2740     PySwigIterator* operator + (ptrdiff_t n) const
2741     {
2742       return copy()->advance(n);
2743     }
2744
2745     PySwigIterator* operator - (ptrdiff_t n) const
2746     {
2747       return copy()->advance(-n);
2748     }
2749
2750     ptrdiff_t operator - (const PySwigIterator& x) const
2751     {
2752       return x.distance(*this);
2753     }
2754
2755     static swig_type_info* descriptor() {
2756       static int init = 0;
2757       static swig_type_info* desc = 0;
2758       if (!init) {
2759         desc = SWIG_TypeQuery("swig::PySwigIterator *");
2760         init = 1;
2761       }
2762       return desc;
2763     }
2764   };
2765 }
2766
2767
2768 SWIGINTERN int
2769 SWIG_AsVal_double (PyObject *obj, double *val)
2770 {
2771   int res = SWIG_TypeError;
2772   if (PyFloat_Check(obj)) {
2773     if (val) *val = PyFloat_AsDouble(obj);
2774     return SWIG_OK;
2775   } else if (PyInt_Check(obj)) {
2776     if (val) *val = PyInt_AsLong(obj);
2777     return SWIG_OK;
2778   } else if (PyLong_Check(obj)) {
2779     double v = PyLong_AsDouble(obj);
2780     if (!PyErr_Occurred()) {
2781       if (val) *val = v;
2782       return SWIG_OK;
2783     } else {
2784       PyErr_Clear();
2785     }
2786   }
2787 #ifdef SWIG_PYTHON_CAST_MODE
2788   {
2789     int dispatch = 0;
2790     double d = PyFloat_AsDouble(obj);
2791     if (!PyErr_Occurred()) {
2792       if (val) *val = d;
2793       return SWIG_AddCast(SWIG_OK);
2794     } else {
2795       PyErr_Clear();
2796     }
2797     if (!dispatch) {
2798       long v = PyLong_AsLong(obj);
2799       if (!PyErr_Occurred()) {
2800         if (val) *val = v;
2801         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2802       } else {
2803         PyErr_Clear();
2804       }
2805     }
2806   }
2807 #endif
2808   return res;
2809 }
2810
2811
2812 #include <float.h>
2813
2814
2815 #include <math.h>
2816
2817
2818 SWIGINTERNINLINE int
2819 SWIG_CanCastAsInteger(double *d, double min, double max) {
2820   double x = *d;
2821   if ((min <= x && x <= max)) {
2822    double fx = floor(x);
2823    double cx = ceil(x);
2824    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2825    if ((errno == EDOM) || (errno == ERANGE)) {
2826      errno = 0;
2827    } else {
2828      double summ, reps, diff;
2829      if (rd < x) {
2830        diff = x - rd;
2831      } else if (rd > x) {
2832        diff = rd - x;
2833      } else {
2834        return 1;
2835      }
2836      summ = rd + x;
2837      reps = diff/summ;
2838      if (reps < 8*DBL_EPSILON) {
2839        *d = rd;
2840        return 1;
2841      }
2842    }
2843   }
2844   return 0;
2845 }
2846
2847
2848 SWIGINTERN int
2849 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
2850 {
2851   if (PyInt_Check(obj)) {
2852     long v = PyInt_AsLong(obj);
2853     if (v >= 0) {
2854       if (val) *val = v;
2855       return SWIG_OK;
2856     } else {
2857       return SWIG_OverflowError;
2858     }
2859   } else if (PyLong_Check(obj)) {
2860     unsigned long v = PyLong_AsUnsignedLong(obj);
2861     if (!PyErr_Occurred()) {
2862       if (val) *val = v;
2863       return SWIG_OK;
2864     } else {
2865       PyErr_Clear();
2866     }
2867   }
2868 #ifdef SWIG_PYTHON_CAST_MODE
2869   {
2870     int dispatch = 0;
2871     unsigned long v = PyLong_AsUnsignedLong(obj);
2872     if (!PyErr_Occurred()) {
2873       if (val) *val = v;
2874       return SWIG_AddCast(SWIG_OK);
2875     } else {
2876       PyErr_Clear();
2877     }
2878     if (!dispatch) {
2879       double d;
2880       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2881       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2882         if (val) *val = (unsigned long)(d);
2883         return res;
2884       }
2885     }
2886   }
2887 #endif
2888   return SWIG_TypeError;
2889 }
2890
2891
2892 SWIGINTERNINLINE int
2893 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2894 {
2895   unsigned long v;
2896   int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2897   if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2898   return res;
2899 }
2900
2901
2902   #define SWIG_From_long   PyInt_FromLong
2903
2904
2905 SWIGINTERNINLINE PyObject *
2906 SWIG_From_ptrdiff_t  (ptrdiff_t value)
2907 {
2908   return SWIG_From_long  (static_cast< long >(value));
2909 }
2910
2911
2912 SWIGINTERNINLINE PyObject*
2913   SWIG_From_bool  (bool value)
2914 {
2915   return PyBool_FromLong(value ? 1 : 0);
2916 }
2917
2918
2919 SWIGINTERN int
2920 SWIG_AsVal_long (PyObject *obj, long* val)
2921 {
2922   if (PyInt_Check(obj)) {
2923     if (val) *val = PyInt_AsLong(obj);
2924     return SWIG_OK;
2925   } else if (PyLong_Check(obj)) {
2926     long v = PyLong_AsLong(obj);
2927     if (!PyErr_Occurred()) {
2928       if (val) *val = v;
2929       return SWIG_OK;
2930     } else {
2931       PyErr_Clear();
2932     }
2933   }
2934 #ifdef SWIG_PYTHON_CAST_MODE
2935   {
2936     int dispatch = 0;
2937     long v = PyInt_AsLong(obj);
2938     if (!PyErr_Occurred()) {
2939       if (val) *val = v;
2940       return SWIG_AddCast(SWIG_OK);
2941     } else {
2942       PyErr_Clear();
2943     }
2944     if (!dispatch) {
2945       double d;
2946       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2947       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2948         if (val) *val = (long)(d);
2949         return res;
2950       }
2951     }
2952   }
2953 #endif
2954   return SWIG_TypeError;
2955 }
2956
2957
2958 SWIGINTERNINLINE int
2959 SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
2960 {
2961   long v;
2962   int res = SWIG_AsVal_long (obj, val ? &v : 0);
2963   if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
2964   return res;
2965 }
2966
2967
2968 #include <stdexcept>
2969
2970
2971 #include <algorithm>
2972
2973
2974 #include <vector>
2975
2976
2977 namespace swig {
2978   template <class Type>
2979   struct noconst_traits {
2980     typedef Type noconst_type;
2981   };
2982
2983   template <class Type>
2984   struct noconst_traits<const Type> {
2985     typedef Type noconst_type;
2986   };
2987
2988   /*
2989     type categories
2990   */
2991   struct pointer_category { };
2992   struct value_category { };
2993
2994   /*
2995     General traits that provides type_name and type_info
2996   */
2997   template <class Type> struct traits { };
2998
2999   template <class Type>
3000   inline const char* type_name() {
3001     return traits<typename noconst_traits<Type >::noconst_type >::type_name();
3002   }
3003
3004   template <class Type>
3005   struct traits_info {
3006     static swig_type_info *type_query(std::string name) {
3007       name += " *";
3008       return SWIG_TypeQuery(name.c_str());
3009     }
3010     static swig_type_info *type_info() {
3011       static swig_type_info *info = type_query(type_name<Type>());
3012       return info;
3013     }
3014   };
3015
3016   template <class Type>
3017   inline swig_type_info *type_info() {
3018     return traits_info<Type>::type_info();
3019   }
3020
3021   /*
3022     Partial specialization for pointers
3023   */
3024   template <class Type> struct traits <Type *> {
3025     typedef pointer_category category;
3026     static std::string make_ptr_name(const char* name) {
3027       std::string ptrname = name;
3028       ptrname += " *";
3029       return ptrname;
3030     }
3031     static const char* type_name() {
3032       static std::string name = make_ptr_name(swig::type_name<Type>());
3033       return name.c_str();
3034     }
3035   };
3036
3037   template <class Type, class Category>
3038   struct traits_as { };
3039
3040   template <class Type, class Category>
3041   struct traits_check { };
3042
3043 }
3044
3045
3046 namespace swig {
3047   /*
3048     Traits that provides the from method
3049   */
3050   template <class Type> struct traits_from_ptr {
3051     static PyObject *from(Type *val, int owner = 0) {
3052       return SWIG_NewPointerObj(val, type_info<Type>(), owner);
3053     }
3054   };
3055
3056   template <class Type> struct traits_from {
3057     static PyObject *from(const Type& val) {
3058       return traits_from_ptr<Type>::from(new Type(val), 1);
3059     }
3060   };
3061
3062   template <class Type> struct traits_from<Type *> {
3063     static PyObject *from(Type* val) {
3064       return traits_from_ptr<Type>::from(val, 0);
3065     }
3066   };
3067
3068   template <class Type> struct traits_from<const Type *> {
3069     static PyObject *from(const Type* val) {
3070       return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
3071     }
3072   };
3073
3074
3075   template <class Type>
3076   inline PyObject *from(const Type& val) {
3077     return traits_from<Type>::from(val);
3078   }
3079
3080   template <class Type>
3081   inline PyObject *from_ptr(Type* val, int owner) {
3082     return traits_from_ptr<Type>::from(val, owner);
3083   }
3084
3085   /*
3086     Traits that provides the asval/as/check method
3087   */
3088   template <class Type>
3089   struct traits_asptr {
3090     static int asptr(PyObject *obj, Type **val) {
3091       Type *p;
3092       int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
3093       if (SWIG_IsOK(res)) {
3094         if (val) *val = p;
3095       }
3096       return res;
3097     }
3098   };
3099
3100   template <class Type>
3101   inline int asptr(PyObject *obj, Type **vptr) {
3102     return traits_asptr<Type>::asptr(obj, vptr);
3103   }
3104
3105   template <class Type>
3106   struct traits_asval {
3107     static int asval(PyObject *obj, Type *val) {
3108       if (val) {
3109         Type *p = 0;
3110         int res = traits_asptr<Type>::asptr(obj, &p);
3111         if (!SWIG_IsOK(res)) return res;
3112         if (p) {
3113           typedef typename noconst_traits<Type>::noconst_type noconst_type;
3114           *(const_cast<noconst_type*>(val)) = *p;
3115           if (SWIG_IsNewObj(res)){
3116             delete p;
3117             res = SWIG_DelNewMask(res);
3118           }
3119           return res;
3120         } else {
3121           return SWIG_ERROR;
3122         }
3123       } else {
3124         return traits_asptr<Type>::asptr(obj, (Type **)(0));
3125       }
3126     }
3127   };
3128
3129   template <class Type> struct traits_asval<Type*> {
3130     static int asval(PyObject *obj, Type **val) {
3131       if (val) {
3132         typedef typename noconst_traits<Type>::noconst_type noconst_type;
3133         noconst_type *p = 0;
3134         int res = traits_asptr<noconst_type>::asptr(obj,  &p);
3135         if (SWIG_IsOK(res)) {
3136           *(const_cast<noconst_type**>(val)) = p;
3137         }
3138         return res;
3139       } else {
3140         return traits_asptr<Type>::asptr(obj, (Type **)(0));
3141       }
3142     }
3143   };
3144
3145   template <class Type>
3146   inline int asval(PyObject *obj, Type *val) {
3147     return traits_asval<Type>::asval(obj, val);
3148   }
3149
3150   template <class Type>
3151   struct traits_as<Type, value_category> {
3152     static Type as(PyObject *obj, bool throw_error) {
3153       Type v;
3154       int res = asval(obj, &v);
3155       if (!obj || !SWIG_IsOK(res)) {
3156         if (!PyErr_Occurred()) {
3157           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3158         }
3159         if (throw_error) throw std::invalid_argument("bad type");
3160       }
3161       return v;
3162     }
3163   };
3164
3165   template <class Type>
3166   struct traits_as<Type, pointer_category> {
3167     static Type as(PyObject *obj, bool throw_error) {
3168       Type *v = 0;
3169       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3170       if (SWIG_IsOK(res) && v) {
3171         if (SWIG_IsNewObj(res)) {
3172           Type r(*v);
3173           delete v;
3174           return r;
3175         } else {
3176           return *v;
3177         }
3178       } else {
3179         // Uninitialized return value, no Type() constructor required.
3180         static Type *v_def = (Type*) malloc(sizeof(Type));
3181         if (!PyErr_Occurred()) {
3182           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3183         }
3184         if (throw_error) throw std::invalid_argument("bad type");
3185         memset(v_def,0,sizeof(Type));
3186         return *v_def;
3187       }
3188     }
3189   };
3190
3191   template <class Type>
3192   struct traits_as<Type*, pointer_category> {
3193     static Type* as(PyObject *obj, bool throw_error) {
3194       Type *v = 0;
3195       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3196       if (SWIG_IsOK(res)) {
3197         return v;
3198       } else {
3199         if (!PyErr_Occurred()) {
3200           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3201         }
3202         if (throw_error) throw std::invalid_argument("bad type");
3203         return 0;
3204       }
3205     }
3206   };
3207
3208   template <class Type>
3209   inline Type as(PyObject *obj, bool te = false) {
3210     return traits_as<Type, typename traits<Type>::category>::as(obj, te);
3211   }
3212
3213   template <class Type>
3214   struct traits_check<Type, value_category> {
3215     static bool check(PyObject *obj) {
3216       int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
3217       return SWIG_IsOK(res) ? true : false;
3218     }
3219   };
3220
3221   template <class Type>
3222   struct traits_check<Type, pointer_category> {
3223     static bool check(PyObject *obj) {
3224       int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
3225       return SWIG_IsOK(res) ? true : false;
3226     }
3227   };
3228
3229   template <class Type>
3230   inline bool check(PyObject *obj) {
3231     return traits_check<Type, typename traits<Type>::category>::check(obj);
3232   }
3233 }
3234
3235
3236 #include <functional>
3237
3238 namespace std {
3239   template <>
3240   struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
3241   {
3242     bool
3243     operator()(PyObject * v, PyObject *w) const
3244     {
3245       bool res;
3246       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3247       res = PyObject_Compare(v, w) < 0;
3248       SWIG_PYTHON_THREAD_END_BLOCK;
3249       return res;
3250     }
3251   };
3252
3253   template <>
3254   struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
3255   {
3256     bool
3257     operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
3258     {
3259       return std::less<PyObject *>()(v, w);
3260     }
3261   };
3262
3263   template <>
3264   struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
3265   {
3266     bool
3267     operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
3268     {
3269       return std::less<PyObject *>()(v, w);
3270     }
3271   };
3272
3273 }
3274
3275 namespace swig {
3276   template <> struct traits<PyObject *> {
3277     typedef value_category category;
3278     static const char* type_name() { return "PyObject *"; }
3279   };
3280
3281   template <>  struct traits_asval<PyObject * > {
3282     typedef PyObject * value_type;
3283     static int asval(PyObject *obj, value_type *val) {
3284       if (val) *val = obj;
3285       return SWIG_OK;
3286     }
3287   };
3288
3289   template <>
3290   struct traits_check<PyObject *, value_category> {
3291     static bool check(PyObject *) {
3292       return true;
3293     }
3294   };
3295
3296   template <>  struct traits_from<PyObject *> {
3297     typedef PyObject * value_type;
3298     static PyObject *from(const value_type& val) {
3299       Py_XINCREF(val);
3300       return val;
3301     }
3302   };
3303
3304 }
3305
3306 namespace swig {
3307   inline size_t
3308   check_index(ptrdiff_t i, size_t size, bool insert = false) {
3309     if ( i < 0 ) {
3310       if ((size_t) (-i) <= size)
3311         return (size_t) (i + size);
3312     } else if ( (size_t) i < size ) {
3313       return (size_t) i;
3314     } else if (insert && ((size_t) i == size)) {
3315       return size;
3316     }
3317
3318     throw std::out_of_range("index out of range");
3319   }
3320
3321   inline size_t
3322   slice_index(ptrdiff_t i, size_t size) {
3323     if ( i < 0 ) {
3324       if ((size_t) (-i) <= size) {
3325         return (size_t) (i + size);
3326       } else {
3327         throw std::out_of_range("index out of range");
3328       }
3329     } else {
3330       return ( (size_t) i < size ) ? ((size_t) i) : size;
3331     }
3332   }
3333
3334   template <class Sequence, class Difference>
3335   inline typename Sequence::iterator
3336   getpos(Sequence* self, Difference i)  {
3337     typename Sequence::iterator pos = self->begin();
3338     std::advance(pos, check_index(i,self->size()));
3339     return pos;
3340   }
3341
3342   template <class Sequence, class Difference>
3343   inline typename Sequence::const_iterator
3344   cgetpos(const Sequence* self, Difference i)  {
3345     typename Sequence::const_iterator pos = self->begin();
3346     std::advance(pos, check_index(i,self->size()));
3347     return pos;
3348   }
3349
3350   template <class Sequence, class Difference>
3351   inline Sequence*
3352   getslice(const Sequence* self, Difference i, Difference j) {
3353     typename Sequence::size_type size = self->size();
3354     typename Sequence::size_type ii = swig::check_index(i, size);
3355     typename Sequence::size_type jj = swig::slice_index(j, size);
3356
3357     if (jj > ii) {
3358       typename Sequence::const_iterator vb = self->begin();
3359       typename Sequence::const_iterator ve = self->begin();
3360       std::advance(vb,ii);
3361       std::advance(ve,jj);
3362       return new Sequence(vb, ve);
3363     } else {
3364       return new Sequence();
3365     }
3366   }
3367
3368   template <class Sequence, class Difference, class InputSeq>
3369   inline void
3370   setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
3371     typename Sequence::size_type size = self->size();
3372     typename Sequence::size_type ii = swig::check_index(i, size, true);
3373     typename Sequence::size_type jj = swig::slice_index(j, size);
3374     if (jj < ii) jj = ii;
3375     size_t ssize = jj - ii;
3376     if (ssize <= v.size()) {
3377       typename Sequence::iterator sb = self->begin();
3378       typename InputSeq::const_iterator vmid = v.begin();
3379       std::advance(sb,ii);
3380       std::advance(vmid, jj - ii);
3381       self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
3382     } else {
3383       typename Sequence::iterator sb = self->begin();
3384       typename Sequence::iterator se = self->begin();
3385       std::advance(sb,ii);
3386       std::advance(se,jj);
3387       self->erase(sb,se);
3388       self->insert(sb, v.begin(), v.end());
3389     }
3390   }
3391
3392   template <class Sequence, class Difference>
3393   inline void
3394   delslice(Sequence* self, Difference i, Difference j) {
3395     typename Sequence::size_type size = self->size();
3396     typename Sequence::size_type ii = swig::check_index(i, size, true);
3397     typename Sequence::size_type jj = swig::slice_index(j, size);
3398     if (jj > ii) {
3399       typename Sequence::iterator sb = self->begin();
3400       typename Sequence::iterator se = self->begin();
3401       std::advance(sb,ii);
3402       std::advance(se,jj);
3403       self->erase(sb,se);
3404     }
3405   }
3406 }
3407
3408
3409 #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
3410 #include <iterator>
3411 #else
3412 namespace std  {
3413   template <class Iterator>
3414   struct iterator_traits {
3415     typedef ptrdiff_t difference_type;
3416     typedef typename Iterator::value_type value_type;
3417   };
3418
3419 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
3420   template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
3421   struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
3422     typedef Distance difference_type;
3423     typedef T value_type;
3424   };
3425 #endif
3426
3427   template <class T>
3428   struct iterator_traits<T*> {
3429     typedef T value_type;
3430     typedef ptrdiff_t difference_type;
3431   };
3432
3433   template<typename _InputIterator>
3434   inline typename iterator_traits<_InputIterator>::difference_type
3435   distance(_InputIterator __first, _InputIterator __last)
3436   {
3437     typename iterator_traits<_InputIterator>::difference_type __n = 0;
3438     while (__first != __last) {
3439       ++__first; ++__n;
3440     }
3441     return __n;
3442   }
3443
3444 }
3445 #endif
3446
3447
3448 namespace swig {
3449   template<typename OutIterator>
3450   class PySwigIterator_T :  public PySwigIterator
3451   {
3452   public:
3453     typedef OutIterator out_iterator;
3454     typedef typename std::iterator_traits<out_iterator>::value_type value_type;
3455     typedef PySwigIterator_T<out_iterator> self_type;
3456
3457     PySwigIterator_T(out_iterator curr, PyObject *seq)
3458       : PySwigIterator(seq), current(curr)
3459     {
3460     }
3461
3462     const out_iterator& get_current() const
3463     {
3464       return current;
3465     }
3466
3467
3468     bool equal (const PySwigIterator &iter) const
3469     {
3470       const self_type *iters = dynamic_cast<const self_type *>(&iter);
3471       if (iters) {
3472         return (current == iters->get_current());
3473       } else {
3474         throw std::invalid_argument("bad iterator type");
3475       }
3476     }
3477
3478     ptrdiff_t distance(const PySwigIterator &iter) const
3479     {
3480       const self_type *iters = dynamic_cast<const self_type *>(&iter);
3481       if (iters) {
3482         return std::distance(current, iters->get_current());
3483       } else {
3484         throw std::invalid_argument("bad iterator type");
3485       }
3486     }
3487
3488   protected:
3489     out_iterator current;
3490   };
3491
3492   template <class ValueType>
3493   struct from_oper
3494   {
3495     typedef const ValueType& argument_type;
3496     typedef PyObject *result_type;
3497     result_type operator()(argument_type v) const
3498     {
3499       return swig::from(v);
3500     }
3501   };
3502
3503   template<typename OutIterator,
3504            typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3505            typename FromOper = from_oper<ValueType> >
3506   class PySwigIteratorOpen_T :  public PySwigIterator_T<OutIterator>
3507   {
3508   public:
3509     FromOper from;
3510     typedef OutIterator out_iterator;
3511     typedef ValueType value_type;
3512     typedef PySwigIterator_T<out_iterator>  base;
3513     typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
3514
3515     PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
3516       : PySwigIterator_T<OutIterator>(curr, seq)
3517     {
3518     }
3519
3520     PyObject *value() const {
3521       return from(static_cast<const value_type&>(*(base::current)));
3522     }
3523
3524     PySwigIterator *copy() const
3525     {
3526       return new self_type(*this);
3527     }
3528
3529     PySwigIterator *incr(size_t n = 1)
3530     {
3531       while (n--) {
3532         ++base::current;
3533       }
3534       return this;
3535     }
3536
3537     PySwigIterator *decr(size_t n = 1)
3538     {
3539       while (n--) {
3540         --base::current;
3541       }
3542       return this;
3543     }
3544   };
3545
3546   template<typename OutIterator,
3547            typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3548            typename FromOper = from_oper<ValueType> >
3549   class PySwigIteratorClosed_T :  public PySwigIterator_T<OutIterator>
3550   {
3551   public:
3552     FromOper from;
3553     typedef OutIterator out_iterator;
3554     typedef ValueType value_type;
3555     typedef PySwigIterator_T<out_iterator>  base;
3556     typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
3557
3558     PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
3559       : PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
3560     {
3561     }
3562
3563     PyObject *value() const {
3564       if (base::current == end) {
3565         throw stop_iteration();
3566       } else {
3567         return from(static_cast<const value_type&>(*(base::current)));
3568       }
3569     }
3570
3571     PySwigIterator *copy() const
3572     {
3573       return new self_type(*this);
3574     }
3575
3576     PySwigIterator *incr(size_t n = 1)
3577     {
3578       while (n--) {
3579         if (base::current == end) {
3580           throw stop_iteration();
3581         } else {
3582           ++base::current;
3583         }
3584       }
3585       return this;
3586     }
3587
3588     PySwigIterator *decr(size_t n = 1)
3589     {
3590       while (n--) {
3591         if (base::current == begin) {
3592           throw stop_iteration();
3593         } else {
3594           --base::current;
3595         }
3596       }
3597       return this;
3598     }
3599
3600   private:
3601     out_iterator begin;
3602     out_iterator end;
3603   };
3604
3605   template<typename OutIter>
3606   inline PySwigIterator*
3607   make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
3608   {
3609     return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
3610   }
3611
3612   template<typename OutIter>
3613   inline PySwigIterator*
3614   make_output_iterator(const OutIter& current, PyObject *seq = 0)
3615   {
3616     return new PySwigIteratorOpen_T<OutIter>(current, seq);
3617   }
3618 }
3619
3620
3621 namespace swig
3622 {
3623   template <class T>
3624   struct PySequence_Ref
3625   {
3626     PySequence_Ref(PyObject* seq, int index)
3627       : _seq(seq), _index(index)
3628     {
3629     }
3630
3631     operator T () const
3632     {
3633       swig::PyObject_var item = PySequence_GetItem(_seq, _index);
3634       try {
3635         return swig::as<T>(item, true);
3636       } catch (std::exception& e) {
3637         char msg[1024];
3638         sprintf(msg, "in sequence element %d ", _index);
3639         if (!PyErr_Occurred()) {
3640           SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
3641         }
3642         SWIG_Python_AddErrorMsg(msg);
3643         SWIG_Python_AddErrorMsg(e.what());
3644         throw;
3645       }
3646     }
3647
3648     PySequence_Ref& operator=(const T& v)
3649     {
3650       PySequence_SetItem(_seq, _index, swig::from<T>(v));
3651       return *this;
3652     }
3653
3654   private:
3655     PyObject* _seq;
3656     int _index;
3657   };
3658
3659   template <class T>
3660   struct PySequence_ArrowProxy
3661   {
3662     PySequence_ArrowProxy(const T& x): m_value(x) {}
3663     const T* operator->() const { return &m_value; }
3664     operator const T*() const { return &m_value; }
3665     T m_value;
3666   };
3667
3668   template <class T, class Reference >
3669   struct PySequence_InputIterator
3670   {
3671     typedef PySequence_InputIterator<T, Reference > self;
3672
3673     typedef std::random_access_iterator_tag iterator_category;
3674     typedef Reference reference;
3675     typedef T value_type;
3676     typedef T* pointer;
3677     typedef int difference_type;
3678
3679     PySequence_InputIterator()
3680     {
3681     }
3682
3683     PySequence_InputIterator(PyObject* seq, int index)
3684       : _seq(seq), _index(index)
3685     {
3686     }
3687
3688     reference operator*() const
3689     {
3690       return reference(_seq, _index);
3691     }
3692
3693     PySequence_ArrowProxy<T>
3694     operator->() const {
3695       return PySequence_ArrowProxy<T>(operator*());
3696     }
3697
3698     bool operator==(const self& ri) const
3699     {
3700       return (_index == ri._index) && (_seq == ri._seq);
3701     }
3702
3703     bool operator!=(const self& ri) const
3704     {
3705       return !(operator==(ri));
3706     }
3707
3708     self& operator ++ ()
3709     {
3710       ++_index;
3711       return *this;
3712     }
3713
3714     self& operator -- ()
3715     {
3716       --_index;
3717       return *this;
3718     }
3719
3720     self& operator += (difference_type n)
3721     {
3722       _index += n;
3723       return *this;
3724     }
3725
3726     self operator +(difference_type n) const
3727     {
3728       return self(_seq, _index + n);
3729     }
3730
3731     self& operator -= (difference_type n)
3732     {
3733       _index -= n;
3734       return *this;
3735     }
3736
3737     self operator -(difference_type n) const
3738     {
3739       return self(_seq, _index - n);
3740     }
3741
3742     difference_type operator - (const self& ri) const
3743     {
3744       return _index - ri._index;
3745     }
3746
3747     bool operator < (const self& ri) const
3748     {
3749       return _index < ri._index;
3750     }
3751
3752     reference
3753     operator[](difference_type n) const
3754     {
3755       return reference(_seq, _index + n);
3756     }
3757
3758   private:
3759     PyObject* _seq;
3760     difference_type _index;
3761   };
3762
3763   template <class T>
3764   struct PySequence_Cont
3765   {
3766     typedef PySequence_Ref<T> reference;
3767     typedef const PySequence_Ref<T> const_reference;
3768     typedef T value_type;
3769     typedef T* pointer;
3770     typedef int difference_type;
3771     typedef int size_type;
3772     typedef const pointer const_pointer;
3773     typedef PySequence_InputIterator<T, reference> iterator;
3774     typedef PySequence_InputIterator<T, const_reference> const_iterator;
3775
3776     PySequence_Cont(PyObject* seq) : _seq(0)
3777     {
3778       if (!PySequence_Check(seq)) {
3779         throw std::invalid_argument("a sequence is expected");
3780       }
3781       _seq = seq;
3782       Py_INCREF(_seq);
3783     }
3784
3785     ~PySequence_Cont()
3786     {
3787       if (_seq) Py_DECREF(_seq);
3788     }
3789
3790     size_type size() const
3791     {
3792       return PySequence_Size(_seq);
3793     }
3794
3795     bool empty() const
3796     {
3797       return size() == 0;
3798     }
3799
3800     iterator begin()
3801     {
3802       return iterator(_seq, 0);
3803     }
3804
3805     const_iterator begin() const
3806     {
3807       return const_iterator(_seq, 0);
3808     }
3809
3810     iterator end()
3811     {
3812       return iterator(_seq, size());
3813     }
3814
3815     const_iterator end() const
3816     {
3817       return const_iterator(_seq, size());
3818     }
3819
3820     reference operator[](difference_type n)
3821     {
3822       return reference(_seq, n);
3823     }
3824
3825     const_reference operator[](difference_type n)  const
3826     {
3827       return const_reference(_seq, n);
3828     }
3829
3830     bool check(bool set_err = true) const
3831     {
3832       int s = size();
3833       for (int i = 0; i < s; ++i) {
3834         swig::PyObject_var item = PySequence_GetItem(_seq, i);
3835         if (!swig::check<value_type>(item)) {
3836           if (set_err) {
3837             char msg[1024];
3838             sprintf(msg, "in sequence element %d", i);
3839             SWIG_Error(SWIG_RuntimeError, msg);
3840           }
3841           return false;
3842         }
3843       }
3844       return true;
3845     }
3846
3847   private:
3848     PyObject* _seq;
3849   };
3850
3851 }
3852
3853
3854   namespace swig {
3855     template <>  struct traits<Hex::Hexa > {
3856       typedef pointer_category category;
3857       static const char* type_name() { return"Hex::Hexa"; }
3858     };
3859   }
3860
3861
3862 namespace swig {
3863   template <class PySeq, class Seq>
3864   inline void
3865   assign(const PySeq& pyseq, Seq* seq) {
3866 #ifdef SWIG_STD_NOASSIGN_STL
3867     typedef typename PySeq::value_type value_type;
3868     typename PySeq::const_iterator it = pyseq.begin();
3869     for (;it != pyseq.end(); ++it) {
3870       seq->insert(seq->end(),(value_type)(*it));
3871     }
3872 #else
3873     seq->assign(pyseq.begin(), pyseq.end());
3874 #endif
3875   }
3876
3877   template <class Seq, class T = typename Seq::value_type >
3878   struct traits_asptr_stdseq {
3879     typedef Seq sequence;
3880     typedef T value_type;
3881
3882     static int asptr(PyObject *obj, sequence **seq) {
3883       if (PySequence_Check(obj)) {
3884         try {
3885           PySequence_Cont<value_type> pyseq(obj);
3886           if (seq) {
3887             sequence *pseq = new sequence();
3888             assign(pyseq, pseq);
3889             *seq = pseq;
3890             return SWIG_NEWOBJ;
3891           } else {
3892             return pyseq.check() ? SWIG_OK : SWIG_ERROR;
3893           }
3894         } catch (std::exception& e) {
3895           if (seq) {
3896             if (!PyErr_Occurred()) {
3897               PyErr_SetString(PyExc_TypeError, e.what());
3898             }
3899           }
3900           return SWIG_ERROR;
3901         }
3902       } else {
3903         sequence *p;
3904         if (SWIG_ConvertPtr(obj,(void**)&p,
3905                             swig::type_info<sequence>(),0) == SWIG_OK) {
3906           if (seq) *seq = p;
3907           return SWIG_OLDOBJ;
3908         }
3909       }
3910       return SWIG_ERROR;
3911     }
3912   };
3913
3914   template <class Seq, class T = typename Seq::value_type >
3915   struct traits_from_stdseq {
3916     typedef Seq sequence;
3917     typedef T value_type;
3918     typedef typename Seq::size_type size_type;
3919     typedef typename sequence::const_iterator const_iterator;
3920
3921     static PyObject *from(const sequence& seq) {
3922
3923
3924
3925
3926
3927
3928       size_type size = seq.size();
3929       if (size <= (size_type)INT_MAX) {
3930         PyObject *obj = PyTuple_New((int)size);
3931         int i = 0;
3932         for (const_iterator it = seq.begin();
3933              it != seq.end(); ++it, ++i) {
3934           PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
3935         }
3936         return obj;
3937       } else {
3938         PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
3939         return NULL;
3940       }
3941     }
3942   };
3943 }
3944
3945
3946   namespace swig {
3947     template <class T>
3948     struct traits_asptr<std::vector<T> >  {
3949       static int asptr(PyObject *obj, std::vector<T> **vec) {
3950         return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
3951       }
3952     };
3953
3954     template <class T>
3955     struct traits_from<std::vector<T> > {
3956       static PyObject *from(const std::vector<T>& vec) {
3957         return traits_from_stdseq<std::vector<T> >::from(vec);
3958       }
3959     };
3960   }
3961
3962
3963       namespace swig {
3964         template <>  struct traits<std::vector<Hex::Hexa*, std::allocator<Hex::Hexa * > > > {
3965           typedef value_category category;
3966           static const char* type_name() {
3967             return "std::vector<" "Hex::Hexa" " *," "std::allocator<Hex::Hexa * >" " >";
3968           }
3969         };
3970       }
3971
3972 SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(std::vector<Hex::Hexa * > *self,PyObject **PYTHON_SELF){
3973       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
3974     }
3975 SWIGINTERN bool std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__(std::vector<Hex::Hexa * > const *self){
3976       return !(self->empty());
3977     }
3978 SWIGINTERN std::vector<Hex::Hexa * >::size_type std_vector_Sl_Hex_Hexa_Sm__Sg____len__(std::vector<Hex::Hexa * > const *self){
3979       return self->size();
3980     }
3981
3982 SWIGINTERNINLINE PyObject*
3983 SWIG_From_unsigned_SS_long  (unsigned long value)
3984 {
3985   return (value > LONG_MAX) ?
3986     PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3987 }
3988
3989
3990 SWIGINTERNINLINE PyObject *
3991 SWIG_From_size_t  (size_t value)
3992 {
3993   return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
3994 }
3995
3996 SWIGINTERN std::vector<Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg__pop(std::vector<Hex::Hexa * > *self){
3997       if (self->size() == 0)
3998         throw std::out_of_range("pop from empty container");
3999       std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >::value_type x = self->back();
4000       self->pop_back();
4001       return x;
4002     }
4003 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){
4004       return swig::getslice(self, i, j);
4005     }
4006 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){
4007       swig::setslice(self, i, j, v);
4008     }
4009 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){
4010       swig::delslice(self, i, j);
4011     }
4012 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delitem__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i){
4013       self->erase(swig::getpos(self,i));
4014     }
4015 SWIGINTERN std::vector<Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg____getitem__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i){
4016       return *(swig::cgetpos(self, i));
4017     }
4018 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem__(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::difference_type i,std::vector<Hex::Hexa * >::value_type x){
4019       *(swig::getpos(self,i)) = x;
4020     }
4021 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg__append(std::vector<Hex::Hexa * > *self,std::vector<Hex::Hexa * >::value_type x){
4022       self->push_back(x);
4023     }
4024
4025   namespace swig {
4026     template <>  struct traits<Hex::Quad > {
4027       typedef pointer_category category;
4028       static const char* type_name() { return"Hex::Quad"; }
4029     };
4030   }
4031
4032
4033       namespace swig {
4034         template <>  struct traits<std::vector<Hex::Quad*, std::allocator<Hex::Quad * > > > {
4035           typedef value_category category;
4036           static const char* type_name() {
4037             return "std::vector<" "Hex::Quad" " *," "std::allocator<Hex::Quad * >" " >";
4038           }
4039         };
4040       }
4041
4042 SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Quad_Sm__Sg__iterator(std::vector<Hex::Quad * > *self,PyObject **PYTHON_SELF){
4043       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4044     }
4045 SWIGINTERN bool std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__(std::vector<Hex::Quad * > const *self){
4046       return !(self->empty());
4047     }
4048 SWIGINTERN std::vector<Hex::Quad * >::size_type std_vector_Sl_Hex_Quad_Sm__Sg____len__(std::vector<Hex::Quad * > const *self){
4049       return self->size();
4050     }
4051 SWIGINTERN std::vector<Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg__pop(std::vector<Hex::Quad * > *self){
4052       if (self->size() == 0)
4053         throw std::out_of_range("pop from empty container");
4054       std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >::value_type x = self->back();
4055       self->pop_back();
4056       return x;
4057     }
4058 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){
4059       return swig::getslice(self, i, j);
4060     }
4061 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){
4062       swig::setslice(self, i, j, v);
4063     }
4064 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){
4065       swig::delslice(self, i, j);
4066     }
4067 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delitem__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i){
4068       self->erase(swig::getpos(self,i));
4069     }
4070 SWIGINTERN std::vector<Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg____getitem__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i){
4071       return *(swig::cgetpos(self, i));
4072     }
4073 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem__(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::difference_type i,std::vector<Hex::Quad * >::value_type x){
4074       *(swig::getpos(self,i)) = x;
4075     }
4076 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg__append(std::vector<Hex::Quad * > *self,std::vector<Hex::Quad * >::value_type x){
4077       self->push_back(x);
4078     }
4079
4080   namespace swig {
4081     template <>  struct traits<Hex::Edge > {
4082       typedef pointer_category category;
4083       static const char* type_name() { return"Hex::Edge"; }
4084     };
4085   }
4086
4087
4088       namespace swig {
4089         template <>  struct traits<std::vector<Hex::Edge*, std::allocator<Hex::Edge * > > > {
4090           typedef value_category category;
4091           static const char* type_name() {
4092             return "std::vector<" "Hex::Edge" " *," "std::allocator<Hex::Edge * >" " >";
4093           }
4094         };
4095       }
4096
4097 SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Edge_Sm__Sg__iterator(std::vector<Hex::Edge * > *self,PyObject **PYTHON_SELF){
4098       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4099     }
4100 SWIGINTERN bool std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__(std::vector<Hex::Edge * > const *self){
4101       return !(self->empty());
4102     }
4103 SWIGINTERN std::vector<Hex::Edge * >::size_type std_vector_Sl_Hex_Edge_Sm__Sg____len__(std::vector<Hex::Edge * > const *self){
4104       return self->size();
4105     }
4106 SWIGINTERN std::vector<Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg__pop(std::vector<Hex::Edge * > *self){
4107       if (self->size() == 0)
4108         throw std::out_of_range("pop from empty container");
4109       std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >::value_type x = self->back();
4110       self->pop_back();
4111       return x;
4112     }
4113 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){
4114       return swig::getslice(self, i, j);
4115     }
4116 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){
4117       swig::setslice(self, i, j, v);
4118     }
4119 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){
4120       swig::delslice(self, i, j);
4121     }
4122 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delitem__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i){
4123       self->erase(swig::getpos(self,i));
4124     }
4125 SWIGINTERN std::vector<Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg____getitem__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i){
4126       return *(swig::cgetpos(self, i));
4127     }
4128 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem__(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::difference_type i,std::vector<Hex::Edge * >::value_type x){
4129       *(swig::getpos(self,i)) = x;
4130     }
4131 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg__append(std::vector<Hex::Edge * > *self,std::vector<Hex::Edge * >::value_type x){
4132       self->push_back(x);
4133     }
4134
4135   namespace swig {
4136     template <>  struct traits<Hex::Vertex > {
4137       typedef pointer_category category;
4138       static const char* type_name() { return"Hex::Vertex"; }
4139     };
4140   }
4141
4142
4143       namespace swig {
4144         template <>  struct traits<std::vector<Hex::Vertex*, std::allocator<Hex::Vertex * > > > {
4145           typedef value_category category;
4146           static const char* type_name() {
4147             return "std::vector<" "Hex::Vertex" " *," "std::allocator<Hex::Vertex * >" " >";
4148           }
4149         };
4150       }
4151
4152 SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(std::vector<Hex::Vertex * > *self,PyObject **PYTHON_SELF){
4153       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4154     }
4155 SWIGINTERN bool std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__(std::vector<Hex::Vertex * > const *self){
4156       return !(self->empty());
4157     }
4158 SWIGINTERN std::vector<Hex::Vertex * >::size_type std_vector_Sl_Hex_Vertex_Sm__Sg____len__(std::vector<Hex::Vertex * > const *self){
4159       return self->size();
4160     }
4161 SWIGINTERN std::vector<Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg__pop(std::vector<Hex::Vertex * > *self){
4162       if (self->size() == 0)
4163         throw std::out_of_range("pop from empty container");
4164       std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >::value_type x = self->back();
4165       self->pop_back();
4166       return x;
4167     }
4168 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){
4169       return swig::getslice(self, i, j);
4170     }
4171 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){
4172       swig::setslice(self, i, j, v);
4173     }
4174 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){
4175       swig::delslice(self, i, j);
4176     }
4177 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delitem__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i){
4178       self->erase(swig::getpos(self,i));
4179     }
4180 SWIGINTERN std::vector<Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg____getitem__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i){
4181       return *(swig::cgetpos(self, i));
4182     }
4183 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem__(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::difference_type i,std::vector<Hex::Vertex * >::value_type x){
4184       *(swig::getpos(self,i)) = x;
4185     }
4186 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg__append(std::vector<Hex::Vertex * > *self,std::vector<Hex::Vertex * >::value_type x){
4187       self->push_back(x);
4188     }
4189
4190   namespace swig {
4191     template <>  struct traits<Hex::NewShape > {
4192       typedef pointer_category category;
4193       static const char* type_name() { return"Hex::NewShape"; }
4194     };
4195   }
4196
4197
4198       namespace swig {
4199         template <>  struct traits<std::vector<Hex::NewShape*, std::allocator<Hex::NewShape * > > > {
4200           typedef value_category category;
4201           static const char* type_name() {
4202             return "std::vector<" "Hex::NewShape" " *," "std::allocator<Hex::NewShape * >" " >";
4203           }
4204         };
4205       }
4206
4207 SWIGINTERN swig::PySwigIterator *std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(std::vector<Hex::NewShape * > *self,PyObject **PYTHON_SELF){
4208       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4209     }
4210 SWIGINTERN bool std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__(std::vector<Hex::NewShape * > const *self){
4211       return !(self->empty());
4212     }
4213 SWIGINTERN std::vector<Hex::NewShape * >::size_type std_vector_Sl_Hex_NewShape_Sm__Sg____len__(std::vector<Hex::NewShape * > const *self){
4214       return self->size();
4215     }
4216 SWIGINTERN std::vector<Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg__pop(std::vector<Hex::NewShape * > *self){
4217       if (self->size() == 0)
4218         throw std::out_of_range("pop from empty container");
4219       std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >::value_type x = self->back();
4220       self->pop_back();
4221       return x;
4222     }
4223 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){
4224       return swig::getslice(self, i, j);
4225     }
4226 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){
4227       swig::setslice(self, i, j, v);
4228     }
4229 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){
4230       swig::delslice(self, i, j);
4231     }
4232 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delitem__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i){
4233       self->erase(swig::getpos(self,i));
4234     }
4235 SWIGINTERN std::vector<Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg____getitem__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i){
4236       return *(swig::cgetpos(self, i));
4237     }
4238 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem__(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::difference_type i,std::vector<Hex::NewShape * >::value_type x){
4239       *(swig::getpos(self,i)) = x;
4240     }
4241 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg__append(std::vector<Hex::NewShape * > *self,std::vector<Hex::NewShape * >::value_type x){
4242       self->push_back(x);
4243     }
4244
4245   #define SWIG_From_double   PyFloat_FromDouble
4246
4247
4248 namespace swig {
4249   template <> struct traits<double > {
4250     typedef value_category category;
4251     static const char* type_name() { return"double"; }
4252   };
4253   template <>  struct traits_asval<double > {
4254     typedef double value_type;
4255     static int asval(PyObject *obj, value_type *val) {
4256       return SWIG_AsVal_double (obj, val);
4257     }
4258   };
4259   template <>  struct traits_from<double > {
4260     typedef double value_type;
4261     static PyObject *from(const value_type& val) {
4262       return SWIG_From_double  (val);
4263     }
4264   };
4265 }
4266
4267
4268       namespace swig {
4269         template <>  struct traits<std::vector<double, std::allocator<double > > > {
4270           typedef pointer_category category;
4271           static const char* type_name() {
4272             return "std::vector<" "double" "," "std::allocator<double >" " >";
4273           }
4274         };
4275       }
4276
4277 SWIGINTERN swig::PySwigIterator *std_vector_Sl_double_Sg__iterator(std::vector<double > *self,PyObject **PYTHON_SELF){
4278       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4279     }
4280 SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector<double > const *self){
4281       return !(self->empty());
4282     }
4283 SWIGINTERN std::vector<double >::size_type std_vector_Sl_double_Sg____len__(std::vector<double > const *self){
4284       return self->size();
4285     }
4286 SWIGINTERN std::vector<double >::value_type std_vector_Sl_double_Sg__pop(std::vector<double > *self){
4287       if (self->size() == 0)
4288         throw std::out_of_range("pop from empty container");
4289       std::vector<double,std::allocator<double > >::value_type x = self->back();
4290       self->pop_back();
4291       return x;
4292     }
4293 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){
4294       return swig::getslice(self, i, j);
4295     }
4296 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){
4297       swig::setslice(self, i, j, v);
4298     }
4299 SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector<double > *self,std::vector<double >::difference_type i,std::vector<double >::difference_type j){
4300       swig::delslice(self, i, j);
4301     }
4302 SWIGINTERN void std_vector_Sl_double_Sg____delitem__(std::vector<double > *self,std::vector<double >::difference_type i){
4303       self->erase(swig::getpos(self,i));
4304     }
4305 SWIGINTERN std::vector<double >::value_type const &std_vector_Sl_double_Sg____getitem__(std::vector<double > const *self,std::vector<double >::difference_type i){
4306       return *(swig::cgetpos(self, i));
4307     }
4308 SWIGINTERN void std_vector_Sl_double_Sg____setitem__(std::vector<double > *self,std::vector<double >::difference_type i,std::vector<double >::value_type const &x){
4309       *(swig::getpos(self,i)) = x;
4310     }
4311 SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector<double > *self,std::vector<double >::value_type const &x){
4312       self->push_back(x);
4313     }
4314
4315 #include <limits.h>
4316 #ifndef LLONG_MIN
4317 # define LLONG_MIN      LONG_LONG_MIN
4318 #endif
4319 #ifndef LLONG_MAX
4320 # define LLONG_MAX      LONG_LONG_MAX
4321 #endif
4322 #ifndef ULLONG_MAX
4323 # define ULLONG_MAX     ULONG_LONG_MAX
4324 #endif
4325
4326
4327 SWIGINTERN int
4328 SWIG_AsVal_int (PyObject * obj, int *val)
4329 {
4330   long v;
4331   int res = SWIG_AsVal_long (obj, &v);
4332   if (SWIG_IsOK(res)) {
4333     if ((v < INT_MIN || v > INT_MAX)) {
4334       return SWIG_OverflowError;
4335     } else {
4336       if (val) *val = static_cast< int >(v);
4337     }
4338   }
4339   return res;
4340 }
4341
4342
4343 SWIGINTERNINLINE PyObject *
4344 SWIG_From_int  (int value)
4345 {
4346   return SWIG_From_long  (value);
4347 }
4348
4349
4350 namespace swig {
4351   template <> struct traits<int > {
4352     typedef value_category category;
4353     static const char* type_name() { return"int"; }
4354   };
4355   template <>  struct traits_asval<int > {
4356     typedef int value_type;
4357     static int asval(PyObject *obj, value_type *val) {
4358       return SWIG_AsVal_int (obj, val);
4359     }
4360   };
4361   template <>  struct traits_from<int > {
4362     typedef int value_type;
4363     static PyObject *from(const value_type& val) {
4364       return SWIG_From_int  (val);
4365     }
4366   };
4367 }
4368
4369
4370       namespace swig {
4371         template <>  struct traits<std::vector<int, std::allocator<int > > > {
4372           typedef pointer_category category;
4373           static const char* type_name() {
4374             return "std::vector<" "int" "," "std::allocator<int >" " >";
4375           }
4376         };
4377       }
4378
4379 SWIGINTERN swig::PySwigIterator *std_vector_Sl_int_Sg__iterator(std::vector<int > *self,PyObject **PYTHON_SELF){
4380       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4381     }
4382 SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector<int > const *self){
4383       return !(self->empty());
4384     }
4385 SWIGINTERN std::vector<int >::size_type std_vector_Sl_int_Sg____len__(std::vector<int > const *self){
4386       return self->size();
4387     }
4388 SWIGINTERN std::vector<int >::value_type std_vector_Sl_int_Sg__pop(std::vector<int > *self){
4389       if (self->size() == 0)
4390         throw std::out_of_range("pop from empty container");
4391       std::vector<int,std::allocator<int > >::value_type x = self->back();
4392       self->pop_back();
4393       return x;
4394     }
4395 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){
4396       return swig::getslice(self, i, j);
4397     }
4398 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){
4399       swig::setslice(self, i, j, v);
4400     }
4401 SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::difference_type j){
4402       swig::delslice(self, i, j);
4403     }
4404 SWIGINTERN void std_vector_Sl_int_Sg____delitem__(std::vector<int > *self,std::vector<int >::difference_type i){
4405       self->erase(swig::getpos(self,i));
4406     }
4407 SWIGINTERN std::vector<int >::value_type const &std_vector_Sl_int_Sg____getitem__(std::vector<int > const *self,std::vector<int >::difference_type i){
4408       return *(swig::cgetpos(self, i));
4409     }
4410 SWIGINTERN void std_vector_Sl_int_Sg____setitem__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::value_type const &x){
4411       *(swig::getpos(self,i)) = x;
4412     }
4413 SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector<int > *self,std::vector<int >::value_type const &x){
4414       self->push_back(x);
4415     }
4416
4417 SWIGINTERN swig_type_info*
4418 SWIG_pchar_descriptor(void)
4419 {
4420   static int init = 0;
4421   static swig_type_info* info = 0;
4422   if (!init) {
4423     info = SWIG_TypeQuery("_p_char");
4424     init = 1;
4425   }
4426   return info;
4427 }
4428
4429
4430 SWIGINTERNINLINE PyObject *
4431 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
4432 {
4433   if (carray) {
4434     if (size > INT_MAX) {
4435       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4436       return pchar_descriptor ?
4437         SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
4438     } else {
4439       return PyString_FromStringAndSize(carray, static_cast< int >(size));
4440     }
4441   } else {
4442     return SWIG_Py_Void();
4443   }
4444 }
4445
4446
4447 SWIGINTERNINLINE PyObject *
4448 SWIG_From_char  (char c)
4449 {
4450   return SWIG_FromCharPtrAndSize(&c,1);
4451 }
4452
4453
4454 SWIGINTERNINLINE PyObject *
4455 SWIG_FromCharPtr(const char *cptr)
4456 {
4457   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
4458 }
4459
4460
4461 SWIGINTERN int
4462 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
4463 {
4464   if (PyString_Check(obj)) {
4465     char *cstr; Py_ssize_t len;
4466     PyString_AsStringAndSize(obj, &cstr, &len);
4467     if (cptr)  {
4468       if (alloc) {
4469         /*
4470            In python the user should not be able to modify the inner
4471            string representation. To warranty that, if you define
4472            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
4473            buffer is always returned.
4474
4475            The default behavior is just to return the pointer value,
4476            so, be careful.
4477         */
4478 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
4479         if (*alloc != SWIG_OLDOBJ)
4480 #else
4481         if (*alloc == SWIG_NEWOBJ)
4482 #endif
4483           {
4484             *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
4485             *alloc = SWIG_NEWOBJ;
4486           }
4487         else {
4488           *cptr = cstr;
4489           *alloc = SWIG_OLDOBJ;
4490         }
4491       } else {
4492         *cptr = PyString_AsString(obj);
4493       }
4494     }
4495     if (psize) *psize = len + 1;
4496     return SWIG_OK;
4497   } else {
4498     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4499     if (pchar_descriptor) {
4500       void* vptr = 0;
4501       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
4502         if (cptr) *cptr = (char *) vptr;
4503         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
4504         if (alloc) *alloc = SWIG_OLDOBJ;
4505         return SWIG_OK;
4506       }
4507     }
4508   }
4509   return SWIG_TypeError;
4510 }
4511
4512
4513
4514
4515
4516 SWIGINTERN int
4517 SWIG_AsVal_bool (PyObject *obj, bool *val)
4518 {
4519   if (obj == Py_True) {
4520     if (val) *val = true;
4521     return SWIG_OK;
4522   } else if (obj == Py_False) {
4523     if (val) *val = false;
4524     return SWIG_OK;
4525   } else {
4526     long v = 0;
4527     int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
4528     if (SWIG_IsOK(res) && val) *val = v ? true : false;
4529     return res;
4530   }
4531 }
4532
4533 #ifdef __cplusplus
4534 extern "C" {
4535 #endif
4536 SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4537   PyObject *resultobj = 0;
4538   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4539   void *argp1 = 0 ;
4540   int res1 = 0 ;
4541   PyObject * obj0 = 0 ;
4542
4543   if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
4544   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
4545   if (!SWIG_IsOK(res1)) {
4546     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4547   }
4548   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4549   delete arg1;
4550
4551   resultobj = SWIG_Py_Void();
4552   return resultobj;
4553 fail:
4554   return NULL;
4555 }
4556
4557
4558 SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4559   PyObject *resultobj = 0;
4560   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4561   PyObject *result = 0 ;
4562   void *argp1 = 0 ;
4563   int res1 = 0 ;
4564   PyObject * obj0 = 0 ;
4565
4566   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_value",&obj0)) SWIG_fail;
4567   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4568   if (!SWIG_IsOK(res1)) {
4569     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4570   }
4571   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4572   try {
4573     result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
4574   }
4575   catch(swig::stop_iteration &_e) {
4576     {
4577       (void)_e;
4578       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4579       SWIG_fail;
4580     }
4581   }
4582
4583   resultobj = result;
4584   return resultobj;
4585 fail:
4586   return NULL;
4587 }
4588
4589
4590 SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4591   PyObject *resultobj = 0;
4592   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4593   size_t arg2 ;
4594   swig::PySwigIterator *result = 0 ;
4595   void *argp1 = 0 ;
4596   int res1 = 0 ;
4597   size_t val2 ;
4598   int ecode2 = 0 ;
4599   PyObject * obj0 = 0 ;
4600   PyObject * obj1 = 0 ;
4601
4602   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
4603   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4604   if (!SWIG_IsOK(res1)) {
4605     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4606   }
4607   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4608   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
4609   if (!SWIG_IsOK(ecode2)) {
4610     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
4611   }
4612   arg2 = static_cast< size_t >(val2);
4613   try {
4614     result = (swig::PySwigIterator *)(arg1)->incr(arg2);
4615   }
4616   catch(swig::stop_iteration &_e) {
4617     {
4618       (void)_e;
4619       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4620       SWIG_fail;
4621     }
4622   }
4623
4624   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4625   return resultobj;
4626 fail:
4627   return NULL;
4628 }
4629
4630
4631 SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4632   PyObject *resultobj = 0;
4633   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4634   swig::PySwigIterator *result = 0 ;
4635   void *argp1 = 0 ;
4636   int res1 = 0 ;
4637   PyObject * obj0 = 0 ;
4638
4639   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_incr",&obj0)) SWIG_fail;
4640   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4641   if (!SWIG_IsOK(res1)) {
4642     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4643   }
4644   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4645   try {
4646     result = (swig::PySwigIterator *)(arg1)->incr();
4647   }
4648   catch(swig::stop_iteration &_e) {
4649     {
4650       (void)_e;
4651       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4652       SWIG_fail;
4653     }
4654   }
4655
4656   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4657   return resultobj;
4658 fail:
4659   return NULL;
4660 }
4661
4662
4663 SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
4664   int argc;
4665   PyObject *argv[3];
4666   int ii;
4667
4668   if (!PyTuple_Check(args)) SWIG_fail;
4669   argc = PyObject_Length(args);
4670   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4671     argv[ii] = PyTuple_GET_ITEM(args,ii);
4672   }
4673   if (argc == 1) {
4674     int _v;
4675     void *vptr = 0;
4676     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4677     _v = SWIG_CheckState(res);
4678     if (_v) {
4679       return _wrap_PySwigIterator_incr__SWIG_1(self, args);
4680     }
4681   }
4682   if (argc == 2) {
4683     int _v;
4684     void *vptr = 0;
4685     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4686     _v = SWIG_CheckState(res);
4687     if (_v) {
4688       {
4689         int res = SWIG_AsVal_size_t(argv[1], NULL);
4690         _v = SWIG_CheckState(res);
4691       }
4692       if (_v) {
4693         return _wrap_PySwigIterator_incr__SWIG_0(self, args);
4694       }
4695     }
4696   }
4697
4698 fail:
4699   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n  Possible C/C++ prototypes are:\n    incr(size_t)\n    incr()\n");
4700   return NULL;
4701 }
4702
4703
4704 SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4705   PyObject *resultobj = 0;
4706   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4707   size_t arg2 ;
4708   swig::PySwigIterator *result = 0 ;
4709   void *argp1 = 0 ;
4710   int res1 = 0 ;
4711   size_t val2 ;
4712   int ecode2 = 0 ;
4713   PyObject * obj0 = 0 ;
4714   PyObject * obj1 = 0 ;
4715
4716   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_decr",&obj0,&obj1)) SWIG_fail;
4717   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4718   if (!SWIG_IsOK(res1)) {
4719     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4720   }
4721   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4722   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
4723   if (!SWIG_IsOK(ecode2)) {
4724     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
4725   }
4726   arg2 = static_cast< size_t >(val2);
4727   try {
4728     result = (swig::PySwigIterator *)(arg1)->decr(arg2);
4729   }
4730   catch(swig::stop_iteration &_e) {
4731     {
4732       (void)_e;
4733       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4734       SWIG_fail;
4735     }
4736   }
4737
4738   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4739   return resultobj;
4740 fail:
4741   return NULL;
4742 }
4743
4744
4745 SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4746   PyObject *resultobj = 0;
4747   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4748   swig::PySwigIterator *result = 0 ;
4749   void *argp1 = 0 ;
4750   int res1 = 0 ;
4751   PyObject * obj0 = 0 ;
4752
4753   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
4754   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4755   if (!SWIG_IsOK(res1)) {
4756     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4757   }
4758   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4759   try {
4760     result = (swig::PySwigIterator *)(arg1)->decr();
4761   }
4762   catch(swig::stop_iteration &_e) {
4763     {
4764       (void)_e;
4765       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4766       SWIG_fail;
4767     }
4768   }
4769
4770   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4771   return resultobj;
4772 fail:
4773   return NULL;
4774 }
4775
4776
4777 SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
4778   int argc;
4779   PyObject *argv[3];
4780   int ii;
4781
4782   if (!PyTuple_Check(args)) SWIG_fail;
4783   argc = PyObject_Length(args);
4784   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4785     argv[ii] = PyTuple_GET_ITEM(args,ii);
4786   }
4787   if (argc == 1) {
4788     int _v;
4789     void *vptr = 0;
4790     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4791     _v = SWIG_CheckState(res);
4792     if (_v) {
4793       return _wrap_PySwigIterator_decr__SWIG_1(self, args);
4794     }
4795   }
4796   if (argc == 2) {
4797     int _v;
4798     void *vptr = 0;
4799     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4800     _v = SWIG_CheckState(res);
4801     if (_v) {
4802       {
4803         int res = SWIG_AsVal_size_t(argv[1], NULL);
4804         _v = SWIG_CheckState(res);
4805       }
4806       if (_v) {
4807         return _wrap_PySwigIterator_decr__SWIG_0(self, args);
4808       }
4809     }
4810   }
4811
4812 fail:
4813   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n  Possible C/C++ prototypes are:\n    decr(size_t)\n    decr()\n");
4814   return NULL;
4815 }
4816
4817
4818 SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4819   PyObject *resultobj = 0;
4820   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4821   swig::PySwigIterator *arg2 = 0 ;
4822   ptrdiff_t result;
4823   void *argp1 = 0 ;
4824   int res1 = 0 ;
4825   void *argp2 = 0 ;
4826   int res2 = 0 ;
4827   PyObject * obj0 = 0 ;
4828   PyObject * obj1 = 0 ;
4829
4830   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
4831   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4832   if (!SWIG_IsOK(res1)) {
4833     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4834   }
4835   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4836   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
4837   if (!SWIG_IsOK(res2)) {
4838     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4839   }
4840   if (!argp2) {
4841     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4842   }
4843   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
4844   try {
4845     result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
4846   }
4847   catch(std::invalid_argument &_e) {
4848     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;
4849   }
4850
4851   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
4852   return resultobj;
4853 fail:
4854   return NULL;
4855 }
4856
4857
4858 SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4859   PyObject *resultobj = 0;
4860   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4861   swig::PySwigIterator *arg2 = 0 ;
4862   bool result;
4863   void *argp1 = 0 ;
4864   int res1 = 0 ;
4865   void *argp2 = 0 ;
4866   int res2 = 0 ;
4867   PyObject * obj0 = 0 ;
4868   PyObject * obj1 = 0 ;
4869
4870   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
4871   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4872   if (!SWIG_IsOK(res1)) {
4873     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4874   }
4875   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4876   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
4877   if (!SWIG_IsOK(res2)) {
4878     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4879   }
4880   if (!argp2) {
4881     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4882   }
4883   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
4884   try {
4885     result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
4886   }
4887   catch(std::invalid_argument &_e) {
4888     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;
4889   }
4890
4891   resultobj = SWIG_From_bool(static_cast< bool >(result));
4892   return resultobj;
4893 fail:
4894   return NULL;
4895 }
4896
4897
4898 SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4899   PyObject *resultobj = 0;
4900   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4901   swig::PySwigIterator *result = 0 ;
4902   void *argp1 = 0 ;
4903   int res1 = 0 ;
4904   PyObject * obj0 = 0 ;
4905
4906   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
4907   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4908   if (!SWIG_IsOK(res1)) {
4909     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4910   }
4911   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4912   result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
4913   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
4914   return resultobj;
4915 fail:
4916   return NULL;
4917 }
4918
4919
4920 SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4921   PyObject *resultobj = 0;
4922   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4923   PyObject *result = 0 ;
4924   void *argp1 = 0 ;
4925   int res1 = 0 ;
4926   PyObject * obj0 = 0 ;
4927
4928   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
4929   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4930   if (!SWIG_IsOK(res1)) {
4931     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4932   }
4933   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4934   try {
4935     result = (PyObject *)(arg1)->next();
4936   }
4937   catch(swig::stop_iteration &_e) {
4938     {
4939       (void)_e;
4940       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4941       SWIG_fail;
4942     }
4943   }
4944
4945   resultobj = result;
4946   return resultobj;
4947 fail:
4948   return NULL;
4949 }
4950
4951
4952 SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4953   PyObject *resultobj = 0;
4954   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4955   PyObject *result = 0 ;
4956   void *argp1 = 0 ;
4957   int res1 = 0 ;
4958   PyObject * obj0 = 0 ;
4959
4960   if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
4961   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4962   if (!SWIG_IsOK(res1)) {
4963     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4964   }
4965   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4966   try {
4967     result = (PyObject *)(arg1)->previous();
4968   }
4969   catch(swig::stop_iteration &_e) {
4970     {
4971       (void)_e;
4972       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4973       SWIG_fail;
4974     }
4975   }
4976
4977   resultobj = result;
4978   return resultobj;
4979 fail:
4980   return NULL;
4981 }
4982
4983
4984 SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4985   PyObject *resultobj = 0;
4986   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4987   ptrdiff_t arg2 ;
4988   swig::PySwigIterator *result = 0 ;
4989   void *argp1 = 0 ;
4990   int res1 = 0 ;
4991   ptrdiff_t val2 ;
4992   int ecode2 = 0 ;
4993   PyObject * obj0 = 0 ;
4994   PyObject * obj1 = 0 ;
4995
4996   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_advance",&obj0,&obj1)) SWIG_fail;
4997   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4998   if (!SWIG_IsOK(res1)) {
4999     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5000   }
5001   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5002   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5003   if (!SWIG_IsOK(ecode2)) {
5004     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
5005   }
5006   arg2 = static_cast< ptrdiff_t >(val2);
5007   try {
5008     result = (swig::PySwigIterator *)(arg1)->advance(arg2);
5009   }
5010   catch(swig::stop_iteration &_e) {
5011     {
5012       (void)_e;
5013       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5014       SWIG_fail;
5015     }
5016   }
5017
5018   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5019   return resultobj;
5020 fail:
5021   return NULL;
5022 }
5023
5024
5025 SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5026   PyObject *resultobj = 0;
5027   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5028   swig::PySwigIterator *arg2 = 0 ;
5029   bool result;
5030   void *argp1 = 0 ;
5031   int res1 = 0 ;
5032   void *argp2 = 0 ;
5033   int res2 = 0 ;
5034   PyObject * obj0 = 0 ;
5035   PyObject * obj1 = 0 ;
5036
5037   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
5038   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5039   if (!SWIG_IsOK(res1)) {
5040     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5041   }
5042   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5043   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5044   if (!SWIG_IsOK(res2)) {
5045     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5046   }
5047   if (!argp2) {
5048     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5049   }
5050   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5051   result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
5052   resultobj = SWIG_From_bool(static_cast< bool >(result));
5053   return resultobj;
5054 fail:
5055   return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5060   PyObject *resultobj = 0;
5061   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5062   swig::PySwigIterator *arg2 = 0 ;
5063   bool result;
5064   void *argp1 = 0 ;
5065   int res1 = 0 ;
5066   void *argp2 = 0 ;
5067   int res2 = 0 ;
5068   PyObject * obj0 = 0 ;
5069   PyObject * obj1 = 0 ;
5070
5071   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
5072   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5073   if (!SWIG_IsOK(res1)) {
5074     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5075   }
5076   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5077   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5078   if (!SWIG_IsOK(res2)) {
5079     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5080   }
5081   if (!argp2) {
5082     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5083   }
5084   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5085   result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
5086   resultobj = SWIG_From_bool(static_cast< bool >(result));
5087   return resultobj;
5088 fail:
5089   return NULL;
5090 }
5091
5092
5093 SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5094   PyObject *resultobj = 0;
5095   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5096   ptrdiff_t arg2 ;
5097   swig::PySwigIterator *result = 0 ;
5098   void *argp1 = 0 ;
5099   int res1 = 0 ;
5100   ptrdiff_t val2 ;
5101   int ecode2 = 0 ;
5102   PyObject * obj0 = 0 ;
5103   PyObject * obj1 = 0 ;
5104
5105   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
5106   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
5107   if (!SWIG_IsOK(res1)) {
5108     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5109   }
5110   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5111   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5112   if (!SWIG_IsOK(ecode2)) {
5113     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
5114   }
5115   arg2 = static_cast< ptrdiff_t >(val2);
5116   try {
5117     {
5118       swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
5119       result = (swig::PySwigIterator *) &_result_ref;
5120     }
5121   }
5122   catch(swig::stop_iteration &_e) {
5123     {
5124       (void)_e;
5125       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5126       SWIG_fail;
5127     }
5128   }
5129
5130   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5131   return resultobj;
5132 fail:
5133   return NULL;
5134 }
5135
5136
5137 SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5138   PyObject *resultobj = 0;
5139   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5140   ptrdiff_t arg2 ;
5141   swig::PySwigIterator *result = 0 ;
5142   void *argp1 = 0 ;
5143   int res1 = 0 ;
5144   ptrdiff_t val2 ;
5145   int ecode2 = 0 ;
5146   PyObject * obj0 = 0 ;
5147   PyObject * obj1 = 0 ;
5148
5149   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
5150   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
5151   if (!SWIG_IsOK(res1)) {
5152     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5153   }
5154   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5155   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5156   if (!SWIG_IsOK(ecode2)) {
5157     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5158   }
5159   arg2 = static_cast< ptrdiff_t >(val2);
5160   try {
5161     {
5162       swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
5163       result = (swig::PySwigIterator *) &_result_ref;
5164     }
5165   }
5166   catch(swig::stop_iteration &_e) {
5167     {
5168       (void)_e;
5169       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5170       SWIG_fail;
5171     }
5172   }
5173
5174   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5175   return resultobj;
5176 fail:
5177   return NULL;
5178 }
5179
5180
5181 SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5182   PyObject *resultobj = 0;
5183   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5184   ptrdiff_t arg2 ;
5185   swig::PySwigIterator *result = 0 ;
5186   void *argp1 = 0 ;
5187   int res1 = 0 ;
5188   ptrdiff_t val2 ;
5189   int ecode2 = 0 ;
5190   PyObject * obj0 = 0 ;
5191   PyObject * obj1 = 0 ;
5192
5193   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
5194   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5195   if (!SWIG_IsOK(res1)) {
5196     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5197   }
5198   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5199   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5200   if (!SWIG_IsOK(ecode2)) {
5201     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
5202   }
5203   arg2 = static_cast< ptrdiff_t >(val2);
5204   try {
5205     result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
5206   }
5207   catch(swig::stop_iteration &_e) {
5208     {
5209       (void)_e;
5210       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5211       SWIG_fail;
5212     }
5213   }
5214
5215   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5216   return resultobj;
5217 fail:
5218   return NULL;
5219 }
5220
5221
5222 SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5223   PyObject *resultobj = 0;
5224   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5225   ptrdiff_t arg2 ;
5226   swig::PySwigIterator *result = 0 ;
5227   void *argp1 = 0 ;
5228   int res1 = 0 ;
5229   ptrdiff_t val2 ;
5230   int ecode2 = 0 ;
5231   PyObject * obj0 = 0 ;
5232   PyObject * obj1 = 0 ;
5233
5234   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
5235   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5236   if (!SWIG_IsOK(res1)) {
5237     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5238   }
5239   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5240   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5241   if (!SWIG_IsOK(ecode2)) {
5242     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5243   }
5244   arg2 = static_cast< ptrdiff_t >(val2);
5245   try {
5246     result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
5247   }
5248   catch(swig::stop_iteration &_e) {
5249     {
5250       (void)_e;
5251       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5252       SWIG_fail;
5253     }
5254   }
5255
5256   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5257   return resultobj;
5258 fail:
5259   return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5264   PyObject *resultobj = 0;
5265   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5266   swig::PySwigIterator *arg2 = 0 ;
5267   ptrdiff_t result;
5268   void *argp1 = 0 ;
5269   int res1 = 0 ;
5270   void *argp2 = 0 ;
5271   int res2 = 0 ;
5272   PyObject * obj0 = 0 ;
5273   PyObject * obj1 = 0 ;
5274
5275   if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
5276   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5277   if (!SWIG_IsOK(res1)) {
5278     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5279   }
5280   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5281   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5282   if (!SWIG_IsOK(res2)) {
5283     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5284   }
5285   if (!argp2) {
5286     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5287   }
5288   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5289   result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
5290   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5291   return resultobj;
5292 fail:
5293   return NULL;
5294 }
5295
5296
5297 SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
5298   int argc;
5299   PyObject *argv[3];
5300   int ii;
5301
5302   if (!PyTuple_Check(args)) SWIG_fail;
5303   argc = PyObject_Length(args);
5304   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5305     argv[ii] = PyTuple_GET_ITEM(args,ii);
5306   }
5307   if (argc == 2) {
5308     int _v;
5309     void *vptr = 0;
5310     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5311     _v = SWIG_CheckState(res);
5312     if (_v) {
5313       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
5314       _v = SWIG_CheckState(res);
5315       if (_v) {
5316         return _wrap_PySwigIterator___sub____SWIG_1(self, args);
5317       }
5318     }
5319   }
5320   if (argc == 2) {
5321     int _v;
5322     void *vptr = 0;
5323     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5324     _v = SWIG_CheckState(res);
5325     if (_v) {
5326       {
5327         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
5328         _v = SWIG_CheckState(res);
5329       }
5330       if (_v) {
5331         return _wrap_PySwigIterator___sub____SWIG_0(self, args);
5332       }
5333     }
5334   }
5335
5336 fail:
5337   Py_INCREF(Py_NotImplemented);
5338   return Py_NotImplemented;
5339 }
5340
5341
5342 SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5343   PyObject *obj;
5344   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
5345   SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
5346   return SWIG_Py_Void();
5347 }
5348
5349 SWIGINTERN PyObject *_wrap_VectorHexas_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350   PyObject *resultobj = 0;
5351   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5352   PyObject **arg2 = (PyObject **) 0 ;
5353   swig::PySwigIterator *result = 0 ;
5354   void *argp1 = 0 ;
5355   int res1 = 0 ;
5356   PyObject * obj0 = 0 ;
5357
5358   arg2 = &obj0;
5359   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_iterator",&obj0)) SWIG_fail;
5360   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5361   if (!SWIG_IsOK(res1)) {
5362     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_iterator" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5363   }
5364   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5365   result = (swig::PySwigIterator *)std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(arg1,arg2);
5366   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5367   return resultobj;
5368 fail:
5369   return NULL;
5370 }
5371
5372
5373 SWIGINTERN PyObject *_wrap_VectorHexas___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5374   PyObject *resultobj = 0;
5375   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5376   bool result;
5377   void *argp1 = 0 ;
5378   int res1 = 0 ;
5379   PyObject * obj0 = 0 ;
5380
5381   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___nonzero__",&obj0)) SWIG_fail;
5382   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5383   if (!SWIG_IsOK(res1)) {
5384     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5385   }
5386   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5387   result = (bool)std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__((std::vector<Hex::Hexa * > const *)arg1);
5388   resultobj = SWIG_From_bool(static_cast< bool >(result));
5389   return resultobj;
5390 fail:
5391   return NULL;
5392 }
5393
5394
5395 SWIGINTERN PyObject *_wrap_VectorHexas___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5396   PyObject *resultobj = 0;
5397   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5398   std::vector<Hex::Hexa * >::size_type result;
5399   void *argp1 = 0 ;
5400   int res1 = 0 ;
5401   PyObject * obj0 = 0 ;
5402
5403   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___len__",&obj0)) SWIG_fail;
5404   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5405   if (!SWIG_IsOK(res1)) {
5406     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___len__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5407   }
5408   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5409   result = std_vector_Sl_Hex_Hexa_Sm__Sg____len__((std::vector<Hex::Hexa * > const *)arg1);
5410   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
5411   return resultobj;
5412 fail:
5413   return NULL;
5414 }
5415
5416
5417 SWIGINTERN PyObject *_wrap_VectorHexas_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5418   PyObject *resultobj = 0;
5419   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5420   std::vector<Hex::Hexa * >::value_type result;
5421   void *argp1 = 0 ;
5422   int res1 = 0 ;
5423   PyObject * obj0 = 0 ;
5424
5425   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop",&obj0)) SWIG_fail;
5426   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5427   if (!SWIG_IsOK(res1)) {
5428     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5429   }
5430   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5431   try {
5432     result = (std::vector<Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg__pop(arg1);
5433   }
5434   catch(std::out_of_range &_e) {
5435     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5436   }
5437
5438   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
5439   return resultobj;
5440 fail:
5441   return NULL;
5442 }
5443
5444
5445 SWIGINTERN PyObject *_wrap_VectorHexas___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5446   PyObject *resultobj = 0;
5447   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5448   std::vector<Hex::Hexa * >::difference_type arg2 ;
5449   std::vector<Hex::Hexa * >::difference_type arg3 ;
5450   std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *result = 0 ;
5451   void *argp1 = 0 ;
5452   int res1 = 0 ;
5453   ptrdiff_t val2 ;
5454   int ecode2 = 0 ;
5455   ptrdiff_t val3 ;
5456   int ecode3 = 0 ;
5457   PyObject * obj0 = 0 ;
5458   PyObject * obj1 = 0 ;
5459   PyObject * obj2 = 0 ;
5460
5461   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
5462   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5463   if (!SWIG_IsOK(res1)) {
5464     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5465   }
5466   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5467   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5468   if (!SWIG_IsOK(ecode2)) {
5469     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5470   }
5471   arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5472   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
5473   if (!SWIG_IsOK(ecode3)) {
5474     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5475   }
5476   arg3 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val3);
5477   try {
5478     result = (std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *)std_vector_Sl_Hex_Hexa_Sm__Sg____getslice__(arg1,arg2,arg3);
5479   }
5480   catch(std::out_of_range &_e) {
5481     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5482   }
5483
5484   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_OWN |  0 );
5485   return resultobj;
5486 fail:
5487   return NULL;
5488 }
5489
5490
5491 SWIGINTERN PyObject *_wrap_VectorHexas___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5492   PyObject *resultobj = 0;
5493   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5494   std::vector<Hex::Hexa * >::difference_type arg2 ;
5495   std::vector<Hex::Hexa * >::difference_type arg3 ;
5496   std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *arg4 = 0 ;
5497   void *argp1 = 0 ;
5498   int res1 = 0 ;
5499   ptrdiff_t val2 ;
5500   int ecode2 = 0 ;
5501   ptrdiff_t val3 ;
5502   int ecode3 = 0 ;
5503   int res4 = SWIG_OLDOBJ ;
5504   PyObject * obj0 = 0 ;
5505   PyObject * obj1 = 0 ;
5506   PyObject * obj2 = 0 ;
5507   PyObject * obj3 = 0 ;
5508
5509   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5510   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5511   if (!SWIG_IsOK(res1)) {
5512     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5513   }
5514   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5515   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5516   if (!SWIG_IsOK(ecode2)) {
5517     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5518   }
5519   arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5520   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
5521   if (!SWIG_IsOK(ecode3)) {
5522     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5523   }
5524   arg3 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val3);
5525   {
5526     std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *)0;
5527     res4 = swig::asptr(obj3, &ptr);
5528     if (!SWIG_IsOK(res4)) {
5529       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > const &""'");
5530     }
5531     if (!ptr) {
5532       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 &""'");
5533     }
5534     arg4 = ptr;
5535   }
5536   try {
5537     std_vector_Sl_Hex_Hexa_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > const &)*arg4);
5538   }
5539   catch(std::out_of_range &_e) {
5540     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5541   }
5542   catch(std::invalid_argument &_e) {
5543     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
5544   }
5545
5546   resultobj = SWIG_Py_Void();
5547   if (SWIG_IsNewObj(res4)) delete arg4;
5548   return resultobj;
5549 fail:
5550   if (SWIG_IsNewObj(res4)) delete arg4;
5551   return NULL;
5552 }
5553
5554
5555 SWIGINTERN PyObject *_wrap_VectorHexas___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5556   PyObject *resultobj = 0;
5557   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5558   std::vector<Hex::Hexa * >::difference_type arg2 ;
5559   std::vector<Hex::Hexa * >::difference_type arg3 ;
5560   void *argp1 = 0 ;
5561   int res1 = 0 ;
5562   ptrdiff_t val2 ;
5563   int ecode2 = 0 ;
5564   ptrdiff_t val3 ;
5565   int ecode3 = 0 ;
5566   PyObject * obj0 = 0 ;
5567   PyObject * obj1 = 0 ;
5568   PyObject * obj2 = 0 ;
5569
5570   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
5571   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5572   if (!SWIG_IsOK(res1)) {
5573     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5574   }
5575   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5576   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5577   if (!SWIG_IsOK(ecode2)) {
5578     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5579   }
5580   arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5581   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
5582   if (!SWIG_IsOK(ecode3)) {
5583     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5584   }
5585   arg3 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val3);
5586   try {
5587     std_vector_Sl_Hex_Hexa_Sm__Sg____delslice__(arg1,arg2,arg3);
5588   }
5589   catch(std::out_of_range &_e) {
5590     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5591   }
5592
5593   resultobj = SWIG_Py_Void();
5594   return resultobj;
5595 fail:
5596   return NULL;
5597 }
5598
5599
5600 SWIGINTERN PyObject *_wrap_VectorHexas___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601   PyObject *resultobj = 0;
5602   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5603   std::vector<Hex::Hexa * >::difference_type arg2 ;
5604   void *argp1 = 0 ;
5605   int res1 = 0 ;
5606   ptrdiff_t val2 ;
5607   int ecode2 = 0 ;
5608   PyObject * obj0 = 0 ;
5609   PyObject * obj1 = 0 ;
5610
5611   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___delitem__",&obj0,&obj1)) SWIG_fail;
5612   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5613   if (!SWIG_IsOK(res1)) {
5614     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5615   }
5616   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5617   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5618   if (!SWIG_IsOK(ecode2)) {
5619     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5620   }
5621   arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5622   try {
5623     std_vector_Sl_Hex_Hexa_Sm__Sg____delitem__(arg1,arg2);
5624   }
5625   catch(std::out_of_range &_e) {
5626     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5627   }
5628
5629   resultobj = SWIG_Py_Void();
5630   return resultobj;
5631 fail:
5632   return NULL;
5633 }
5634
5635
5636 SWIGINTERN PyObject *_wrap_VectorHexas___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5637   PyObject *resultobj = 0;
5638   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5639   std::vector<Hex::Hexa * >::difference_type arg2 ;
5640   std::vector<Hex::Hexa * >::value_type result;
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
5648   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___getitem__",&obj0,&obj1)) SWIG_fail;
5649   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5650   if (!SWIG_IsOK(res1)) {
5651     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5652   }
5653   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5654   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5655   if (!SWIG_IsOK(ecode2)) {
5656     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5657   }
5658   arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5659   try {
5660     result = (std::vector<Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg____getitem__(arg1,arg2);
5661   }
5662   catch(std::out_of_range &_e) {
5663     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5664   }
5665
5666   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
5667   return resultobj;
5668 fail:
5669   return NULL;
5670 }
5671
5672
5673 SWIGINTERN PyObject *_wrap_VectorHexas___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5674   PyObject *resultobj = 0;
5675   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5676   std::vector<Hex::Hexa * >::difference_type arg2 ;
5677   std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
5678   void *argp1 = 0 ;
5679   int res1 = 0 ;
5680   ptrdiff_t val2 ;
5681   int ecode2 = 0 ;
5682   void *argp3 = 0 ;
5683   int res3 = 0 ;
5684   PyObject * obj0 = 0 ;
5685   PyObject * obj1 = 0 ;
5686   PyObject * obj2 = 0 ;
5687
5688   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
5689   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5690   if (!SWIG_IsOK(res1)) {
5691     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5692   }
5693   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5694   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5695   if (!SWIG_IsOK(ecode2)) {
5696     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::difference_type""'");
5697   }
5698   arg2 = static_cast< std::vector<Hex::Hexa * >::difference_type >(val2);
5699   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
5700   if (!SWIG_IsOK(res3)) {
5701     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
5702   }
5703   arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
5704   try {
5705     std_vector_Sl_Hex_Hexa_Sm__Sg____setitem__(arg1,arg2,arg3);
5706   }
5707   catch(std::out_of_range &_e) {
5708     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5709   }
5710
5711   resultobj = SWIG_Py_Void();
5712   return resultobj;
5713 fail:
5714   return NULL;
5715 }
5716
5717
5718 SWIGINTERN PyObject *_wrap_VectorHexas_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5719   PyObject *resultobj = 0;
5720   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5721   std::vector<Hex::Hexa * >::value_type arg2 = (std::vector<Hex::Hexa * >::value_type) 0 ;
5722   void *argp1 = 0 ;
5723   int res1 = 0 ;
5724   void *argp2 = 0 ;
5725   int res2 = 0 ;
5726   PyObject * obj0 = 0 ;
5727   PyObject * obj1 = 0 ;
5728
5729   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_append",&obj0,&obj1)) SWIG_fail;
5730   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5731   if (!SWIG_IsOK(res1)) {
5732     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_append" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5733   }
5734   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5735   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
5736   if (!SWIG_IsOK(res2)) {
5737     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_append" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
5738   }
5739   arg2 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp2);
5740   std_vector_Sl_Hex_Hexa_Sm__Sg__append(arg1,arg2);
5741   resultobj = SWIG_Py_Void();
5742   return resultobj;
5743 fail:
5744   return NULL;
5745 }
5746
5747
5748 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5749   PyObject *resultobj = 0;
5750   std::vector<Hex::Hexa * > *result = 0 ;
5751
5752   if (!PyArg_ParseTuple(args,(char *)":new_VectorHexas")) SWIG_fail;
5753   result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >();
5754   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
5755   return resultobj;
5756 fail:
5757   return NULL;
5758 }
5759
5760
5761 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5762   PyObject *resultobj = 0;
5763   std::vector<Hex::Hexa * > *arg1 = 0 ;
5764   std::vector<Hex::Hexa * > *result = 0 ;
5765   int res1 = SWIG_OLDOBJ ;
5766   PyObject * obj0 = 0 ;
5767
5768   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
5769   {
5770     std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *)0;
5771     res1 = swig::asptr(obj0, &ptr);
5772     if (!SWIG_IsOK(res1)) {
5773       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const &""'");
5774     }
5775     if (!ptr) {
5776       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const &""'");
5777     }
5778     arg1 = ptr;
5779   }
5780   result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >((std::vector<Hex::Hexa * > const &)*arg1);
5781   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
5782   if (SWIG_IsNewObj(res1)) delete arg1;
5783   return resultobj;
5784 fail:
5785   if (SWIG_IsNewObj(res1)) delete arg1;
5786   return NULL;
5787 }
5788
5789
5790 SWIGINTERN PyObject *_wrap_VectorHexas_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5791   PyObject *resultobj = 0;
5792   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5793   bool result;
5794   void *argp1 = 0 ;
5795   int res1 = 0 ;
5796   PyObject * obj0 = 0 ;
5797
5798   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_empty",&obj0)) SWIG_fail;
5799   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5800   if (!SWIG_IsOK(res1)) {
5801     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_empty" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5802   }
5803   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5804   result = (bool)((std::vector<Hex::Hexa * > const *)arg1)->empty();
5805   resultobj = SWIG_From_bool(static_cast< bool >(result));
5806   return resultobj;
5807 fail:
5808   return NULL;
5809 }
5810
5811
5812 SWIGINTERN PyObject *_wrap_VectorHexas_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5813   PyObject *resultobj = 0;
5814   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5815   std::vector<Hex::Hexa * >::size_type result;
5816   void *argp1 = 0 ;
5817   int res1 = 0 ;
5818   PyObject * obj0 = 0 ;
5819
5820   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_size",&obj0)) SWIG_fail;
5821   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5822   if (!SWIG_IsOK(res1)) {
5823     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_size" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5824   }
5825   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5826   result = ((std::vector<Hex::Hexa * > const *)arg1)->size();
5827   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
5828   return resultobj;
5829 fail:
5830   return NULL;
5831 }
5832
5833
5834 SWIGINTERN PyObject *_wrap_VectorHexas_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5835   PyObject *resultobj = 0;
5836   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5837   void *argp1 = 0 ;
5838   int res1 = 0 ;
5839   PyObject * obj0 = 0 ;
5840
5841   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_clear",&obj0)) SWIG_fail;
5842   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5843   if (!SWIG_IsOK(res1)) {
5844     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_clear" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5845   }
5846   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5847   (arg1)->clear();
5848   resultobj = SWIG_Py_Void();
5849   return resultobj;
5850 fail:
5851   return NULL;
5852 }
5853
5854
5855 SWIGINTERN PyObject *_wrap_VectorHexas_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5856   PyObject *resultobj = 0;
5857   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5858   std::vector<Hex::Hexa * > *arg2 = 0 ;
5859   void *argp1 = 0 ;
5860   int res1 = 0 ;
5861   void *argp2 = 0 ;
5862   int res2 = 0 ;
5863   PyObject * obj0 = 0 ;
5864   PyObject * obj1 = 0 ;
5865
5866   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_swap",&obj0,&obj1)) SWIG_fail;
5867   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5868   if (!SWIG_IsOK(res1)) {
5869     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_swap" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5870   }
5871   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5872   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t,  0 );
5873   if (!SWIG_IsOK(res2)) {
5874     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector<Hex::Hexa * > &""'");
5875   }
5876   if (!argp2) {
5877     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector<Hex::Hexa * > &""'");
5878   }
5879   arg2 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp2);
5880   (arg1)->swap(*arg2);
5881   resultobj = SWIG_Py_Void();
5882   return resultobj;
5883 fail:
5884   return NULL;
5885 }
5886
5887
5888 SWIGINTERN PyObject *_wrap_VectorHexas_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5889   PyObject *resultobj = 0;
5890   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5891   SwigValueWrapper<std::allocator<Hex::Hexa * > > result;
5892   void *argp1 = 0 ;
5893   int res1 = 0 ;
5894   PyObject * obj0 = 0 ;
5895
5896   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_get_allocator",&obj0)) SWIG_fail;
5897   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5898   if (!SWIG_IsOK(res1)) {
5899     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5900   }
5901   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5902   result = ((std::vector<Hex::Hexa * > const *)arg1)->get_allocator();
5903   resultobj = SWIG_NewPointerObj((new std::vector<Hex::Hexa * >::allocator_type(static_cast< const std::vector<Hex::Hexa * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
5904   return resultobj;
5905 fail:
5906   return NULL;
5907 }
5908
5909
5910 SWIGINTERN PyObject *_wrap_VectorHexas_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5911   PyObject *resultobj = 0;
5912   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5913   std::vector<Hex::Hexa * >::iterator result;
5914   void *argp1 = 0 ;
5915   int res1 = 0 ;
5916   PyObject * obj0 = 0 ;
5917
5918   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_begin",&obj0)) SWIG_fail;
5919   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5920   if (!SWIG_IsOK(res1)) {
5921     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_begin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
5922   }
5923   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5924   result = (arg1)->begin();
5925   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
5926     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
5927   return resultobj;
5928 fail:
5929   return NULL;
5930 }
5931
5932
5933 SWIGINTERN PyObject *_wrap_VectorHexas_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5934   PyObject *resultobj = 0;
5935   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5936   std::vector<Hex::Hexa * >::const_iterator result;
5937   void *argp1 = 0 ;
5938   int res1 = 0 ;
5939   PyObject * obj0 = 0 ;
5940
5941   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_begin",&obj0)) SWIG_fail;
5942   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5943   if (!SWIG_IsOK(res1)) {
5944     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_begin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
5945   }
5946   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
5947   result = ((std::vector<Hex::Hexa * > const *)arg1)->begin();
5948   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_iterator & >(result)),
5949     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
5950   return resultobj;
5951 fail:
5952   return NULL;
5953 }
5954
5955
5956 SWIGINTERN PyObject *_wrap_VectorHexas_begin(PyObject *self, PyObject *args) {
5957   int argc;
5958   PyObject *argv[2];
5959   int ii;
5960
5961   if (!PyTuple_Check(args)) SWIG_fail;
5962   argc = PyObject_Length(args);
5963   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
5964     argv[ii] = PyTuple_GET_ITEM(args,ii);
5965   }
5966   if (argc == 1) {
5967     int _v;
5968     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
5969     _v = SWIG_CheckState(res);
5970     if (_v) {
5971       return _wrap_VectorHexas_begin__SWIG_0(self, args);
5972     }
5973   }
5974   if (argc == 1) {
5975     int _v;
5976     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
5977     _v = SWIG_CheckState(res);
5978     if (_v) {
5979       return _wrap_VectorHexas_begin__SWIG_1(self, args);
5980     }
5981   }
5982
5983 fail:
5984   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
5985   return NULL;
5986 }
5987
5988
5989 SWIGINTERN PyObject *_wrap_VectorHexas_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5990   PyObject *resultobj = 0;
5991   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
5992   std::vector<Hex::Hexa * >::iterator result;
5993   void *argp1 = 0 ;
5994   int res1 = 0 ;
5995   PyObject * obj0 = 0 ;
5996
5997   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_end",&obj0)) SWIG_fail;
5998   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
5999   if (!SWIG_IsOK(res1)) {
6000     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_end" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6001   }
6002   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6003   result = (arg1)->end();
6004   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
6005     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6006   return resultobj;
6007 fail:
6008   return NULL;
6009 }
6010
6011
6012 SWIGINTERN PyObject *_wrap_VectorHexas_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6013   PyObject *resultobj = 0;
6014   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6015   std::vector<Hex::Hexa * >::const_iterator result;
6016   void *argp1 = 0 ;
6017   int res1 = 0 ;
6018   PyObject * obj0 = 0 ;
6019
6020   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_end",&obj0)) SWIG_fail;
6021   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6022   if (!SWIG_IsOK(res1)) {
6023     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_end" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6024   }
6025   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6026   result = ((std::vector<Hex::Hexa * > const *)arg1)->end();
6027   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_iterator & >(result)),
6028     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6029   return resultobj;
6030 fail:
6031   return NULL;
6032 }
6033
6034
6035 SWIGINTERN PyObject *_wrap_VectorHexas_end(PyObject *self, PyObject *args) {
6036   int argc;
6037   PyObject *argv[2];
6038   int ii;
6039
6040   if (!PyTuple_Check(args)) SWIG_fail;
6041   argc = PyObject_Length(args);
6042   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6043     argv[ii] = PyTuple_GET_ITEM(args,ii);
6044   }
6045   if (argc == 1) {
6046     int _v;
6047     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6048     _v = SWIG_CheckState(res);
6049     if (_v) {
6050       return _wrap_VectorHexas_end__SWIG_0(self, args);
6051     }
6052   }
6053   if (argc == 1) {
6054     int _v;
6055     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6056     _v = SWIG_CheckState(res);
6057     if (_v) {
6058       return _wrap_VectorHexas_end__SWIG_1(self, args);
6059     }
6060   }
6061
6062 fail:
6063   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
6064   return NULL;
6065 }
6066
6067
6068 SWIGINTERN PyObject *_wrap_VectorHexas_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6069   PyObject *resultobj = 0;
6070   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6071   std::vector<Hex::Hexa * >::reverse_iterator result;
6072   void *argp1 = 0 ;
6073   int res1 = 0 ;
6074   PyObject * obj0 = 0 ;
6075
6076   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rbegin",&obj0)) SWIG_fail;
6077   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6078   if (!SWIG_IsOK(res1)) {
6079     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6080   }
6081   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6082   result = (arg1)->rbegin();
6083   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::reverse_iterator & >(result)),
6084     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6085   return resultobj;
6086 fail:
6087   return NULL;
6088 }
6089
6090
6091 SWIGINTERN PyObject *_wrap_VectorHexas_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6092   PyObject *resultobj = 0;
6093   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6094   std::vector<Hex::Hexa * >::const_reverse_iterator result;
6095   void *argp1 = 0 ;
6096   int res1 = 0 ;
6097   PyObject * obj0 = 0 ;
6098
6099   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rbegin",&obj0)) SWIG_fail;
6100   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6101   if (!SWIG_IsOK(res1)) {
6102     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6103   }
6104   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6105   result = ((std::vector<Hex::Hexa * > const *)arg1)->rbegin();
6106   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_reverse_iterator & >(result)),
6107     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6108   return resultobj;
6109 fail:
6110   return NULL;
6111 }
6112
6113
6114 SWIGINTERN PyObject *_wrap_VectorHexas_rbegin(PyObject *self, PyObject *args) {
6115   int argc;
6116   PyObject *argv[2];
6117   int ii;
6118
6119   if (!PyTuple_Check(args)) SWIG_fail;
6120   argc = PyObject_Length(args);
6121   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6122     argv[ii] = PyTuple_GET_ITEM(args,ii);
6123   }
6124   if (argc == 1) {
6125     int _v;
6126     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6127     _v = SWIG_CheckState(res);
6128     if (_v) {
6129       return _wrap_VectorHexas_rbegin__SWIG_0(self, args);
6130     }
6131   }
6132   if (argc == 1) {
6133     int _v;
6134     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6135     _v = SWIG_CheckState(res);
6136     if (_v) {
6137       return _wrap_VectorHexas_rbegin__SWIG_1(self, args);
6138     }
6139   }
6140
6141 fail:
6142   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
6143   return NULL;
6144 }
6145
6146
6147 SWIGINTERN PyObject *_wrap_VectorHexas_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6148   PyObject *resultobj = 0;
6149   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6150   std::vector<Hex::Hexa * >::reverse_iterator result;
6151   void *argp1 = 0 ;
6152   int res1 = 0 ;
6153   PyObject * obj0 = 0 ;
6154
6155   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rend",&obj0)) SWIG_fail;
6156   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6157   if (!SWIG_IsOK(res1)) {
6158     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rend" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6159   }
6160   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6161   result = (arg1)->rend();
6162   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::reverse_iterator & >(result)),
6163     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6164   return resultobj;
6165 fail:
6166   return NULL;
6167 }
6168
6169
6170 SWIGINTERN PyObject *_wrap_VectorHexas_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6171   PyObject *resultobj = 0;
6172   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6173   std::vector<Hex::Hexa * >::const_reverse_iterator result;
6174   void *argp1 = 0 ;
6175   int res1 = 0 ;
6176   PyObject * obj0 = 0 ;
6177
6178   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rend",&obj0)) SWIG_fail;
6179   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6180   if (!SWIG_IsOK(res1)) {
6181     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rend" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6182   }
6183   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6184   result = ((std::vector<Hex::Hexa * > const *)arg1)->rend();
6185   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::const_reverse_iterator & >(result)),
6186     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6187   return resultobj;
6188 fail:
6189   return NULL;
6190 }
6191
6192
6193 SWIGINTERN PyObject *_wrap_VectorHexas_rend(PyObject *self, PyObject *args) {
6194   int argc;
6195   PyObject *argv[2];
6196   int ii;
6197
6198   if (!PyTuple_Check(args)) SWIG_fail;
6199   argc = PyObject_Length(args);
6200   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6201     argv[ii] = PyTuple_GET_ITEM(args,ii);
6202   }
6203   if (argc == 1) {
6204     int _v;
6205     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6206     _v = SWIG_CheckState(res);
6207     if (_v) {
6208       return _wrap_VectorHexas_rend__SWIG_0(self, args);
6209     }
6210   }
6211   if (argc == 1) {
6212     int _v;
6213     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6214     _v = SWIG_CheckState(res);
6215     if (_v) {
6216       return _wrap_VectorHexas_rend__SWIG_1(self, args);
6217     }
6218   }
6219
6220 fail:
6221   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
6222   return NULL;
6223 }
6224
6225
6226 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6227   PyObject *resultobj = 0;
6228   std::vector<Hex::Hexa * >::size_type arg1 ;
6229   std::vector<Hex::Hexa * > *result = 0 ;
6230   size_t val1 ;
6231   int ecode1 = 0 ;
6232   PyObject * obj0 = 0 ;
6233
6234   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
6235   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
6236   if (!SWIG_IsOK(ecode1)) {
6237     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6238   }
6239   arg1 = static_cast< std::vector<Hex::Hexa * >::size_type >(val1);
6240   result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >(arg1);
6241   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
6242   return resultobj;
6243 fail:
6244   return NULL;
6245 }
6246
6247
6248 SWIGINTERN PyObject *_wrap_VectorHexas_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6249   PyObject *resultobj = 0;
6250   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6251   void *argp1 = 0 ;
6252   int res1 = 0 ;
6253   PyObject * obj0 = 0 ;
6254
6255   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop_back",&obj0)) SWIG_fail;
6256   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6257   if (!SWIG_IsOK(res1)) {
6258     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6259   }
6260   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6261   (arg1)->pop_back();
6262   resultobj = SWIG_Py_Void();
6263   return resultobj;
6264 fail:
6265   return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6270   PyObject *resultobj = 0;
6271   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6272   std::vector<Hex::Hexa * >::size_type arg2 ;
6273   void *argp1 = 0 ;
6274   int res1 = 0 ;
6275   size_t val2 ;
6276   int ecode2 = 0 ;
6277   PyObject * obj0 = 0 ;
6278   PyObject * obj1 = 0 ;
6279
6280   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_resize",&obj0,&obj1)) SWIG_fail;
6281   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6282   if (!SWIG_IsOK(res1)) {
6283     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6284   }
6285   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6286   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6287   if (!SWIG_IsOK(ecode2)) {
6288     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6289   }
6290   arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
6291   (arg1)->resize(arg2);
6292   resultobj = SWIG_Py_Void();
6293   return resultobj;
6294 fail:
6295   return NULL;
6296 }
6297
6298
6299 SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6300   PyObject *resultobj = 0;
6301   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6302   std::vector<Hex::Hexa * >::iterator arg2 ;
6303   std::vector<Hex::Hexa * >::iterator result;
6304   void *argp1 = 0 ;
6305   int res1 = 0 ;
6306   swig::PySwigIterator *iter2 = 0 ;
6307   int res2 ;
6308   PyObject * obj0 = 0 ;
6309   PyObject * obj1 = 0 ;
6310
6311   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_erase",&obj0,&obj1)) SWIG_fail;
6312   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6313   if (!SWIG_IsOK(res1)) {
6314     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6315   }
6316   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6317   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6318   if (!SWIG_IsOK(res2) || !iter2) {
6319     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6320   } else {
6321     swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
6322     if (iter_t) {
6323       arg2 = iter_t->get_current();
6324     } else {
6325       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6326     }
6327   }
6328   result = (arg1)->erase(arg2);
6329   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
6330     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6331   return resultobj;
6332 fail:
6333   return NULL;
6334 }
6335
6336
6337 SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6338   PyObject *resultobj = 0;
6339   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6340   std::vector<Hex::Hexa * >::iterator arg2 ;
6341   std::vector<Hex::Hexa * >::iterator arg3 ;
6342   std::vector<Hex::Hexa * >::iterator result;
6343   void *argp1 = 0 ;
6344   int res1 = 0 ;
6345   swig::PySwigIterator *iter2 = 0 ;
6346   int res2 ;
6347   swig::PySwigIterator *iter3 = 0 ;
6348   int res3 ;
6349   PyObject * obj0 = 0 ;
6350   PyObject * obj1 = 0 ;
6351   PyObject * obj2 = 0 ;
6352
6353   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_erase",&obj0,&obj1,&obj2)) SWIG_fail;
6354   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6355   if (!SWIG_IsOK(res1)) {
6356     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6357   }
6358   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6359   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6360   if (!SWIG_IsOK(res2) || !iter2) {
6361     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6362   } else {
6363     swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
6364     if (iter_t) {
6365       arg2 = iter_t->get_current();
6366     } else {
6367       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6368     }
6369   }
6370   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
6371   if (!SWIG_IsOK(res3) || !iter3) {
6372     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6373   } else {
6374     swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter3);
6375     if (iter_t) {
6376       arg3 = iter_t->get_current();
6377     } else {
6378       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6379     }
6380   }
6381   result = (arg1)->erase(arg2,arg3);
6382   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
6383     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6384   return resultobj;
6385 fail:
6386   return NULL;
6387 }
6388
6389
6390 SWIGINTERN PyObject *_wrap_VectorHexas_erase(PyObject *self, PyObject *args) {
6391   int argc;
6392   PyObject *argv[4];
6393   int ii;
6394
6395   if (!PyTuple_Check(args)) SWIG_fail;
6396   argc = PyObject_Length(args);
6397   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6398     argv[ii] = PyTuple_GET_ITEM(args,ii);
6399   }
6400   if (argc == 2) {
6401     int _v;
6402     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6403     _v = SWIG_CheckState(res);
6404     if (_v) {
6405       swig::PySwigIterator *iter = 0;
6406       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6407       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
6408       if (_v) {
6409         return _wrap_VectorHexas_erase__SWIG_0(self, args);
6410       }
6411     }
6412   }
6413   if (argc == 3) {
6414     int _v;
6415     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6416     _v = SWIG_CheckState(res);
6417     if (_v) {
6418       swig::PySwigIterator *iter = 0;
6419       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6420       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
6421       if (_v) {
6422         swig::PySwigIterator *iter = 0;
6423         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6424         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
6425         if (_v) {
6426           return _wrap_VectorHexas_erase__SWIG_1(self, args);
6427         }
6428       }
6429     }
6430   }
6431
6432 fail:
6433   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<Hex::Hexa * >::iterator)\n    erase(std::vector<Hex::Hexa * >::iterator,std::vector<Hex::Hexa * >::iterator)\n");
6434   return NULL;
6435 }
6436
6437
6438 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6439   PyObject *resultobj = 0;
6440   std::vector<Hex::Hexa * >::size_type arg1 ;
6441   std::vector<Hex::Hexa * >::value_type arg2 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6442   std::vector<Hex::Hexa * > *result = 0 ;
6443   size_t val1 ;
6444   int ecode1 = 0 ;
6445   void *argp2 = 0 ;
6446   int res2 = 0 ;
6447   PyObject * obj0 = 0 ;
6448   PyObject * obj1 = 0 ;
6449
6450   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorHexas",&obj0,&obj1)) SWIG_fail;
6451   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
6452   if (!SWIG_IsOK(ecode1)) {
6453     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6454   }
6455   arg1 = static_cast< std::vector<Hex::Hexa * >::size_type >(val1);
6456   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
6457   if (!SWIG_IsOK(res2)) {
6458     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorHexas" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6459   }
6460   arg2 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp2);
6461   result = (std::vector<Hex::Hexa * > *)new std::vector<Hex::Hexa * >(arg1,arg2);
6462   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
6463   return resultobj;
6464 fail:
6465   return NULL;
6466 }
6467
6468
6469 SWIGINTERN PyObject *_wrap_new_VectorHexas(PyObject *self, PyObject *args) {
6470   int argc;
6471   PyObject *argv[3];
6472   int ii;
6473
6474   if (!PyTuple_Check(args)) SWIG_fail;
6475   argc = PyObject_Length(args);
6476   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
6477     argv[ii] = PyTuple_GET_ITEM(args,ii);
6478   }
6479   if (argc == 0) {
6480     return _wrap_new_VectorHexas__SWIG_0(self, args);
6481   }
6482   if (argc == 1) {
6483     int _v;
6484     {
6485       int res = SWIG_AsVal_size_t(argv[0], NULL);
6486       _v = SWIG_CheckState(res);
6487     }
6488     if (_v) {
6489       return _wrap_new_VectorHexas__SWIG_2(self, args);
6490     }
6491   }
6492   if (argc == 1) {
6493     int _v;
6494     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6495     _v = SWIG_CheckState(res);
6496     if (_v) {
6497       return _wrap_new_VectorHexas__SWIG_1(self, args);
6498     }
6499   }
6500   if (argc == 2) {
6501     int _v;
6502     {
6503       int res = SWIG_AsVal_size_t(argv[0], NULL);
6504       _v = SWIG_CheckState(res);
6505     }
6506     if (_v) {
6507       void *vptr = 0;
6508       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
6509       _v = SWIG_CheckState(res);
6510       if (_v) {
6511         return _wrap_new_VectorHexas__SWIG_3(self, args);
6512       }
6513     }
6514   }
6515
6516 fail:
6517   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorHexas'.\n  Possible C/C++ prototypes are:\n    std::vector<(p.Hex::Hexa)>()\n    std::vector<(p.Hex::Hexa)>(std::vector<Hex::Hexa * > const &)\n    std::vector<(p.Hex::Hexa)>(std::vector<Hex::Hexa * >::size_type)\n    std::vector<(p.Hex::Hexa)>(std::vector<Hex::Hexa * >::size_type,std::vector<Hex::Hexa * >::value_type)\n");
6518   return NULL;
6519 }
6520
6521
6522 SWIGINTERN PyObject *_wrap_VectorHexas_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6523   PyObject *resultobj = 0;
6524   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6525   std::vector<Hex::Hexa * >::value_type arg2 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6526   void *argp1 = 0 ;
6527   int res1 = 0 ;
6528   void *argp2 = 0 ;
6529   int res2 = 0 ;
6530   PyObject * obj0 = 0 ;
6531   PyObject * obj1 = 0 ;
6532
6533   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_push_back",&obj0,&obj1)) SWIG_fail;
6534   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6535   if (!SWIG_IsOK(res1)) {
6536     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_push_back" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6537   }
6538   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6539   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
6540   if (!SWIG_IsOK(res2)) {
6541     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_push_back" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6542   }
6543   arg2 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp2);
6544   (arg1)->push_back(arg2);
6545   resultobj = SWIG_Py_Void();
6546   return resultobj;
6547 fail:
6548   return NULL;
6549 }
6550
6551
6552 SWIGINTERN PyObject *_wrap_VectorHexas_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6553   PyObject *resultobj = 0;
6554   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6555   std::vector<Hex::Hexa * >::value_type result;
6556   void *argp1 = 0 ;
6557   int res1 = 0 ;
6558   PyObject * obj0 = 0 ;
6559
6560   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_front",&obj0)) SWIG_fail;
6561   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6562   if (!SWIG_IsOK(res1)) {
6563     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_front" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6564   }
6565   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6566   result = (std::vector<Hex::Hexa * >::value_type)((std::vector<Hex::Hexa * > const *)arg1)->front();
6567   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
6568   return resultobj;
6569 fail:
6570   return NULL;
6571 }
6572
6573
6574 SWIGINTERN PyObject *_wrap_VectorHexas_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6575   PyObject *resultobj = 0;
6576   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6577   std::vector<Hex::Hexa * >::value_type result;
6578   void *argp1 = 0 ;
6579   int res1 = 0 ;
6580   PyObject * obj0 = 0 ;
6581
6582   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_back",&obj0)) SWIG_fail;
6583   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6584   if (!SWIG_IsOK(res1)) {
6585     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_back" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6586   }
6587   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6588   result = (std::vector<Hex::Hexa * >::value_type)((std::vector<Hex::Hexa * > const *)arg1)->back();
6589   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
6590   return resultobj;
6591 fail:
6592   return NULL;
6593 }
6594
6595
6596 SWIGINTERN PyObject *_wrap_VectorHexas_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6597   PyObject *resultobj = 0;
6598   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6599   std::vector<Hex::Hexa * >::size_type arg2 ;
6600   std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6601   void *argp1 = 0 ;
6602   int res1 = 0 ;
6603   size_t val2 ;
6604   int ecode2 = 0 ;
6605   void *argp3 = 0 ;
6606   int res3 = 0 ;
6607   PyObject * obj0 = 0 ;
6608   PyObject * obj1 = 0 ;
6609   PyObject * obj2 = 0 ;
6610
6611   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_assign",&obj0,&obj1,&obj2)) SWIG_fail;
6612   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6613   if (!SWIG_IsOK(res1)) {
6614     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_assign" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6615   }
6616   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6617   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6618   if (!SWIG_IsOK(ecode2)) {
6619     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_assign" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6620   }
6621   arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
6622   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
6623   if (!SWIG_IsOK(res3)) {
6624     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_assign" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6625   }
6626   arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
6627   (arg1)->assign(arg2,arg3);
6628   resultobj = SWIG_Py_Void();
6629   return resultobj;
6630 fail:
6631   return NULL;
6632 }
6633
6634
6635 SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6636   PyObject *resultobj = 0;
6637   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6638   std::vector<Hex::Hexa * >::size_type arg2 ;
6639   std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6640   void *argp1 = 0 ;
6641   int res1 = 0 ;
6642   size_t val2 ;
6643   int ecode2 = 0 ;
6644   void *argp3 = 0 ;
6645   int res3 = 0 ;
6646   PyObject * obj0 = 0 ;
6647   PyObject * obj1 = 0 ;
6648   PyObject * obj2 = 0 ;
6649
6650   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_resize",&obj0,&obj1,&obj2)) SWIG_fail;
6651   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6652   if (!SWIG_IsOK(res1)) {
6653     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6654   }
6655   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6656   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6657   if (!SWIG_IsOK(ecode2)) {
6658     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6659   }
6660   arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
6661   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
6662   if (!SWIG_IsOK(res3)) {
6663     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_resize" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6664   }
6665   arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
6666   (arg1)->resize(arg2,arg3);
6667   resultobj = SWIG_Py_Void();
6668   return resultobj;
6669 fail:
6670   return NULL;
6671 }
6672
6673
6674 SWIGINTERN PyObject *_wrap_VectorHexas_resize(PyObject *self, PyObject *args) {
6675   int argc;
6676   PyObject *argv[4];
6677   int ii;
6678
6679   if (!PyTuple_Check(args)) SWIG_fail;
6680   argc = PyObject_Length(args);
6681   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6682     argv[ii] = PyTuple_GET_ITEM(args,ii);
6683   }
6684   if (argc == 2) {
6685     int _v;
6686     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6687     _v = SWIG_CheckState(res);
6688     if (_v) {
6689       {
6690         int res = SWIG_AsVal_size_t(argv[1], NULL);
6691         _v = SWIG_CheckState(res);
6692       }
6693       if (_v) {
6694         return _wrap_VectorHexas_resize__SWIG_0(self, args);
6695       }
6696     }
6697   }
6698   if (argc == 3) {
6699     int _v;
6700     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6701     _v = SWIG_CheckState(res);
6702     if (_v) {
6703       {
6704         int res = SWIG_AsVal_size_t(argv[1], NULL);
6705         _v = SWIG_CheckState(res);
6706       }
6707       if (_v) {
6708         void *vptr = 0;
6709         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
6710         _v = SWIG_CheckState(res);
6711         if (_v) {
6712           return _wrap_VectorHexas_resize__SWIG_1(self, args);
6713         }
6714       }
6715     }
6716   }
6717
6718 fail:
6719   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<Hex::Hexa * >::size_type)\n    resize(std::vector<Hex::Hexa * >::size_type,std::vector<Hex::Hexa * >::value_type)\n");
6720   return NULL;
6721 }
6722
6723
6724 SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6725   PyObject *resultobj = 0;
6726   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6727   std::vector<Hex::Hexa * >::iterator arg2 ;
6728   std::vector<Hex::Hexa * >::value_type arg3 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6729   std::vector<Hex::Hexa * >::iterator result;
6730   void *argp1 = 0 ;
6731   int res1 = 0 ;
6732   swig::PySwigIterator *iter2 = 0 ;
6733   int res2 ;
6734   void *argp3 = 0 ;
6735   int res3 = 0 ;
6736   PyObject * obj0 = 0 ;
6737   PyObject * obj1 = 0 ;
6738   PyObject * obj2 = 0 ;
6739
6740   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_insert",&obj0,&obj1,&obj2)) SWIG_fail;
6741   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6742   if (!SWIG_IsOK(res1)) {
6743     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6744   }
6745   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6746   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6747   if (!SWIG_IsOK(res2) || !iter2) {
6748     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6749   } else {
6750     swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
6751     if (iter_t) {
6752       arg2 = iter_t->get_current();
6753     } else {
6754       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6755     }
6756   }
6757   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
6758   if (!SWIG_IsOK(res3)) {
6759     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6760   }
6761   arg3 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp3);
6762   result = (arg1)->insert(arg2,arg3);
6763   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Hexa * >::iterator & >(result)),
6764     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6765   return resultobj;
6766 fail:
6767   return NULL;
6768 }
6769
6770
6771 SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6772   PyObject *resultobj = 0;
6773   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6774   std::vector<Hex::Hexa * >::iterator arg2 ;
6775   std::vector<Hex::Hexa * >::size_type arg3 ;
6776   std::vector<Hex::Hexa * >::value_type arg4 = (std::vector<Hex::Hexa * >::value_type) 0 ;
6777   void *argp1 = 0 ;
6778   int res1 = 0 ;
6779   swig::PySwigIterator *iter2 = 0 ;
6780   int res2 ;
6781   size_t val3 ;
6782   int ecode3 = 0 ;
6783   void *argp4 = 0 ;
6784   int res4 = 0 ;
6785   PyObject * obj0 = 0 ;
6786   PyObject * obj1 = 0 ;
6787   PyObject * obj2 = 0 ;
6788   PyObject * obj3 = 0 ;
6789
6790   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6791   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6792   if (!SWIG_IsOK(res1)) {
6793     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6794   }
6795   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6796   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6797   if (!SWIG_IsOK(res2) || !iter2) {
6798     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6799   } else {
6800     swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter2);
6801     if (iter_t) {
6802       arg2 = iter_t->get_current();
6803     } else {
6804       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::iterator""'");
6805     }
6806   }
6807   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
6808   if (!SWIG_IsOK(ecode3)) {
6809     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6810   }
6811   arg3 = static_cast< std::vector<Hex::Hexa * >::size_type >(val3);
6812   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0 |  0 );
6813   if (!SWIG_IsOK(res4)) {
6814     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas_insert" "', argument " "4"" of type '" "std::vector<Hex::Hexa * >::value_type""'");
6815   }
6816   arg4 = reinterpret_cast< std::vector<Hex::Hexa * >::value_type >(argp4);
6817   (arg1)->insert(arg2,arg3,arg4);
6818   resultobj = SWIG_Py_Void();
6819   return resultobj;
6820 fail:
6821   return NULL;
6822 }
6823
6824
6825 SWIGINTERN PyObject *_wrap_VectorHexas_insert(PyObject *self, PyObject *args) {
6826   int argc;
6827   PyObject *argv[5];
6828   int ii;
6829
6830   if (!PyTuple_Check(args)) SWIG_fail;
6831   argc = PyObject_Length(args);
6832   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
6833     argv[ii] = PyTuple_GET_ITEM(args,ii);
6834   }
6835   if (argc == 3) {
6836     int _v;
6837     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6838     _v = SWIG_CheckState(res);
6839     if (_v) {
6840       swig::PySwigIterator *iter = 0;
6841       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6842       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
6843       if (_v) {
6844         void *vptr = 0;
6845         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
6846         _v = SWIG_CheckState(res);
6847         if (_v) {
6848           return _wrap_VectorHexas_insert__SWIG_0(self, args);
6849         }
6850       }
6851     }
6852   }
6853   if (argc == 4) {
6854     int _v;
6855     int res = swig::asptr(argv[0], (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > >**)(0));
6856     _v = SWIG_CheckState(res);
6857     if (_v) {
6858       swig::PySwigIterator *iter = 0;
6859       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6860       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Hexa * >::iterator > *>(iter) != 0));
6861       if (_v) {
6862         {
6863           int res = SWIG_AsVal_size_t(argv[2], NULL);
6864           _v = SWIG_CheckState(res);
6865         }
6866         if (_v) {
6867           void *vptr = 0;
6868           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0);
6869           _v = SWIG_CheckState(res);
6870           if (_v) {
6871             return _wrap_VectorHexas_insert__SWIG_1(self, args);
6872           }
6873         }
6874       }
6875     }
6876   }
6877
6878 fail:
6879   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorHexas_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<Hex::Hexa * >::iterator,std::vector<Hex::Hexa * >::value_type)\n    insert(std::vector<Hex::Hexa * >::iterator,std::vector<Hex::Hexa * >::size_type,std::vector<Hex::Hexa * >::value_type)\n");
6880   return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_VectorHexas_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6885   PyObject *resultobj = 0;
6886   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6887   std::vector<Hex::Hexa * >::size_type arg2 ;
6888   void *argp1 = 0 ;
6889   int res1 = 0 ;
6890   size_t val2 ;
6891   int ecode2 = 0 ;
6892   PyObject * obj0 = 0 ;
6893   PyObject * obj1 = 0 ;
6894
6895   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_reserve",&obj0,&obj1)) SWIG_fail;
6896   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6897   if (!SWIG_IsOK(res1)) {
6898     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_reserve" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6899   }
6900   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6901   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6902   if (!SWIG_IsOK(ecode2)) {
6903     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_reserve" "', argument " "2"" of type '" "std::vector<Hex::Hexa * >::size_type""'");
6904   }
6905   arg2 = static_cast< std::vector<Hex::Hexa * >::size_type >(val2);
6906   (arg1)->reserve(arg2);
6907   resultobj = SWIG_Py_Void();
6908   return resultobj;
6909 fail:
6910   return NULL;
6911 }
6912
6913
6914 SWIGINTERN PyObject *_wrap_VectorHexas_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6915   PyObject *resultobj = 0;
6916   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6917   std::vector<Hex::Hexa * >::size_type result;
6918   void *argp1 = 0 ;
6919   int res1 = 0 ;
6920   PyObject * obj0 = 0 ;
6921
6922   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_capacity",&obj0)) SWIG_fail;
6923   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0 |  0 );
6924   if (!SWIG_IsOK(res1)) {
6925     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_capacity" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > const *""'");
6926   }
6927   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6928   result = ((std::vector<Hex::Hexa * > const *)arg1)->capacity();
6929   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6930   return resultobj;
6931 fail:
6932   return NULL;
6933 }
6934
6935
6936 SWIGINTERN PyObject *_wrap_delete_VectorHexas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6937   PyObject *resultobj = 0;
6938   std::vector<Hex::Hexa * > *arg1 = (std::vector<Hex::Hexa * > *) 0 ;
6939   void *argp1 = 0 ;
6940   int res1 = 0 ;
6941   PyObject * obj0 = 0 ;
6942
6943   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorHexas",&obj0)) SWIG_fail;
6944   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_POINTER_DISOWN |  0 );
6945   if (!SWIG_IsOK(res1)) {
6946     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorHexas" "', argument " "1"" of type '" "std::vector<Hex::Hexa * > *""'");
6947   }
6948   arg1 = reinterpret_cast< std::vector<Hex::Hexa * > * >(argp1);
6949   delete arg1;
6950
6951   resultobj = SWIG_Py_Void();
6952   return resultobj;
6953 fail:
6954   return NULL;
6955 }
6956
6957
6958 SWIGINTERN PyObject *VectorHexas_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6959   PyObject *obj;
6960   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
6961   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, SWIG_NewClientData(obj));
6962   return SWIG_Py_Void();
6963 }
6964
6965 SWIGINTERN PyObject *_wrap_VectorQuads_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6966   PyObject *resultobj = 0;
6967   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
6968   PyObject **arg2 = (PyObject **) 0 ;
6969   swig::PySwigIterator *result = 0 ;
6970   void *argp1 = 0 ;
6971   int res1 = 0 ;
6972   PyObject * obj0 = 0 ;
6973
6974   arg2 = &obj0;
6975   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_iterator",&obj0)) SWIG_fail;
6976   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
6977   if (!SWIG_IsOK(res1)) {
6978     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_iterator" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
6979   }
6980   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
6981   result = (swig::PySwigIterator *)std_vector_Sl_Hex_Quad_Sm__Sg__iterator(arg1,arg2);
6982   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
6983   return resultobj;
6984 fail:
6985   return NULL;
6986 }
6987
6988
6989 SWIGINTERN PyObject *_wrap_VectorQuads___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6990   PyObject *resultobj = 0;
6991   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
6992   bool result;
6993   void *argp1 = 0 ;
6994   int res1 = 0 ;
6995   PyObject * obj0 = 0 ;
6996
6997   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___nonzero__",&obj0)) SWIG_fail;
6998   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
6999   if (!SWIG_IsOK(res1)) {
7000     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7001   }
7002   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7003   result = (bool)std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__((std::vector<Hex::Quad * > const *)arg1);
7004   resultobj = SWIG_From_bool(static_cast< bool >(result));
7005   return resultobj;
7006 fail:
7007   return NULL;
7008 }
7009
7010
7011 SWIGINTERN PyObject *_wrap_VectorQuads___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7012   PyObject *resultobj = 0;
7013   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7014   std::vector<Hex::Quad * >::size_type result;
7015   void *argp1 = 0 ;
7016   int res1 = 0 ;
7017   PyObject * obj0 = 0 ;
7018
7019   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___len__",&obj0)) SWIG_fail;
7020   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7021   if (!SWIG_IsOK(res1)) {
7022     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___len__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7023   }
7024   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7025   result = std_vector_Sl_Hex_Quad_Sm__Sg____len__((std::vector<Hex::Quad * > const *)arg1);
7026   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7027   return resultobj;
7028 fail:
7029   return NULL;
7030 }
7031
7032
7033 SWIGINTERN PyObject *_wrap_VectorQuads_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7034   PyObject *resultobj = 0;
7035   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7036   std::vector<Hex::Quad * >::value_type result;
7037   void *argp1 = 0 ;
7038   int res1 = 0 ;
7039   PyObject * obj0 = 0 ;
7040
7041   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop",&obj0)) SWIG_fail;
7042   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7043   if (!SWIG_IsOK(res1)) {
7044     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7045   }
7046   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7047   try {
7048     result = (std::vector<Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg__pop(arg1);
7049   }
7050   catch(std::out_of_range &_e) {
7051     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7052   }
7053
7054   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
7055   return resultobj;
7056 fail:
7057   return NULL;
7058 }
7059
7060
7061 SWIGINTERN PyObject *_wrap_VectorQuads___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7062   PyObject *resultobj = 0;
7063   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7064   std::vector<Hex::Quad * >::difference_type arg2 ;
7065   std::vector<Hex::Quad * >::difference_type arg3 ;
7066   std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *result = 0 ;
7067   void *argp1 = 0 ;
7068   int res1 = 0 ;
7069   ptrdiff_t val2 ;
7070   int ecode2 = 0 ;
7071   ptrdiff_t val3 ;
7072   int ecode3 = 0 ;
7073   PyObject * obj0 = 0 ;
7074   PyObject * obj1 = 0 ;
7075   PyObject * obj2 = 0 ;
7076
7077   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7078   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7079   if (!SWIG_IsOK(res1)) {
7080     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7081   }
7082   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7083   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7084   if (!SWIG_IsOK(ecode2)) {
7085     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7086   }
7087   arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7088   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7089   if (!SWIG_IsOK(ecode3)) {
7090     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7091   }
7092   arg3 = static_cast< std::vector<Hex::Quad * >::difference_type >(val3);
7093   try {
7094     result = (std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *)std_vector_Sl_Hex_Quad_Sm__Sg____getslice__(arg1,arg2,arg3);
7095   }
7096   catch(std::out_of_range &_e) {
7097     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7098   }
7099
7100   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_OWN |  0 );
7101   return resultobj;
7102 fail:
7103   return NULL;
7104 }
7105
7106
7107 SWIGINTERN PyObject *_wrap_VectorQuads___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7108   PyObject *resultobj = 0;
7109   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7110   std::vector<Hex::Quad * >::difference_type arg2 ;
7111   std::vector<Hex::Quad * >::difference_type arg3 ;
7112   std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *arg4 = 0 ;
7113   void *argp1 = 0 ;
7114   int res1 = 0 ;
7115   ptrdiff_t val2 ;
7116   int ecode2 = 0 ;
7117   ptrdiff_t val3 ;
7118   int ecode3 = 0 ;
7119   int res4 = SWIG_OLDOBJ ;
7120   PyObject * obj0 = 0 ;
7121   PyObject * obj1 = 0 ;
7122   PyObject * obj2 = 0 ;
7123   PyObject * obj3 = 0 ;
7124
7125   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7126   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7127   if (!SWIG_IsOK(res1)) {
7128     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7129   }
7130   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7131   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7132   if (!SWIG_IsOK(ecode2)) {
7133     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7134   }
7135   arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7136   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7137   if (!SWIG_IsOK(ecode3)) {
7138     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7139   }
7140   arg3 = static_cast< std::vector<Hex::Quad * >::difference_type >(val3);
7141   {
7142     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
7143     res4 = swig::asptr(obj3, &ptr);
7144     if (!SWIG_IsOK(res4)) {
7145       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > const &""'");
7146     }
7147     if (!ptr) {
7148       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 &""'");
7149     }
7150     arg4 = ptr;
7151   }
7152   try {
7153     std_vector_Sl_Hex_Quad_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > const &)*arg4);
7154   }
7155   catch(std::out_of_range &_e) {
7156     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7157   }
7158   catch(std::invalid_argument &_e) {
7159     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7160   }
7161
7162   resultobj = SWIG_Py_Void();
7163   if (SWIG_IsNewObj(res4)) delete arg4;
7164   return resultobj;
7165 fail:
7166   if (SWIG_IsNewObj(res4)) delete arg4;
7167   return NULL;
7168 }
7169
7170
7171 SWIGINTERN PyObject *_wrap_VectorQuads___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7172   PyObject *resultobj = 0;
7173   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7174   std::vector<Hex::Quad * >::difference_type arg2 ;
7175   std::vector<Hex::Quad * >::difference_type arg3 ;
7176   void *argp1 = 0 ;
7177   int res1 = 0 ;
7178   ptrdiff_t val2 ;
7179   int ecode2 = 0 ;
7180   ptrdiff_t val3 ;
7181   int ecode3 = 0 ;
7182   PyObject * obj0 = 0 ;
7183   PyObject * obj1 = 0 ;
7184   PyObject * obj2 = 0 ;
7185
7186   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7187   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7188   if (!SWIG_IsOK(res1)) {
7189     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7190   }
7191   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7192   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7193   if (!SWIG_IsOK(ecode2)) {
7194     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7195   }
7196   arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7197   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7198   if (!SWIG_IsOK(ecode3)) {
7199     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7200   }
7201   arg3 = static_cast< std::vector<Hex::Quad * >::difference_type >(val3);
7202   try {
7203     std_vector_Sl_Hex_Quad_Sm__Sg____delslice__(arg1,arg2,arg3);
7204   }
7205   catch(std::out_of_range &_e) {
7206     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7207   }
7208
7209   resultobj = SWIG_Py_Void();
7210   return resultobj;
7211 fail:
7212   return NULL;
7213 }
7214
7215
7216 SWIGINTERN PyObject *_wrap_VectorQuads___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7217   PyObject *resultobj = 0;
7218   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7219   std::vector<Hex::Quad * >::difference_type arg2 ;
7220   void *argp1 = 0 ;
7221   int res1 = 0 ;
7222   ptrdiff_t val2 ;
7223   int ecode2 = 0 ;
7224   PyObject * obj0 = 0 ;
7225   PyObject * obj1 = 0 ;
7226
7227   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___delitem__",&obj0,&obj1)) SWIG_fail;
7228   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7229   if (!SWIG_IsOK(res1)) {
7230     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7231   }
7232   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7233   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7234   if (!SWIG_IsOK(ecode2)) {
7235     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7236   }
7237   arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7238   try {
7239     std_vector_Sl_Hex_Quad_Sm__Sg____delitem__(arg1,arg2);
7240   }
7241   catch(std::out_of_range &_e) {
7242     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7243   }
7244
7245   resultobj = SWIG_Py_Void();
7246   return resultobj;
7247 fail:
7248   return NULL;
7249 }
7250
7251
7252 SWIGINTERN PyObject *_wrap_VectorQuads___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7253   PyObject *resultobj = 0;
7254   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7255   std::vector<Hex::Quad * >::difference_type arg2 ;
7256   std::vector<Hex::Quad * >::value_type result;
7257   void *argp1 = 0 ;
7258   int res1 = 0 ;
7259   ptrdiff_t val2 ;
7260   int ecode2 = 0 ;
7261   PyObject * obj0 = 0 ;
7262   PyObject * obj1 = 0 ;
7263
7264   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___getitem__",&obj0,&obj1)) SWIG_fail;
7265   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7266   if (!SWIG_IsOK(res1)) {
7267     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7268   }
7269   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7270   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7271   if (!SWIG_IsOK(ecode2)) {
7272     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7273   }
7274   arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7275   try {
7276     result = (std::vector<Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg____getitem__(arg1,arg2);
7277   }
7278   catch(std::out_of_range &_e) {
7279     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7280   }
7281
7282   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
7283   return resultobj;
7284 fail:
7285   return NULL;
7286 }
7287
7288
7289 SWIGINTERN PyObject *_wrap_VectorQuads___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7290   PyObject *resultobj = 0;
7291   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7292   std::vector<Hex::Quad * >::difference_type arg2 ;
7293   std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
7294   void *argp1 = 0 ;
7295   int res1 = 0 ;
7296   ptrdiff_t val2 ;
7297   int ecode2 = 0 ;
7298   void *argp3 = 0 ;
7299   int res3 = 0 ;
7300   PyObject * obj0 = 0 ;
7301   PyObject * obj1 = 0 ;
7302   PyObject * obj2 = 0 ;
7303
7304   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
7305   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7306   if (!SWIG_IsOK(res1)) {
7307     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7308   }
7309   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7310   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7311   if (!SWIG_IsOK(ecode2)) {
7312     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::difference_type""'");
7313   }
7314   arg2 = static_cast< std::vector<Hex::Quad * >::difference_type >(val2);
7315   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
7316   if (!SWIG_IsOK(res3)) {
7317     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
7318   }
7319   arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
7320   try {
7321     std_vector_Sl_Hex_Quad_Sm__Sg____setitem__(arg1,arg2,arg3);
7322   }
7323   catch(std::out_of_range &_e) {
7324     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7325   }
7326
7327   resultobj = SWIG_Py_Void();
7328   return resultobj;
7329 fail:
7330   return NULL;
7331 }
7332
7333
7334 SWIGINTERN PyObject *_wrap_VectorQuads_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7335   PyObject *resultobj = 0;
7336   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7337   std::vector<Hex::Quad * >::value_type arg2 = (std::vector<Hex::Quad * >::value_type) 0 ;
7338   void *argp1 = 0 ;
7339   int res1 = 0 ;
7340   void *argp2 = 0 ;
7341   int res2 = 0 ;
7342   PyObject * obj0 = 0 ;
7343   PyObject * obj1 = 0 ;
7344
7345   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_append",&obj0,&obj1)) SWIG_fail;
7346   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7347   if (!SWIG_IsOK(res1)) {
7348     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_append" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7349   }
7350   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7351   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
7352   if (!SWIG_IsOK(res2)) {
7353     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_append" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::value_type""'");
7354   }
7355   arg2 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp2);
7356   std_vector_Sl_Hex_Quad_Sm__Sg__append(arg1,arg2);
7357   resultobj = SWIG_Py_Void();
7358   return resultobj;
7359 fail:
7360   return NULL;
7361 }
7362
7363
7364 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7365   PyObject *resultobj = 0;
7366   std::vector<Hex::Quad * > *result = 0 ;
7367
7368   if (!PyArg_ParseTuple(args,(char *)":new_VectorQuads")) SWIG_fail;
7369   result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >();
7370   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
7371   return resultobj;
7372 fail:
7373   return NULL;
7374 }
7375
7376
7377 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7378   PyObject *resultobj = 0;
7379   std::vector<Hex::Quad * > *arg1 = 0 ;
7380   std::vector<Hex::Quad * > *result = 0 ;
7381   int res1 = SWIG_OLDOBJ ;
7382   PyObject * obj0 = 0 ;
7383
7384   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
7385   {
7386     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
7387     res1 = swig::asptr(obj0, &ptr);
7388     if (!SWIG_IsOK(res1)) {
7389       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const &""'");
7390     }
7391     if (!ptr) {
7392       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const &""'");
7393     }
7394     arg1 = ptr;
7395   }
7396   result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >((std::vector<Hex::Quad * > const &)*arg1);
7397   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
7398   if (SWIG_IsNewObj(res1)) delete arg1;
7399   return resultobj;
7400 fail:
7401   if (SWIG_IsNewObj(res1)) delete arg1;
7402   return NULL;
7403 }
7404
7405
7406 SWIGINTERN PyObject *_wrap_VectorQuads_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7407   PyObject *resultobj = 0;
7408   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7409   bool result;
7410   void *argp1 = 0 ;
7411   int res1 = 0 ;
7412   PyObject * obj0 = 0 ;
7413
7414   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_empty",&obj0)) SWIG_fail;
7415   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7416   if (!SWIG_IsOK(res1)) {
7417     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_empty" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7418   }
7419   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7420   result = (bool)((std::vector<Hex::Quad * > const *)arg1)->empty();
7421   resultobj = SWIG_From_bool(static_cast< bool >(result));
7422   return resultobj;
7423 fail:
7424   return NULL;
7425 }
7426
7427
7428 SWIGINTERN PyObject *_wrap_VectorQuads_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7429   PyObject *resultobj = 0;
7430   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7431   std::vector<Hex::Quad * >::size_type result;
7432   void *argp1 = 0 ;
7433   int res1 = 0 ;
7434   PyObject * obj0 = 0 ;
7435
7436   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_size",&obj0)) SWIG_fail;
7437   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7438   if (!SWIG_IsOK(res1)) {
7439     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_size" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7440   }
7441   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7442   result = ((std::vector<Hex::Quad * > const *)arg1)->size();
7443   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7444   return resultobj;
7445 fail:
7446   return NULL;
7447 }
7448
7449
7450 SWIGINTERN PyObject *_wrap_VectorQuads_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7451   PyObject *resultobj = 0;
7452   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7453   void *argp1 = 0 ;
7454   int res1 = 0 ;
7455   PyObject * obj0 = 0 ;
7456
7457   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_clear",&obj0)) SWIG_fail;
7458   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7459   if (!SWIG_IsOK(res1)) {
7460     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_clear" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7461   }
7462   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7463   (arg1)->clear();
7464   resultobj = SWIG_Py_Void();
7465   return resultobj;
7466 fail:
7467   return NULL;
7468 }
7469
7470
7471 SWIGINTERN PyObject *_wrap_VectorQuads_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7472   PyObject *resultobj = 0;
7473   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7474   std::vector<Hex::Quad * > *arg2 = 0 ;
7475   void *argp1 = 0 ;
7476   int res1 = 0 ;
7477   void *argp2 = 0 ;
7478   int res2 = 0 ;
7479   PyObject * obj0 = 0 ;
7480   PyObject * obj1 = 0 ;
7481
7482   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_swap",&obj0,&obj1)) SWIG_fail;
7483   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7484   if (!SWIG_IsOK(res1)) {
7485     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_swap" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7486   }
7487   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7488   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t,  0 );
7489   if (!SWIG_IsOK(res2)) {
7490     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector<Hex::Quad * > &""'");
7491   }
7492   if (!argp2) {
7493     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector<Hex::Quad * > &""'");
7494   }
7495   arg2 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp2);
7496   (arg1)->swap(*arg2);
7497   resultobj = SWIG_Py_Void();
7498   return resultobj;
7499 fail:
7500   return NULL;
7501 }
7502
7503
7504 SWIGINTERN PyObject *_wrap_VectorQuads_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7505   PyObject *resultobj = 0;
7506   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7507   SwigValueWrapper<std::allocator<Hex::Quad * > > result;
7508   void *argp1 = 0 ;
7509   int res1 = 0 ;
7510   PyObject * obj0 = 0 ;
7511
7512   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_get_allocator",&obj0)) SWIG_fail;
7513   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7514   if (!SWIG_IsOK(res1)) {
7515     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7516   }
7517   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7518   result = ((std::vector<Hex::Quad * > const *)arg1)->get_allocator();
7519   resultobj = SWIG_NewPointerObj((new std::vector<Hex::Quad * >::allocator_type(static_cast< const std::vector<Hex::Quad * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
7520   return resultobj;
7521 fail:
7522   return NULL;
7523 }
7524
7525
7526 SWIGINTERN PyObject *_wrap_VectorQuads_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7527   PyObject *resultobj = 0;
7528   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7529   std::vector<Hex::Quad * >::iterator result;
7530   void *argp1 = 0 ;
7531   int res1 = 0 ;
7532   PyObject * obj0 = 0 ;
7533
7534   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_begin",&obj0)) SWIG_fail;
7535   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7536   if (!SWIG_IsOK(res1)) {
7537     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_begin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7538   }
7539   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7540   result = (arg1)->begin();
7541   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
7542     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7543   return resultobj;
7544 fail:
7545   return NULL;
7546 }
7547
7548
7549 SWIGINTERN PyObject *_wrap_VectorQuads_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7550   PyObject *resultobj = 0;
7551   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7552   std::vector<Hex::Quad * >::const_iterator result;
7553   void *argp1 = 0 ;
7554   int res1 = 0 ;
7555   PyObject * obj0 = 0 ;
7556
7557   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_begin",&obj0)) SWIG_fail;
7558   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7559   if (!SWIG_IsOK(res1)) {
7560     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_begin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7561   }
7562   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7563   result = ((std::vector<Hex::Quad * > const *)arg1)->begin();
7564   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_iterator & >(result)),
7565     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7566   return resultobj;
7567 fail:
7568   return NULL;
7569 }
7570
7571
7572 SWIGINTERN PyObject *_wrap_VectorQuads_begin(PyObject *self, PyObject *args) {
7573   int argc;
7574   PyObject *argv[2];
7575   int ii;
7576
7577   if (!PyTuple_Check(args)) SWIG_fail;
7578   argc = PyObject_Length(args);
7579   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
7580     argv[ii] = PyTuple_GET_ITEM(args,ii);
7581   }
7582   if (argc == 1) {
7583     int _v;
7584     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7585     _v = SWIG_CheckState(res);
7586     if (_v) {
7587       return _wrap_VectorQuads_begin__SWIG_0(self, args);
7588     }
7589   }
7590   if (argc == 1) {
7591     int _v;
7592     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7593     _v = SWIG_CheckState(res);
7594     if (_v) {
7595       return _wrap_VectorQuads_begin__SWIG_1(self, args);
7596     }
7597   }
7598
7599 fail:
7600   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
7601   return NULL;
7602 }
7603
7604
7605 SWIGINTERN PyObject *_wrap_VectorQuads_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7606   PyObject *resultobj = 0;
7607   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7608   std::vector<Hex::Quad * >::iterator result;
7609   void *argp1 = 0 ;
7610   int res1 = 0 ;
7611   PyObject * obj0 = 0 ;
7612
7613   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_end",&obj0)) SWIG_fail;
7614   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7615   if (!SWIG_IsOK(res1)) {
7616     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_end" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7617   }
7618   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7619   result = (arg1)->end();
7620   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
7621     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7622   return resultobj;
7623 fail:
7624   return NULL;
7625 }
7626
7627
7628 SWIGINTERN PyObject *_wrap_VectorQuads_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7629   PyObject *resultobj = 0;
7630   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7631   std::vector<Hex::Quad * >::const_iterator result;
7632   void *argp1 = 0 ;
7633   int res1 = 0 ;
7634   PyObject * obj0 = 0 ;
7635
7636   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_end",&obj0)) SWIG_fail;
7637   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7638   if (!SWIG_IsOK(res1)) {
7639     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_end" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7640   }
7641   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7642   result = ((std::vector<Hex::Quad * > const *)arg1)->end();
7643   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_iterator & >(result)),
7644     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7645   return resultobj;
7646 fail:
7647   return NULL;
7648 }
7649
7650
7651 SWIGINTERN PyObject *_wrap_VectorQuads_end(PyObject *self, PyObject *args) {
7652   int argc;
7653   PyObject *argv[2];
7654   int ii;
7655
7656   if (!PyTuple_Check(args)) SWIG_fail;
7657   argc = PyObject_Length(args);
7658   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
7659     argv[ii] = PyTuple_GET_ITEM(args,ii);
7660   }
7661   if (argc == 1) {
7662     int _v;
7663     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7664     _v = SWIG_CheckState(res);
7665     if (_v) {
7666       return _wrap_VectorQuads_end__SWIG_0(self, args);
7667     }
7668   }
7669   if (argc == 1) {
7670     int _v;
7671     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7672     _v = SWIG_CheckState(res);
7673     if (_v) {
7674       return _wrap_VectorQuads_end__SWIG_1(self, args);
7675     }
7676   }
7677
7678 fail:
7679   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
7680   return NULL;
7681 }
7682
7683
7684 SWIGINTERN PyObject *_wrap_VectorQuads_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7685   PyObject *resultobj = 0;
7686   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7687   std::vector<Hex::Quad * >::reverse_iterator result;
7688   void *argp1 = 0 ;
7689   int res1 = 0 ;
7690   PyObject * obj0 = 0 ;
7691
7692   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rbegin",&obj0)) SWIG_fail;
7693   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7694   if (!SWIG_IsOK(res1)) {
7695     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7696   }
7697   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7698   result = (arg1)->rbegin();
7699   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::reverse_iterator & >(result)),
7700     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7701   return resultobj;
7702 fail:
7703   return NULL;
7704 }
7705
7706
7707 SWIGINTERN PyObject *_wrap_VectorQuads_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7708   PyObject *resultobj = 0;
7709   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7710   std::vector<Hex::Quad * >::const_reverse_iterator result;
7711   void *argp1 = 0 ;
7712   int res1 = 0 ;
7713   PyObject * obj0 = 0 ;
7714
7715   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rbegin",&obj0)) SWIG_fail;
7716   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7717   if (!SWIG_IsOK(res1)) {
7718     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7719   }
7720   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7721   result = ((std::vector<Hex::Quad * > const *)arg1)->rbegin();
7722   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_reverse_iterator & >(result)),
7723     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7724   return resultobj;
7725 fail:
7726   return NULL;
7727 }
7728
7729
7730 SWIGINTERN PyObject *_wrap_VectorQuads_rbegin(PyObject *self, PyObject *args) {
7731   int argc;
7732   PyObject *argv[2];
7733   int ii;
7734
7735   if (!PyTuple_Check(args)) SWIG_fail;
7736   argc = PyObject_Length(args);
7737   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
7738     argv[ii] = PyTuple_GET_ITEM(args,ii);
7739   }
7740   if (argc == 1) {
7741     int _v;
7742     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7743     _v = SWIG_CheckState(res);
7744     if (_v) {
7745       return _wrap_VectorQuads_rbegin__SWIG_0(self, args);
7746     }
7747   }
7748   if (argc == 1) {
7749     int _v;
7750     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7751     _v = SWIG_CheckState(res);
7752     if (_v) {
7753       return _wrap_VectorQuads_rbegin__SWIG_1(self, args);
7754     }
7755   }
7756
7757 fail:
7758   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
7759   return NULL;
7760 }
7761
7762
7763 SWIGINTERN PyObject *_wrap_VectorQuads_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7764   PyObject *resultobj = 0;
7765   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7766   std::vector<Hex::Quad * >::reverse_iterator result;
7767   void *argp1 = 0 ;
7768   int res1 = 0 ;
7769   PyObject * obj0 = 0 ;
7770
7771   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rend",&obj0)) SWIG_fail;
7772   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7773   if (!SWIG_IsOK(res1)) {
7774     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rend" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7775   }
7776   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7777   result = (arg1)->rend();
7778   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::reverse_iterator & >(result)),
7779     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7780   return resultobj;
7781 fail:
7782   return NULL;
7783 }
7784
7785
7786 SWIGINTERN PyObject *_wrap_VectorQuads_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7787   PyObject *resultobj = 0;
7788   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7789   std::vector<Hex::Quad * >::const_reverse_iterator result;
7790   void *argp1 = 0 ;
7791   int res1 = 0 ;
7792   PyObject * obj0 = 0 ;
7793
7794   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rend",&obj0)) SWIG_fail;
7795   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7796   if (!SWIG_IsOK(res1)) {
7797     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rend" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
7798   }
7799   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7800   result = ((std::vector<Hex::Quad * > const *)arg1)->rend();
7801   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::const_reverse_iterator & >(result)),
7802     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7803   return resultobj;
7804 fail:
7805   return NULL;
7806 }
7807
7808
7809 SWIGINTERN PyObject *_wrap_VectorQuads_rend(PyObject *self, PyObject *args) {
7810   int argc;
7811   PyObject *argv[2];
7812   int ii;
7813
7814   if (!PyTuple_Check(args)) SWIG_fail;
7815   argc = PyObject_Length(args);
7816   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
7817     argv[ii] = PyTuple_GET_ITEM(args,ii);
7818   }
7819   if (argc == 1) {
7820     int _v;
7821     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7822     _v = SWIG_CheckState(res);
7823     if (_v) {
7824       return _wrap_VectorQuads_rend__SWIG_0(self, args);
7825     }
7826   }
7827   if (argc == 1) {
7828     int _v;
7829     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
7830     _v = SWIG_CheckState(res);
7831     if (_v) {
7832       return _wrap_VectorQuads_rend__SWIG_1(self, args);
7833     }
7834   }
7835
7836 fail:
7837   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
7838   return NULL;
7839 }
7840
7841
7842 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7843   PyObject *resultobj = 0;
7844   std::vector<Hex::Quad * >::size_type arg1 ;
7845   std::vector<Hex::Quad * > *result = 0 ;
7846   size_t val1 ;
7847   int ecode1 = 0 ;
7848   PyObject * obj0 = 0 ;
7849
7850   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
7851   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
7852   if (!SWIG_IsOK(ecode1)) {
7853     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * >::size_type""'");
7854   }
7855   arg1 = static_cast< std::vector<Hex::Quad * >::size_type >(val1);
7856   result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >(arg1);
7857   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
7858   return resultobj;
7859 fail:
7860   return NULL;
7861 }
7862
7863
7864 SWIGINTERN PyObject *_wrap_VectorQuads_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7865   PyObject *resultobj = 0;
7866   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7867   void *argp1 = 0 ;
7868   int res1 = 0 ;
7869   PyObject * obj0 = 0 ;
7870
7871   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop_back",&obj0)) SWIG_fail;
7872   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7873   if (!SWIG_IsOK(res1)) {
7874     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7875   }
7876   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7877   (arg1)->pop_back();
7878   resultobj = SWIG_Py_Void();
7879   return resultobj;
7880 fail:
7881   return NULL;
7882 }
7883
7884
7885 SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7886   PyObject *resultobj = 0;
7887   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7888   std::vector<Hex::Quad * >::size_type arg2 ;
7889   void *argp1 = 0 ;
7890   int res1 = 0 ;
7891   size_t val2 ;
7892   int ecode2 = 0 ;
7893   PyObject * obj0 = 0 ;
7894   PyObject * obj1 = 0 ;
7895
7896   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_resize",&obj0,&obj1)) SWIG_fail;
7897   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7898   if (!SWIG_IsOK(res1)) {
7899     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7900   }
7901   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7902   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7903   if (!SWIG_IsOK(ecode2)) {
7904     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
7905   }
7906   arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
7907   (arg1)->resize(arg2);
7908   resultobj = SWIG_Py_Void();
7909   return resultobj;
7910 fail:
7911   return NULL;
7912 }
7913
7914
7915 SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916   PyObject *resultobj = 0;
7917   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7918   std::vector<Hex::Quad * >::iterator arg2 ;
7919   std::vector<Hex::Quad * >::iterator result;
7920   void *argp1 = 0 ;
7921   int res1 = 0 ;
7922   swig::PySwigIterator *iter2 = 0 ;
7923   int res2 ;
7924   PyObject * obj0 = 0 ;
7925   PyObject * obj1 = 0 ;
7926
7927   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_erase",&obj0,&obj1)) SWIG_fail;
7928   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7929   if (!SWIG_IsOK(res1)) {
7930     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7931   }
7932   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7933   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
7934   if (!SWIG_IsOK(res2) || !iter2) {
7935     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7936   } else {
7937     swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
7938     if (iter_t) {
7939       arg2 = iter_t->get_current();
7940     } else {
7941       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7942     }
7943   }
7944   result = (arg1)->erase(arg2);
7945   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
7946     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7947   return resultobj;
7948 fail:
7949   return NULL;
7950 }
7951
7952
7953 SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7954   PyObject *resultobj = 0;
7955   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
7956   std::vector<Hex::Quad * >::iterator arg2 ;
7957   std::vector<Hex::Quad * >::iterator arg3 ;
7958   std::vector<Hex::Quad * >::iterator result;
7959   void *argp1 = 0 ;
7960   int res1 = 0 ;
7961   swig::PySwigIterator *iter2 = 0 ;
7962   int res2 ;
7963   swig::PySwigIterator *iter3 = 0 ;
7964   int res3 ;
7965   PyObject * obj0 = 0 ;
7966   PyObject * obj1 = 0 ;
7967   PyObject * obj2 = 0 ;
7968
7969   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_erase",&obj0,&obj1,&obj2)) SWIG_fail;
7970   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
7971   if (!SWIG_IsOK(res1)) {
7972     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
7973   }
7974   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
7975   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
7976   if (!SWIG_IsOK(res2) || !iter2) {
7977     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7978   } else {
7979     swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
7980     if (iter_t) {
7981       arg2 = iter_t->get_current();
7982     } else {
7983       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7984     }
7985   }
7986   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
7987   if (!SWIG_IsOK(res3) || !iter3) {
7988     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7989   } else {
7990     swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter3);
7991     if (iter_t) {
7992       arg3 = iter_t->get_current();
7993     } else {
7994       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::iterator""'");
7995     }
7996   }
7997   result = (arg1)->erase(arg2,arg3);
7998   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
7999     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8000   return resultobj;
8001 fail:
8002   return NULL;
8003 }
8004
8005
8006 SWIGINTERN PyObject *_wrap_VectorQuads_erase(PyObject *self, PyObject *args) {
8007   int argc;
8008   PyObject *argv[4];
8009   int ii;
8010
8011   if (!PyTuple_Check(args)) SWIG_fail;
8012   argc = PyObject_Length(args);
8013   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8014     argv[ii] = PyTuple_GET_ITEM(args,ii);
8015   }
8016   if (argc == 2) {
8017     int _v;
8018     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8019     _v = SWIG_CheckState(res);
8020     if (_v) {
8021       swig::PySwigIterator *iter = 0;
8022       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8023       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
8024       if (_v) {
8025         return _wrap_VectorQuads_erase__SWIG_0(self, args);
8026       }
8027     }
8028   }
8029   if (argc == 3) {
8030     int _v;
8031     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8032     _v = SWIG_CheckState(res);
8033     if (_v) {
8034       swig::PySwigIterator *iter = 0;
8035       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8036       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
8037       if (_v) {
8038         swig::PySwigIterator *iter = 0;
8039         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8040         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
8041         if (_v) {
8042           return _wrap_VectorQuads_erase__SWIG_1(self, args);
8043         }
8044       }
8045     }
8046   }
8047
8048 fail:
8049   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<Hex::Quad * >::iterator)\n    erase(std::vector<Hex::Quad * >::iterator,std::vector<Hex::Quad * >::iterator)\n");
8050   return NULL;
8051 }
8052
8053
8054 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8055   PyObject *resultobj = 0;
8056   std::vector<Hex::Quad * >::size_type arg1 ;
8057   std::vector<Hex::Quad * >::value_type arg2 = (std::vector<Hex::Quad * >::value_type) 0 ;
8058   std::vector<Hex::Quad * > *result = 0 ;
8059   size_t val1 ;
8060   int ecode1 = 0 ;
8061   void *argp2 = 0 ;
8062   int res2 = 0 ;
8063   PyObject * obj0 = 0 ;
8064   PyObject * obj1 = 0 ;
8065
8066   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorQuads",&obj0,&obj1)) SWIG_fail;
8067   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
8068   if (!SWIG_IsOK(ecode1)) {
8069     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * >::size_type""'");
8070   }
8071   arg1 = static_cast< std::vector<Hex::Quad * >::size_type >(val1);
8072   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
8073   if (!SWIG_IsOK(res2)) {
8074     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorQuads" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8075   }
8076   arg2 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp2);
8077   result = (std::vector<Hex::Quad * > *)new std::vector<Hex::Quad * >(arg1,arg2);
8078   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
8079   return resultobj;
8080 fail:
8081   return NULL;
8082 }
8083
8084
8085 SWIGINTERN PyObject *_wrap_new_VectorQuads(PyObject *self, PyObject *args) {
8086   int argc;
8087   PyObject *argv[3];
8088   int ii;
8089
8090   if (!PyTuple_Check(args)) SWIG_fail;
8091   argc = PyObject_Length(args);
8092   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
8093     argv[ii] = PyTuple_GET_ITEM(args,ii);
8094   }
8095   if (argc == 0) {
8096     return _wrap_new_VectorQuads__SWIG_0(self, args);
8097   }
8098   if (argc == 1) {
8099     int _v;
8100     {
8101       int res = SWIG_AsVal_size_t(argv[0], NULL);
8102       _v = SWIG_CheckState(res);
8103     }
8104     if (_v) {
8105       return _wrap_new_VectorQuads__SWIG_2(self, args);
8106     }
8107   }
8108   if (argc == 1) {
8109     int _v;
8110     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8111     _v = SWIG_CheckState(res);
8112     if (_v) {
8113       return _wrap_new_VectorQuads__SWIG_1(self, args);
8114     }
8115   }
8116   if (argc == 2) {
8117     int _v;
8118     {
8119       int res = SWIG_AsVal_size_t(argv[0], NULL);
8120       _v = SWIG_CheckState(res);
8121     }
8122     if (_v) {
8123       void *vptr = 0;
8124       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
8125       _v = SWIG_CheckState(res);
8126       if (_v) {
8127         return _wrap_new_VectorQuads__SWIG_3(self, args);
8128       }
8129     }
8130   }
8131
8132 fail:
8133   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorQuads'.\n  Possible C/C++ prototypes are:\n    std::vector<(p.Hex::Quad)>()\n    std::vector<(p.Hex::Quad)>(std::vector<Hex::Quad * > const &)\n    std::vector<(p.Hex::Quad)>(std::vector<Hex::Quad * >::size_type)\n    std::vector<(p.Hex::Quad)>(std::vector<Hex::Quad * >::size_type,std::vector<Hex::Quad * >::value_type)\n");
8134   return NULL;
8135 }
8136
8137
8138 SWIGINTERN PyObject *_wrap_VectorQuads_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8139   PyObject *resultobj = 0;
8140   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8141   std::vector<Hex::Quad * >::value_type arg2 = (std::vector<Hex::Quad * >::value_type) 0 ;
8142   void *argp1 = 0 ;
8143   int res1 = 0 ;
8144   void *argp2 = 0 ;
8145   int res2 = 0 ;
8146   PyObject * obj0 = 0 ;
8147   PyObject * obj1 = 0 ;
8148
8149   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_push_back",&obj0,&obj1)) SWIG_fail;
8150   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
8151   if (!SWIG_IsOK(res1)) {
8152     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_push_back" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8153   }
8154   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8155   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
8156   if (!SWIG_IsOK(res2)) {
8157     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_push_back" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8158   }
8159   arg2 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp2);
8160   (arg1)->push_back(arg2);
8161   resultobj = SWIG_Py_Void();
8162   return resultobj;
8163 fail:
8164   return NULL;
8165 }
8166
8167
8168 SWIGINTERN PyObject *_wrap_VectorQuads_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8169   PyObject *resultobj = 0;
8170   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8171   std::vector<Hex::Quad * >::value_type result;
8172   void *argp1 = 0 ;
8173   int res1 = 0 ;
8174   PyObject * obj0 = 0 ;
8175
8176   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_front",&obj0)) SWIG_fail;
8177   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
8178   if (!SWIG_IsOK(res1)) {
8179     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_front" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
8180   }
8181   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8182   result = (std::vector<Hex::Quad * >::value_type)((std::vector<Hex::Quad * > const *)arg1)->front();
8183   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
8184   return resultobj;
8185 fail:
8186   return NULL;
8187 }
8188
8189
8190 SWIGINTERN PyObject *_wrap_VectorQuads_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8191   PyObject *resultobj = 0;
8192   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8193   std::vector<Hex::Quad * >::value_type result;
8194   void *argp1 = 0 ;
8195   int res1 = 0 ;
8196   PyObject * obj0 = 0 ;
8197
8198   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_back",&obj0)) SWIG_fail;
8199   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
8200   if (!SWIG_IsOK(res1)) {
8201     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_back" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
8202   }
8203   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8204   result = (std::vector<Hex::Quad * >::value_type)((std::vector<Hex::Quad * > const *)arg1)->back();
8205   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
8206   return resultobj;
8207 fail:
8208   return NULL;
8209 }
8210
8211
8212 SWIGINTERN PyObject *_wrap_VectorQuads_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8213   PyObject *resultobj = 0;
8214   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8215   std::vector<Hex::Quad * >::size_type arg2 ;
8216   std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
8217   void *argp1 = 0 ;
8218   int res1 = 0 ;
8219   size_t val2 ;
8220   int ecode2 = 0 ;
8221   void *argp3 = 0 ;
8222   int res3 = 0 ;
8223   PyObject * obj0 = 0 ;
8224   PyObject * obj1 = 0 ;
8225   PyObject * obj2 = 0 ;
8226
8227   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_assign",&obj0,&obj1,&obj2)) SWIG_fail;
8228   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
8229   if (!SWIG_IsOK(res1)) {
8230     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_assign" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8231   }
8232   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8233   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8234   if (!SWIG_IsOK(ecode2)) {
8235     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_assign" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
8236   }
8237   arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
8238   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
8239   if (!SWIG_IsOK(res3)) {
8240     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_assign" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8241   }
8242   arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
8243   (arg1)->assign(arg2,arg3);
8244   resultobj = SWIG_Py_Void();
8245   return resultobj;
8246 fail:
8247   return NULL;
8248 }
8249
8250
8251 SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8252   PyObject *resultobj = 0;
8253   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8254   std::vector<Hex::Quad * >::size_type arg2 ;
8255   std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
8256   void *argp1 = 0 ;
8257   int res1 = 0 ;
8258   size_t val2 ;
8259   int ecode2 = 0 ;
8260   void *argp3 = 0 ;
8261   int res3 = 0 ;
8262   PyObject * obj0 = 0 ;
8263   PyObject * obj1 = 0 ;
8264   PyObject * obj2 = 0 ;
8265
8266   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_resize",&obj0,&obj1,&obj2)) SWIG_fail;
8267   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
8268   if (!SWIG_IsOK(res1)) {
8269     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8270   }
8271   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8272   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8273   if (!SWIG_IsOK(ecode2)) {
8274     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
8275   }
8276   arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
8277   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
8278   if (!SWIG_IsOK(res3)) {
8279     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_resize" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8280   }
8281   arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
8282   (arg1)->resize(arg2,arg3);
8283   resultobj = SWIG_Py_Void();
8284   return resultobj;
8285 fail:
8286   return NULL;
8287 }
8288
8289
8290 SWIGINTERN PyObject *_wrap_VectorQuads_resize(PyObject *self, PyObject *args) {
8291   int argc;
8292   PyObject *argv[4];
8293   int ii;
8294
8295   if (!PyTuple_Check(args)) SWIG_fail;
8296   argc = PyObject_Length(args);
8297   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8298     argv[ii] = PyTuple_GET_ITEM(args,ii);
8299   }
8300   if (argc == 2) {
8301     int _v;
8302     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8303     _v = SWIG_CheckState(res);
8304     if (_v) {
8305       {
8306         int res = SWIG_AsVal_size_t(argv[1], NULL);
8307         _v = SWIG_CheckState(res);
8308       }
8309       if (_v) {
8310         return _wrap_VectorQuads_resize__SWIG_0(self, args);
8311       }
8312     }
8313   }
8314   if (argc == 3) {
8315     int _v;
8316     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8317     _v = SWIG_CheckState(res);
8318     if (_v) {
8319       {
8320         int res = SWIG_AsVal_size_t(argv[1], NULL);
8321         _v = SWIG_CheckState(res);
8322       }
8323       if (_v) {
8324         void *vptr = 0;
8325         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
8326         _v = SWIG_CheckState(res);
8327         if (_v) {
8328           return _wrap_VectorQuads_resize__SWIG_1(self, args);
8329         }
8330       }
8331     }
8332   }
8333
8334 fail:
8335   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<Hex::Quad * >::size_type)\n    resize(std::vector<Hex::Quad * >::size_type,std::vector<Hex::Quad * >::value_type)\n");
8336   return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8341   PyObject *resultobj = 0;
8342   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8343   std::vector<Hex::Quad * >::iterator arg2 ;
8344   std::vector<Hex::Quad * >::value_type arg3 = (std::vector<Hex::Quad * >::value_type) 0 ;
8345   std::vector<Hex::Quad * >::iterator result;
8346   void *argp1 = 0 ;
8347   int res1 = 0 ;
8348   swig::PySwigIterator *iter2 = 0 ;
8349   int res2 ;
8350   void *argp3 = 0 ;
8351   int res3 = 0 ;
8352   PyObject * obj0 = 0 ;
8353   PyObject * obj1 = 0 ;
8354   PyObject * obj2 = 0 ;
8355
8356   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_insert",&obj0,&obj1,&obj2)) SWIG_fail;
8357   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
8358   if (!SWIG_IsOK(res1)) {
8359     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8360   }
8361   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8362   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
8363   if (!SWIG_IsOK(res2) || !iter2) {
8364     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
8365   } else {
8366     swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
8367     if (iter_t) {
8368       arg2 = iter_t->get_current();
8369     } else {
8370       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
8371     }
8372   }
8373   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
8374   if (!SWIG_IsOK(res3)) {
8375     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8376   }
8377   arg3 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp3);
8378   result = (arg1)->insert(arg2,arg3);
8379   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Quad * >::iterator & >(result)),
8380     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8381   return resultobj;
8382 fail:
8383   return NULL;
8384 }
8385
8386
8387 SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8388   PyObject *resultobj = 0;
8389   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8390   std::vector<Hex::Quad * >::iterator arg2 ;
8391   std::vector<Hex::Quad * >::size_type arg3 ;
8392   std::vector<Hex::Quad * >::value_type arg4 = (std::vector<Hex::Quad * >::value_type) 0 ;
8393   void *argp1 = 0 ;
8394   int res1 = 0 ;
8395   swig::PySwigIterator *iter2 = 0 ;
8396   int res2 ;
8397   size_t val3 ;
8398   int ecode3 = 0 ;
8399   void *argp4 = 0 ;
8400   int res4 = 0 ;
8401   PyObject * obj0 = 0 ;
8402   PyObject * obj1 = 0 ;
8403   PyObject * obj2 = 0 ;
8404   PyObject * obj3 = 0 ;
8405
8406   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8407   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
8408   if (!SWIG_IsOK(res1)) {
8409     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8410   }
8411   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8412   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
8413   if (!SWIG_IsOK(res2) || !iter2) {
8414     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
8415   } else {
8416     swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter2);
8417     if (iter_t) {
8418       arg2 = iter_t->get_current();
8419     } else {
8420       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::iterator""'");
8421     }
8422   }
8423   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8424   if (!SWIG_IsOK(ecode3)) {
8425     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector<Hex::Quad * >::size_type""'");
8426   }
8427   arg3 = static_cast< std::vector<Hex::Quad * >::size_type >(val3);
8428   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0 |  0 );
8429   if (!SWIG_IsOK(res4)) {
8430     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads_insert" "', argument " "4"" of type '" "std::vector<Hex::Quad * >::value_type""'");
8431   }
8432   arg4 = reinterpret_cast< std::vector<Hex::Quad * >::value_type >(argp4);
8433   (arg1)->insert(arg2,arg3,arg4);
8434   resultobj = SWIG_Py_Void();
8435   return resultobj;
8436 fail:
8437   return NULL;
8438 }
8439
8440
8441 SWIGINTERN PyObject *_wrap_VectorQuads_insert(PyObject *self, PyObject *args) {
8442   int argc;
8443   PyObject *argv[5];
8444   int ii;
8445
8446   if (!PyTuple_Check(args)) SWIG_fail;
8447   argc = PyObject_Length(args);
8448   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
8449     argv[ii] = PyTuple_GET_ITEM(args,ii);
8450   }
8451   if (argc == 3) {
8452     int _v;
8453     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8454     _v = SWIG_CheckState(res);
8455     if (_v) {
8456       swig::PySwigIterator *iter = 0;
8457       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8458       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
8459       if (_v) {
8460         void *vptr = 0;
8461         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
8462         _v = SWIG_CheckState(res);
8463         if (_v) {
8464           return _wrap_VectorQuads_insert__SWIG_0(self, args);
8465         }
8466       }
8467     }
8468   }
8469   if (argc == 4) {
8470     int _v;
8471     int res = swig::asptr(argv[0], (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > >**)(0));
8472     _v = SWIG_CheckState(res);
8473     if (_v) {
8474       swig::PySwigIterator *iter = 0;
8475       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8476       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Quad * >::iterator > *>(iter) != 0));
8477       if (_v) {
8478         {
8479           int res = SWIG_AsVal_size_t(argv[2], NULL);
8480           _v = SWIG_CheckState(res);
8481         }
8482         if (_v) {
8483           void *vptr = 0;
8484           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0);
8485           _v = SWIG_CheckState(res);
8486           if (_v) {
8487             return _wrap_VectorQuads_insert__SWIG_1(self, args);
8488           }
8489         }
8490       }
8491     }
8492   }
8493
8494 fail:
8495   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorQuads_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<Hex::Quad * >::iterator,std::vector<Hex::Quad * >::value_type)\n    insert(std::vector<Hex::Quad * >::iterator,std::vector<Hex::Quad * >::size_type,std::vector<Hex::Quad * >::value_type)\n");
8496   return NULL;
8497 }
8498
8499
8500 SWIGINTERN PyObject *_wrap_VectorQuads_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8501   PyObject *resultobj = 0;
8502   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8503   std::vector<Hex::Quad * >::size_type arg2 ;
8504   void *argp1 = 0 ;
8505   int res1 = 0 ;
8506   size_t val2 ;
8507   int ecode2 = 0 ;
8508   PyObject * obj0 = 0 ;
8509   PyObject * obj1 = 0 ;
8510
8511   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_reserve",&obj0,&obj1)) SWIG_fail;
8512   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
8513   if (!SWIG_IsOK(res1)) {
8514     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_reserve" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8515   }
8516   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8517   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8518   if (!SWIG_IsOK(ecode2)) {
8519     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_reserve" "', argument " "2"" of type '" "std::vector<Hex::Quad * >::size_type""'");
8520   }
8521   arg2 = static_cast< std::vector<Hex::Quad * >::size_type >(val2);
8522   (arg1)->reserve(arg2);
8523   resultobj = SWIG_Py_Void();
8524   return resultobj;
8525 fail:
8526   return NULL;
8527 }
8528
8529
8530 SWIGINTERN PyObject *_wrap_VectorQuads_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8531   PyObject *resultobj = 0;
8532   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8533   std::vector<Hex::Quad * >::size_type result;
8534   void *argp1 = 0 ;
8535   int res1 = 0 ;
8536   PyObject * obj0 = 0 ;
8537
8538   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_capacity",&obj0)) SWIG_fail;
8539   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0 |  0 );
8540   if (!SWIG_IsOK(res1)) {
8541     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_capacity" "', argument " "1"" of type '" "std::vector<Hex::Quad * > const *""'");
8542   }
8543   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8544   result = ((std::vector<Hex::Quad * > const *)arg1)->capacity();
8545   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8546   return resultobj;
8547 fail:
8548   return NULL;
8549 }
8550
8551
8552 SWIGINTERN PyObject *_wrap_delete_VectorQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8553   PyObject *resultobj = 0;
8554   std::vector<Hex::Quad * > *arg1 = (std::vector<Hex::Quad * > *) 0 ;
8555   void *argp1 = 0 ;
8556   int res1 = 0 ;
8557   PyObject * obj0 = 0 ;
8558
8559   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorQuads",&obj0)) SWIG_fail;
8560   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_POINTER_DISOWN |  0 );
8561   if (!SWIG_IsOK(res1)) {
8562     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorQuads" "', argument " "1"" of type '" "std::vector<Hex::Quad * > *""'");
8563   }
8564   arg1 = reinterpret_cast< std::vector<Hex::Quad * > * >(argp1);
8565   delete arg1;
8566
8567   resultobj = SWIG_Py_Void();
8568   return resultobj;
8569 fail:
8570   return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *VectorQuads_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8575   PyObject *obj;
8576   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
8577   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, SWIG_NewClientData(obj));
8578   return SWIG_Py_Void();
8579 }
8580
8581 SWIGINTERN PyObject *_wrap_VectorEdges_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8582   PyObject *resultobj = 0;
8583   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8584   PyObject **arg2 = (PyObject **) 0 ;
8585   swig::PySwigIterator *result = 0 ;
8586   void *argp1 = 0 ;
8587   int res1 = 0 ;
8588   PyObject * obj0 = 0 ;
8589
8590   arg2 = &obj0;
8591   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_iterator",&obj0)) SWIG_fail;
8592   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
8593   if (!SWIG_IsOK(res1)) {
8594     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_iterator" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8595   }
8596   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8597   result = (swig::PySwigIterator *)std_vector_Sl_Hex_Edge_Sm__Sg__iterator(arg1,arg2);
8598   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
8599   return resultobj;
8600 fail:
8601   return NULL;
8602 }
8603
8604
8605 SWIGINTERN PyObject *_wrap_VectorEdges___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8606   PyObject *resultobj = 0;
8607   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8608   bool result;
8609   void *argp1 = 0 ;
8610   int res1 = 0 ;
8611   PyObject * obj0 = 0 ;
8612
8613   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___nonzero__",&obj0)) SWIG_fail;
8614   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
8615   if (!SWIG_IsOK(res1)) {
8616     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
8617   }
8618   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8619   result = (bool)std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__((std::vector<Hex::Edge * > const *)arg1);
8620   resultobj = SWIG_From_bool(static_cast< bool >(result));
8621   return resultobj;
8622 fail:
8623   return NULL;
8624 }
8625
8626
8627 SWIGINTERN PyObject *_wrap_VectorEdges___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8628   PyObject *resultobj = 0;
8629   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8630   std::vector<Hex::Edge * >::size_type result;
8631   void *argp1 = 0 ;
8632   int res1 = 0 ;
8633   PyObject * obj0 = 0 ;
8634
8635   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___len__",&obj0)) SWIG_fail;
8636   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
8637   if (!SWIG_IsOK(res1)) {
8638     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___len__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
8639   }
8640   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8641   result = std_vector_Sl_Hex_Edge_Sm__Sg____len__((std::vector<Hex::Edge * > const *)arg1);
8642   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8643   return resultobj;
8644 fail:
8645   return NULL;
8646 }
8647
8648
8649 SWIGINTERN PyObject *_wrap_VectorEdges_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8650   PyObject *resultobj = 0;
8651   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8652   std::vector<Hex::Edge * >::value_type result;
8653   void *argp1 = 0 ;
8654   int res1 = 0 ;
8655   PyObject * obj0 = 0 ;
8656
8657   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop",&obj0)) SWIG_fail;
8658   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
8659   if (!SWIG_IsOK(res1)) {
8660     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8661   }
8662   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8663   try {
8664     result = (std::vector<Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg__pop(arg1);
8665   }
8666   catch(std::out_of_range &_e) {
8667     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8668   }
8669
8670   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
8671   return resultobj;
8672 fail:
8673   return NULL;
8674 }
8675
8676
8677 SWIGINTERN PyObject *_wrap_VectorEdges___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8678   PyObject *resultobj = 0;
8679   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8680   std::vector<Hex::Edge * >::difference_type arg2 ;
8681   std::vector<Hex::Edge * >::difference_type arg3 ;
8682   std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *result = 0 ;
8683   void *argp1 = 0 ;
8684   int res1 = 0 ;
8685   ptrdiff_t val2 ;
8686   int ecode2 = 0 ;
8687   ptrdiff_t val3 ;
8688   int ecode3 = 0 ;
8689   PyObject * obj0 = 0 ;
8690   PyObject * obj1 = 0 ;
8691   PyObject * obj2 = 0 ;
8692
8693   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8694   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
8695   if (!SWIG_IsOK(res1)) {
8696     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8697   }
8698   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8699   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8700   if (!SWIG_IsOK(ecode2)) {
8701     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8702   }
8703   arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8704   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8705   if (!SWIG_IsOK(ecode3)) {
8706     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8707   }
8708   arg3 = static_cast< std::vector<Hex::Edge * >::difference_type >(val3);
8709   try {
8710     result = (std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *)std_vector_Sl_Hex_Edge_Sm__Sg____getslice__(arg1,arg2,arg3);
8711   }
8712   catch(std::out_of_range &_e) {
8713     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8714   }
8715
8716   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_OWN |  0 );
8717   return resultobj;
8718 fail:
8719   return NULL;
8720 }
8721
8722
8723 SWIGINTERN PyObject *_wrap_VectorEdges___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8724   PyObject *resultobj = 0;
8725   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8726   std::vector<Hex::Edge * >::difference_type arg2 ;
8727   std::vector<Hex::Edge * >::difference_type arg3 ;
8728   std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *arg4 = 0 ;
8729   void *argp1 = 0 ;
8730   int res1 = 0 ;
8731   ptrdiff_t val2 ;
8732   int ecode2 = 0 ;
8733   ptrdiff_t val3 ;
8734   int ecode3 = 0 ;
8735   int res4 = SWIG_OLDOBJ ;
8736   PyObject * obj0 = 0 ;
8737   PyObject * obj1 = 0 ;
8738   PyObject * obj2 = 0 ;
8739   PyObject * obj3 = 0 ;
8740
8741   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8742   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
8743   if (!SWIG_IsOK(res1)) {
8744     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8745   }
8746   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8747   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8748   if (!SWIG_IsOK(ecode2)) {
8749     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8750   }
8751   arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8752   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8753   if (!SWIG_IsOK(ecode3)) {
8754     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8755   }
8756   arg3 = static_cast< std::vector<Hex::Edge * >::difference_type >(val3);
8757   {
8758     std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
8759     res4 = swig::asptr(obj3, &ptr);
8760     if (!SWIG_IsOK(res4)) {
8761       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > const &""'");
8762     }
8763     if (!ptr) {
8764       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 &""'");
8765     }
8766     arg4 = ptr;
8767   }
8768   try {
8769     std_vector_Sl_Hex_Edge_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > const &)*arg4);
8770   }
8771   catch(std::out_of_range &_e) {
8772     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8773   }
8774   catch(std::invalid_argument &_e) {
8775     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8776   }
8777
8778   resultobj = SWIG_Py_Void();
8779   if (SWIG_IsNewObj(res4)) delete arg4;
8780   return resultobj;
8781 fail:
8782   if (SWIG_IsNewObj(res4)) delete arg4;
8783   return NULL;
8784 }
8785
8786
8787 SWIGINTERN PyObject *_wrap_VectorEdges___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8788   PyObject *resultobj = 0;
8789   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8790   std::vector<Hex::Edge * >::difference_type arg2 ;
8791   std::vector<Hex::Edge * >::difference_type arg3 ;
8792   void *argp1 = 0 ;
8793   int res1 = 0 ;
8794   ptrdiff_t val2 ;
8795   int ecode2 = 0 ;
8796   ptrdiff_t val3 ;
8797   int ecode3 = 0 ;
8798   PyObject * obj0 = 0 ;
8799   PyObject * obj1 = 0 ;
8800   PyObject * obj2 = 0 ;
8801
8802   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8803   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
8804   if (!SWIG_IsOK(res1)) {
8805     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8806   }
8807   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8808   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8809   if (!SWIG_IsOK(ecode2)) {
8810     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8811   }
8812   arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8813   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8814   if (!SWIG_IsOK(ecode3)) {
8815     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8816   }
8817   arg3 = static_cast< std::vector<Hex::Edge * >::difference_type >(val3);
8818   try {
8819     std_vector_Sl_Hex_Edge_Sm__Sg____delslice__(arg1,arg2,arg3);
8820   }
8821   catch(std::out_of_range &_e) {
8822     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8823   }
8824
8825   resultobj = SWIG_Py_Void();
8826   return resultobj;
8827 fail:
8828   return NULL;
8829 }
8830
8831
8832 SWIGINTERN PyObject *_wrap_VectorEdges___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8833   PyObject *resultobj = 0;
8834   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8835   std::vector<Hex::Edge * >::difference_type arg2 ;
8836   void *argp1 = 0 ;
8837   int res1 = 0 ;
8838   ptrdiff_t val2 ;
8839   int ecode2 = 0 ;
8840   PyObject * obj0 = 0 ;
8841   PyObject * obj1 = 0 ;
8842
8843   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___delitem__",&obj0,&obj1)) SWIG_fail;
8844   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
8845   if (!SWIG_IsOK(res1)) {
8846     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8847   }
8848   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8849   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8850   if (!SWIG_IsOK(ecode2)) {
8851     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8852   }
8853   arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8854   try {
8855     std_vector_Sl_Hex_Edge_Sm__Sg____delitem__(arg1,arg2);
8856   }
8857   catch(std::out_of_range &_e) {
8858     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8859   }
8860
8861   resultobj = SWIG_Py_Void();
8862   return resultobj;
8863 fail:
8864   return NULL;
8865 }
8866
8867
8868 SWIGINTERN PyObject *_wrap_VectorEdges___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8869   PyObject *resultobj = 0;
8870   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8871   std::vector<Hex::Edge * >::difference_type arg2 ;
8872   std::vector<Hex::Edge * >::value_type result;
8873   void *argp1 = 0 ;
8874   int res1 = 0 ;
8875   ptrdiff_t val2 ;
8876   int ecode2 = 0 ;
8877   PyObject * obj0 = 0 ;
8878   PyObject * obj1 = 0 ;
8879
8880   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___getitem__",&obj0,&obj1)) SWIG_fail;
8881   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
8882   if (!SWIG_IsOK(res1)) {
8883     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8884   }
8885   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8886   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8887   if (!SWIG_IsOK(ecode2)) {
8888     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8889   }
8890   arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8891   try {
8892     result = (std::vector<Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg____getitem__(arg1,arg2);
8893   }
8894   catch(std::out_of_range &_e) {
8895     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8896   }
8897
8898   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
8899   return resultobj;
8900 fail:
8901   return NULL;
8902 }
8903
8904
8905 SWIGINTERN PyObject *_wrap_VectorEdges___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8906   PyObject *resultobj = 0;
8907   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8908   std::vector<Hex::Edge * >::difference_type arg2 ;
8909   std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
8910   void *argp1 = 0 ;
8911   int res1 = 0 ;
8912   ptrdiff_t val2 ;
8913   int ecode2 = 0 ;
8914   void *argp3 = 0 ;
8915   int res3 = 0 ;
8916   PyObject * obj0 = 0 ;
8917   PyObject * obj1 = 0 ;
8918   PyObject * obj2 = 0 ;
8919
8920   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
8921   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
8922   if (!SWIG_IsOK(res1)) {
8923     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8924   }
8925   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8926   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8927   if (!SWIG_IsOK(ecode2)) {
8928     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::difference_type""'");
8929   }
8930   arg2 = static_cast< std::vector<Hex::Edge * >::difference_type >(val2);
8931   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
8932   if (!SWIG_IsOK(res3)) {
8933     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
8934   }
8935   arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
8936   try {
8937     std_vector_Sl_Hex_Edge_Sm__Sg____setitem__(arg1,arg2,arg3);
8938   }
8939   catch(std::out_of_range &_e) {
8940     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8941   }
8942
8943   resultobj = SWIG_Py_Void();
8944   return resultobj;
8945 fail:
8946   return NULL;
8947 }
8948
8949
8950 SWIGINTERN PyObject *_wrap_VectorEdges_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8951   PyObject *resultobj = 0;
8952   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
8953   std::vector<Hex::Edge * >::value_type arg2 = (std::vector<Hex::Edge * >::value_type) 0 ;
8954   void *argp1 = 0 ;
8955   int res1 = 0 ;
8956   void *argp2 = 0 ;
8957   int res2 = 0 ;
8958   PyObject * obj0 = 0 ;
8959   PyObject * obj1 = 0 ;
8960
8961   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_append",&obj0,&obj1)) SWIG_fail;
8962   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
8963   if (!SWIG_IsOK(res1)) {
8964     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_append" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
8965   }
8966   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
8967   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
8968   if (!SWIG_IsOK(res2)) {
8969     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_append" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::value_type""'");
8970   }
8971   arg2 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp2);
8972   std_vector_Sl_Hex_Edge_Sm__Sg__append(arg1,arg2);
8973   resultobj = SWIG_Py_Void();
8974   return resultobj;
8975 fail:
8976   return NULL;
8977 }
8978
8979
8980 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8981   PyObject *resultobj = 0;
8982   std::vector<Hex::Edge * > *result = 0 ;
8983
8984   if (!PyArg_ParseTuple(args,(char *)":new_VectorEdges")) SWIG_fail;
8985   result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >();
8986   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
8987   return resultobj;
8988 fail:
8989   return NULL;
8990 }
8991
8992
8993 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8994   PyObject *resultobj = 0;
8995   std::vector<Hex::Edge * > *arg1 = 0 ;
8996   std::vector<Hex::Edge * > *result = 0 ;
8997   int res1 = SWIG_OLDOBJ ;
8998   PyObject * obj0 = 0 ;
8999
9000   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
9001   {
9002     std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
9003     res1 = swig::asptr(obj0, &ptr);
9004     if (!SWIG_IsOK(res1)) {
9005       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const &""'");
9006     }
9007     if (!ptr) {
9008       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const &""'");
9009     }
9010     arg1 = ptr;
9011   }
9012   result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >((std::vector<Hex::Edge * > const &)*arg1);
9013   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
9014   if (SWIG_IsNewObj(res1)) delete arg1;
9015   return resultobj;
9016 fail:
9017   if (SWIG_IsNewObj(res1)) delete arg1;
9018   return NULL;
9019 }
9020
9021
9022 SWIGINTERN PyObject *_wrap_VectorEdges_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023   PyObject *resultobj = 0;
9024   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9025   bool result;
9026   void *argp1 = 0 ;
9027   int res1 = 0 ;
9028   PyObject * obj0 = 0 ;
9029
9030   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_empty",&obj0)) SWIG_fail;
9031   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9032   if (!SWIG_IsOK(res1)) {
9033     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_empty" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9034   }
9035   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9036   result = (bool)((std::vector<Hex::Edge * > const *)arg1)->empty();
9037   resultobj = SWIG_From_bool(static_cast< bool >(result));
9038   return resultobj;
9039 fail:
9040   return NULL;
9041 }
9042
9043
9044 SWIGINTERN PyObject *_wrap_VectorEdges_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9045   PyObject *resultobj = 0;
9046   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9047   std::vector<Hex::Edge * >::size_type result;
9048   void *argp1 = 0 ;
9049   int res1 = 0 ;
9050   PyObject * obj0 = 0 ;
9051
9052   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_size",&obj0)) SWIG_fail;
9053   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9054   if (!SWIG_IsOK(res1)) {
9055     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_size" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9056   }
9057   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9058   result = ((std::vector<Hex::Edge * > const *)arg1)->size();
9059   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9060   return resultobj;
9061 fail:
9062   return NULL;
9063 }
9064
9065
9066 SWIGINTERN PyObject *_wrap_VectorEdges_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9067   PyObject *resultobj = 0;
9068   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9069   void *argp1 = 0 ;
9070   int res1 = 0 ;
9071   PyObject * obj0 = 0 ;
9072
9073   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_clear",&obj0)) SWIG_fail;
9074   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9075   if (!SWIG_IsOK(res1)) {
9076     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_clear" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9077   }
9078   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9079   (arg1)->clear();
9080   resultobj = SWIG_Py_Void();
9081   return resultobj;
9082 fail:
9083   return NULL;
9084 }
9085
9086
9087 SWIGINTERN PyObject *_wrap_VectorEdges_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9088   PyObject *resultobj = 0;
9089   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9090   std::vector<Hex::Edge * > *arg2 = 0 ;
9091   void *argp1 = 0 ;
9092   int res1 = 0 ;
9093   void *argp2 = 0 ;
9094   int res2 = 0 ;
9095   PyObject * obj0 = 0 ;
9096   PyObject * obj1 = 0 ;
9097
9098   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_swap",&obj0,&obj1)) SWIG_fail;
9099   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9100   if (!SWIG_IsOK(res1)) {
9101     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_swap" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9102   }
9103   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9104   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t,  0 );
9105   if (!SWIG_IsOK(res2)) {
9106     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector<Hex::Edge * > &""'");
9107   }
9108   if (!argp2) {
9109     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector<Hex::Edge * > &""'");
9110   }
9111   arg2 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp2);
9112   (arg1)->swap(*arg2);
9113   resultobj = SWIG_Py_Void();
9114   return resultobj;
9115 fail:
9116   return NULL;
9117 }
9118
9119
9120 SWIGINTERN PyObject *_wrap_VectorEdges_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9121   PyObject *resultobj = 0;
9122   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9123   SwigValueWrapper<std::allocator<Hex::Edge * > > result;
9124   void *argp1 = 0 ;
9125   int res1 = 0 ;
9126   PyObject * obj0 = 0 ;
9127
9128   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_get_allocator",&obj0)) SWIG_fail;
9129   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9130   if (!SWIG_IsOK(res1)) {
9131     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9132   }
9133   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9134   result = ((std::vector<Hex::Edge * > const *)arg1)->get_allocator();
9135   resultobj = SWIG_NewPointerObj((new std::vector<Hex::Edge * >::allocator_type(static_cast< const std::vector<Hex::Edge * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
9136   return resultobj;
9137 fail:
9138   return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_VectorEdges_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9143   PyObject *resultobj = 0;
9144   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9145   std::vector<Hex::Edge * >::iterator result;
9146   void *argp1 = 0 ;
9147   int res1 = 0 ;
9148   PyObject * obj0 = 0 ;
9149
9150   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_begin",&obj0)) SWIG_fail;
9151   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9152   if (!SWIG_IsOK(res1)) {
9153     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_begin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9154   }
9155   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9156   result = (arg1)->begin();
9157   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
9158     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9159   return resultobj;
9160 fail:
9161   return NULL;
9162 }
9163
9164
9165 SWIGINTERN PyObject *_wrap_VectorEdges_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9166   PyObject *resultobj = 0;
9167   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9168   std::vector<Hex::Edge * >::const_iterator result;
9169   void *argp1 = 0 ;
9170   int res1 = 0 ;
9171   PyObject * obj0 = 0 ;
9172
9173   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_begin",&obj0)) SWIG_fail;
9174   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9175   if (!SWIG_IsOK(res1)) {
9176     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_begin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9177   }
9178   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9179   result = ((std::vector<Hex::Edge * > const *)arg1)->begin();
9180   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_iterator & >(result)),
9181     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9182   return resultobj;
9183 fail:
9184   return NULL;
9185 }
9186
9187
9188 SWIGINTERN PyObject *_wrap_VectorEdges_begin(PyObject *self, PyObject *args) {
9189   int argc;
9190   PyObject *argv[2];
9191   int ii;
9192
9193   if (!PyTuple_Check(args)) SWIG_fail;
9194   argc = PyObject_Length(args);
9195   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
9196     argv[ii] = PyTuple_GET_ITEM(args,ii);
9197   }
9198   if (argc == 1) {
9199     int _v;
9200     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9201     _v = SWIG_CheckState(res);
9202     if (_v) {
9203       return _wrap_VectorEdges_begin__SWIG_0(self, args);
9204     }
9205   }
9206   if (argc == 1) {
9207     int _v;
9208     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9209     _v = SWIG_CheckState(res);
9210     if (_v) {
9211       return _wrap_VectorEdges_begin__SWIG_1(self, args);
9212     }
9213   }
9214
9215 fail:
9216   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
9217   return NULL;
9218 }
9219
9220
9221 SWIGINTERN PyObject *_wrap_VectorEdges_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9222   PyObject *resultobj = 0;
9223   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9224   std::vector<Hex::Edge * >::iterator result;
9225   void *argp1 = 0 ;
9226   int res1 = 0 ;
9227   PyObject * obj0 = 0 ;
9228
9229   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_end",&obj0)) SWIG_fail;
9230   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9231   if (!SWIG_IsOK(res1)) {
9232     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_end" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9233   }
9234   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9235   result = (arg1)->end();
9236   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
9237     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9238   return resultobj;
9239 fail:
9240   return NULL;
9241 }
9242
9243
9244 SWIGINTERN PyObject *_wrap_VectorEdges_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9245   PyObject *resultobj = 0;
9246   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9247   std::vector<Hex::Edge * >::const_iterator result;
9248   void *argp1 = 0 ;
9249   int res1 = 0 ;
9250   PyObject * obj0 = 0 ;
9251
9252   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_end",&obj0)) SWIG_fail;
9253   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9254   if (!SWIG_IsOK(res1)) {
9255     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_end" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9256   }
9257   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9258   result = ((std::vector<Hex::Edge * > const *)arg1)->end();
9259   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_iterator & >(result)),
9260     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9261   return resultobj;
9262 fail:
9263   return NULL;
9264 }
9265
9266
9267 SWIGINTERN PyObject *_wrap_VectorEdges_end(PyObject *self, PyObject *args) {
9268   int argc;
9269   PyObject *argv[2];
9270   int ii;
9271
9272   if (!PyTuple_Check(args)) SWIG_fail;
9273   argc = PyObject_Length(args);
9274   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
9275     argv[ii] = PyTuple_GET_ITEM(args,ii);
9276   }
9277   if (argc == 1) {
9278     int _v;
9279     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9280     _v = SWIG_CheckState(res);
9281     if (_v) {
9282       return _wrap_VectorEdges_end__SWIG_0(self, args);
9283     }
9284   }
9285   if (argc == 1) {
9286     int _v;
9287     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9288     _v = SWIG_CheckState(res);
9289     if (_v) {
9290       return _wrap_VectorEdges_end__SWIG_1(self, args);
9291     }
9292   }
9293
9294 fail:
9295   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
9296   return NULL;
9297 }
9298
9299
9300 SWIGINTERN PyObject *_wrap_VectorEdges_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9301   PyObject *resultobj = 0;
9302   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9303   std::vector<Hex::Edge * >::reverse_iterator result;
9304   void *argp1 = 0 ;
9305   int res1 = 0 ;
9306   PyObject * obj0 = 0 ;
9307
9308   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rbegin",&obj0)) SWIG_fail;
9309   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9310   if (!SWIG_IsOK(res1)) {
9311     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9312   }
9313   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9314   result = (arg1)->rbegin();
9315   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::reverse_iterator & >(result)),
9316     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9317   return resultobj;
9318 fail:
9319   return NULL;
9320 }
9321
9322
9323 SWIGINTERN PyObject *_wrap_VectorEdges_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9324   PyObject *resultobj = 0;
9325   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9326   std::vector<Hex::Edge * >::const_reverse_iterator result;
9327   void *argp1 = 0 ;
9328   int res1 = 0 ;
9329   PyObject * obj0 = 0 ;
9330
9331   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rbegin",&obj0)) SWIG_fail;
9332   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9333   if (!SWIG_IsOK(res1)) {
9334     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9335   }
9336   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9337   result = ((std::vector<Hex::Edge * > const *)arg1)->rbegin();
9338   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_reverse_iterator & >(result)),
9339     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9340   return resultobj;
9341 fail:
9342   return NULL;
9343 }
9344
9345
9346 SWIGINTERN PyObject *_wrap_VectorEdges_rbegin(PyObject *self, PyObject *args) {
9347   int argc;
9348   PyObject *argv[2];
9349   int ii;
9350
9351   if (!PyTuple_Check(args)) SWIG_fail;
9352   argc = PyObject_Length(args);
9353   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
9354     argv[ii] = PyTuple_GET_ITEM(args,ii);
9355   }
9356   if (argc == 1) {
9357     int _v;
9358     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9359     _v = SWIG_CheckState(res);
9360     if (_v) {
9361       return _wrap_VectorEdges_rbegin__SWIG_0(self, args);
9362     }
9363   }
9364   if (argc == 1) {
9365     int _v;
9366     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9367     _v = SWIG_CheckState(res);
9368     if (_v) {
9369       return _wrap_VectorEdges_rbegin__SWIG_1(self, args);
9370     }
9371   }
9372
9373 fail:
9374   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
9375   return NULL;
9376 }
9377
9378
9379 SWIGINTERN PyObject *_wrap_VectorEdges_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9380   PyObject *resultobj = 0;
9381   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9382   std::vector<Hex::Edge * >::reverse_iterator result;
9383   void *argp1 = 0 ;
9384   int res1 = 0 ;
9385   PyObject * obj0 = 0 ;
9386
9387   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rend",&obj0)) SWIG_fail;
9388   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9389   if (!SWIG_IsOK(res1)) {
9390     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rend" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9391   }
9392   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9393   result = (arg1)->rend();
9394   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::reverse_iterator & >(result)),
9395     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9396   return resultobj;
9397 fail:
9398   return NULL;
9399 }
9400
9401
9402 SWIGINTERN PyObject *_wrap_VectorEdges_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9403   PyObject *resultobj = 0;
9404   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9405   std::vector<Hex::Edge * >::const_reverse_iterator result;
9406   void *argp1 = 0 ;
9407   int res1 = 0 ;
9408   PyObject * obj0 = 0 ;
9409
9410   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rend",&obj0)) SWIG_fail;
9411   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9412   if (!SWIG_IsOK(res1)) {
9413     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rend" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9414   }
9415   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9416   result = ((std::vector<Hex::Edge * > const *)arg1)->rend();
9417   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::const_reverse_iterator & >(result)),
9418     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9419   return resultobj;
9420 fail:
9421   return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *_wrap_VectorEdges_rend(PyObject *self, PyObject *args) {
9426   int argc;
9427   PyObject *argv[2];
9428   int ii;
9429
9430   if (!PyTuple_Check(args)) SWIG_fail;
9431   argc = PyObject_Length(args);
9432   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
9433     argv[ii] = PyTuple_GET_ITEM(args,ii);
9434   }
9435   if (argc == 1) {
9436     int _v;
9437     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9438     _v = SWIG_CheckState(res);
9439     if (_v) {
9440       return _wrap_VectorEdges_rend__SWIG_0(self, args);
9441     }
9442   }
9443   if (argc == 1) {
9444     int _v;
9445     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9446     _v = SWIG_CheckState(res);
9447     if (_v) {
9448       return _wrap_VectorEdges_rend__SWIG_1(self, args);
9449     }
9450   }
9451
9452 fail:
9453   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
9454   return NULL;
9455 }
9456
9457
9458 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9459   PyObject *resultobj = 0;
9460   std::vector<Hex::Edge * >::size_type arg1 ;
9461   std::vector<Hex::Edge * > *result = 0 ;
9462   size_t val1 ;
9463   int ecode1 = 0 ;
9464   PyObject * obj0 = 0 ;
9465
9466   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
9467   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
9468   if (!SWIG_IsOK(ecode1)) {
9469     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * >::size_type""'");
9470   }
9471   arg1 = static_cast< std::vector<Hex::Edge * >::size_type >(val1);
9472   result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >(arg1);
9473   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
9474   return resultobj;
9475 fail:
9476   return NULL;
9477 }
9478
9479
9480 SWIGINTERN PyObject *_wrap_VectorEdges_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481   PyObject *resultobj = 0;
9482   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9483   void *argp1 = 0 ;
9484   int res1 = 0 ;
9485   PyObject * obj0 = 0 ;
9486
9487   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop_back",&obj0)) SWIG_fail;
9488   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9489   if (!SWIG_IsOK(res1)) {
9490     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9491   }
9492   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9493   (arg1)->pop_back();
9494   resultobj = SWIG_Py_Void();
9495   return resultobj;
9496 fail:
9497   return NULL;
9498 }
9499
9500
9501 SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9502   PyObject *resultobj = 0;
9503   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9504   std::vector<Hex::Edge * >::size_type arg2 ;
9505   void *argp1 = 0 ;
9506   int res1 = 0 ;
9507   size_t val2 ;
9508   int ecode2 = 0 ;
9509   PyObject * obj0 = 0 ;
9510   PyObject * obj1 = 0 ;
9511
9512   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_resize",&obj0,&obj1)) SWIG_fail;
9513   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9514   if (!SWIG_IsOK(res1)) {
9515     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9516   }
9517   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9518   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9519   if (!SWIG_IsOK(ecode2)) {
9520     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
9521   }
9522   arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
9523   (arg1)->resize(arg2);
9524   resultobj = SWIG_Py_Void();
9525   return resultobj;
9526 fail:
9527   return NULL;
9528 }
9529
9530
9531 SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9532   PyObject *resultobj = 0;
9533   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9534   std::vector<Hex::Edge * >::iterator arg2 ;
9535   std::vector<Hex::Edge * >::iterator result;
9536   void *argp1 = 0 ;
9537   int res1 = 0 ;
9538   swig::PySwigIterator *iter2 = 0 ;
9539   int res2 ;
9540   PyObject * obj0 = 0 ;
9541   PyObject * obj1 = 0 ;
9542
9543   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_erase",&obj0,&obj1)) SWIG_fail;
9544   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9545   if (!SWIG_IsOK(res1)) {
9546     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9547   }
9548   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9549   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
9550   if (!SWIG_IsOK(res2) || !iter2) {
9551     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9552   } else {
9553     swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
9554     if (iter_t) {
9555       arg2 = iter_t->get_current();
9556     } else {
9557       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9558     }
9559   }
9560   result = (arg1)->erase(arg2);
9561   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
9562     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9563   return resultobj;
9564 fail:
9565   return NULL;
9566 }
9567
9568
9569 SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9570   PyObject *resultobj = 0;
9571   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9572   std::vector<Hex::Edge * >::iterator arg2 ;
9573   std::vector<Hex::Edge * >::iterator arg3 ;
9574   std::vector<Hex::Edge * >::iterator result;
9575   void *argp1 = 0 ;
9576   int res1 = 0 ;
9577   swig::PySwigIterator *iter2 = 0 ;
9578   int res2 ;
9579   swig::PySwigIterator *iter3 = 0 ;
9580   int res3 ;
9581   PyObject * obj0 = 0 ;
9582   PyObject * obj1 = 0 ;
9583   PyObject * obj2 = 0 ;
9584
9585   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_erase",&obj0,&obj1,&obj2)) SWIG_fail;
9586   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9587   if (!SWIG_IsOK(res1)) {
9588     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9589   }
9590   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9591   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
9592   if (!SWIG_IsOK(res2) || !iter2) {
9593     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9594   } else {
9595     swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
9596     if (iter_t) {
9597       arg2 = iter_t->get_current();
9598     } else {
9599       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9600     }
9601   }
9602   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
9603   if (!SWIG_IsOK(res3) || !iter3) {
9604     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9605   } else {
9606     swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter3);
9607     if (iter_t) {
9608       arg3 = iter_t->get_current();
9609     } else {
9610       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9611     }
9612   }
9613   result = (arg1)->erase(arg2,arg3);
9614   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
9615     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9616   return resultobj;
9617 fail:
9618   return NULL;
9619 }
9620
9621
9622 SWIGINTERN PyObject *_wrap_VectorEdges_erase(PyObject *self, PyObject *args) {
9623   int argc;
9624   PyObject *argv[4];
9625   int ii;
9626
9627   if (!PyTuple_Check(args)) SWIG_fail;
9628   argc = PyObject_Length(args);
9629   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
9630     argv[ii] = PyTuple_GET_ITEM(args,ii);
9631   }
9632   if (argc == 2) {
9633     int _v;
9634     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9635     _v = SWIG_CheckState(res);
9636     if (_v) {
9637       swig::PySwigIterator *iter = 0;
9638       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
9639       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
9640       if (_v) {
9641         return _wrap_VectorEdges_erase__SWIG_0(self, args);
9642       }
9643     }
9644   }
9645   if (argc == 3) {
9646     int _v;
9647     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9648     _v = SWIG_CheckState(res);
9649     if (_v) {
9650       swig::PySwigIterator *iter = 0;
9651       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
9652       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
9653       if (_v) {
9654         swig::PySwigIterator *iter = 0;
9655         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
9656         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
9657         if (_v) {
9658           return _wrap_VectorEdges_erase__SWIG_1(self, args);
9659         }
9660       }
9661     }
9662   }
9663
9664 fail:
9665   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<Hex::Edge * >::iterator)\n    erase(std::vector<Hex::Edge * >::iterator,std::vector<Hex::Edge * >::iterator)\n");
9666   return NULL;
9667 }
9668
9669
9670 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9671   PyObject *resultobj = 0;
9672   std::vector<Hex::Edge * >::size_type arg1 ;
9673   std::vector<Hex::Edge * >::value_type arg2 = (std::vector<Hex::Edge * >::value_type) 0 ;
9674   std::vector<Hex::Edge * > *result = 0 ;
9675   size_t val1 ;
9676   int ecode1 = 0 ;
9677   void *argp2 = 0 ;
9678   int res2 = 0 ;
9679   PyObject * obj0 = 0 ;
9680   PyObject * obj1 = 0 ;
9681
9682   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorEdges",&obj0,&obj1)) SWIG_fail;
9683   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
9684   if (!SWIG_IsOK(ecode1)) {
9685     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * >::size_type""'");
9686   }
9687   arg1 = static_cast< std::vector<Hex::Edge * >::size_type >(val1);
9688   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
9689   if (!SWIG_IsOK(res2)) {
9690     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorEdges" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::value_type""'");
9691   }
9692   arg2 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp2);
9693   result = (std::vector<Hex::Edge * > *)new std::vector<Hex::Edge * >(arg1,arg2);
9694   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
9695   return resultobj;
9696 fail:
9697   return NULL;
9698 }
9699
9700
9701 SWIGINTERN PyObject *_wrap_new_VectorEdges(PyObject *self, PyObject *args) {
9702   int argc;
9703   PyObject *argv[3];
9704   int ii;
9705
9706   if (!PyTuple_Check(args)) SWIG_fail;
9707   argc = PyObject_Length(args);
9708   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
9709     argv[ii] = PyTuple_GET_ITEM(args,ii);
9710   }
9711   if (argc == 0) {
9712     return _wrap_new_VectorEdges__SWIG_0(self, args);
9713   }
9714   if (argc == 1) {
9715     int _v;
9716     {
9717       int res = SWIG_AsVal_size_t(argv[0], NULL);
9718       _v = SWIG_CheckState(res);
9719     }
9720     if (_v) {
9721       return _wrap_new_VectorEdges__SWIG_2(self, args);
9722     }
9723   }
9724   if (argc == 1) {
9725     int _v;
9726     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9727     _v = SWIG_CheckState(res);
9728     if (_v) {
9729       return _wrap_new_VectorEdges__SWIG_1(self, args);
9730     }
9731   }
9732   if (argc == 2) {
9733     int _v;
9734     {
9735       int res = SWIG_AsVal_size_t(argv[0], NULL);
9736       _v = SWIG_CheckState(res);
9737     }
9738     if (_v) {
9739       void *vptr = 0;
9740       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
9741       _v = SWIG_CheckState(res);
9742       if (_v) {
9743         return _wrap_new_VectorEdges__SWIG_3(self, args);
9744       }
9745     }
9746   }
9747
9748 fail:
9749   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorEdges'.\n  Possible C/C++ prototypes are:\n    std::vector<(p.Hex::Edge)>()\n    std::vector<(p.Hex::Edge)>(std::vector<Hex::Edge * > const &)\n    std::vector<(p.Hex::Edge)>(std::vector<Hex::Edge * >::size_type)\n    std::vector<(p.Hex::Edge)>(std::vector<Hex::Edge * >::size_type,std::vector<Hex::Edge * >::value_type)\n");
9750   return NULL;
9751 }
9752
9753
9754 SWIGINTERN PyObject *_wrap_VectorEdges_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9755   PyObject *resultobj = 0;
9756   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9757   std::vector<Hex::Edge * >::value_type arg2 = (std::vector<Hex::Edge * >::value_type) 0 ;
9758   void *argp1 = 0 ;
9759   int res1 = 0 ;
9760   void *argp2 = 0 ;
9761   int res2 = 0 ;
9762   PyObject * obj0 = 0 ;
9763   PyObject * obj1 = 0 ;
9764
9765   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_push_back",&obj0,&obj1)) SWIG_fail;
9766   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9767   if (!SWIG_IsOK(res1)) {
9768     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_push_back" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9769   }
9770   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9771   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
9772   if (!SWIG_IsOK(res2)) {
9773     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_push_back" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::value_type""'");
9774   }
9775   arg2 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp2);
9776   (arg1)->push_back(arg2);
9777   resultobj = SWIG_Py_Void();
9778   return resultobj;
9779 fail:
9780   return NULL;
9781 }
9782
9783
9784 SWIGINTERN PyObject *_wrap_VectorEdges_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9785   PyObject *resultobj = 0;
9786   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9787   std::vector<Hex::Edge * >::value_type result;
9788   void *argp1 = 0 ;
9789   int res1 = 0 ;
9790   PyObject * obj0 = 0 ;
9791
9792   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_front",&obj0)) SWIG_fail;
9793   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9794   if (!SWIG_IsOK(res1)) {
9795     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_front" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9796   }
9797   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9798   result = (std::vector<Hex::Edge * >::value_type)((std::vector<Hex::Edge * > const *)arg1)->front();
9799   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
9800   return resultobj;
9801 fail:
9802   return NULL;
9803 }
9804
9805
9806 SWIGINTERN PyObject *_wrap_VectorEdges_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9807   PyObject *resultobj = 0;
9808   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9809   std::vector<Hex::Edge * >::value_type result;
9810   void *argp1 = 0 ;
9811   int res1 = 0 ;
9812   PyObject * obj0 = 0 ;
9813
9814   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_back",&obj0)) SWIG_fail;
9815   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9816   if (!SWIG_IsOK(res1)) {
9817     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_back" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
9818   }
9819   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9820   result = (std::vector<Hex::Edge * >::value_type)((std::vector<Hex::Edge * > const *)arg1)->back();
9821   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
9822   return resultobj;
9823 fail:
9824   return NULL;
9825 }
9826
9827
9828 SWIGINTERN PyObject *_wrap_VectorEdges_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9829   PyObject *resultobj = 0;
9830   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9831   std::vector<Hex::Edge * >::size_type arg2 ;
9832   std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
9833   void *argp1 = 0 ;
9834   int res1 = 0 ;
9835   size_t val2 ;
9836   int ecode2 = 0 ;
9837   void *argp3 = 0 ;
9838   int res3 = 0 ;
9839   PyObject * obj0 = 0 ;
9840   PyObject * obj1 = 0 ;
9841   PyObject * obj2 = 0 ;
9842
9843   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_assign",&obj0,&obj1,&obj2)) SWIG_fail;
9844   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9845   if (!SWIG_IsOK(res1)) {
9846     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_assign" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9847   }
9848   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9849   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9850   if (!SWIG_IsOK(ecode2)) {
9851     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_assign" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
9852   }
9853   arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
9854   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
9855   if (!SWIG_IsOK(res3)) {
9856     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_assign" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
9857   }
9858   arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
9859   (arg1)->assign(arg2,arg3);
9860   resultobj = SWIG_Py_Void();
9861   return resultobj;
9862 fail:
9863   return NULL;
9864 }
9865
9866
9867 SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9868   PyObject *resultobj = 0;
9869   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9870   std::vector<Hex::Edge * >::size_type arg2 ;
9871   std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
9872   void *argp1 = 0 ;
9873   int res1 = 0 ;
9874   size_t val2 ;
9875   int ecode2 = 0 ;
9876   void *argp3 = 0 ;
9877   int res3 = 0 ;
9878   PyObject * obj0 = 0 ;
9879   PyObject * obj1 = 0 ;
9880   PyObject * obj2 = 0 ;
9881
9882   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_resize",&obj0,&obj1,&obj2)) SWIG_fail;
9883   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9884   if (!SWIG_IsOK(res1)) {
9885     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9886   }
9887   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9888   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9889   if (!SWIG_IsOK(ecode2)) {
9890     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
9891   }
9892   arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
9893   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
9894   if (!SWIG_IsOK(res3)) {
9895     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_resize" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
9896   }
9897   arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
9898   (arg1)->resize(arg2,arg3);
9899   resultobj = SWIG_Py_Void();
9900   return resultobj;
9901 fail:
9902   return NULL;
9903 }
9904
9905
9906 SWIGINTERN PyObject *_wrap_VectorEdges_resize(PyObject *self, PyObject *args) {
9907   int argc;
9908   PyObject *argv[4];
9909   int ii;
9910
9911   if (!PyTuple_Check(args)) SWIG_fail;
9912   argc = PyObject_Length(args);
9913   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
9914     argv[ii] = PyTuple_GET_ITEM(args,ii);
9915   }
9916   if (argc == 2) {
9917     int _v;
9918     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9919     _v = SWIG_CheckState(res);
9920     if (_v) {
9921       {
9922         int res = SWIG_AsVal_size_t(argv[1], NULL);
9923         _v = SWIG_CheckState(res);
9924       }
9925       if (_v) {
9926         return _wrap_VectorEdges_resize__SWIG_0(self, args);
9927       }
9928     }
9929   }
9930   if (argc == 3) {
9931     int _v;
9932     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
9933     _v = SWIG_CheckState(res);
9934     if (_v) {
9935       {
9936         int res = SWIG_AsVal_size_t(argv[1], NULL);
9937         _v = SWIG_CheckState(res);
9938       }
9939       if (_v) {
9940         void *vptr = 0;
9941         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
9942         _v = SWIG_CheckState(res);
9943         if (_v) {
9944           return _wrap_VectorEdges_resize__SWIG_1(self, args);
9945         }
9946       }
9947     }
9948   }
9949
9950 fail:
9951   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<Hex::Edge * >::size_type)\n    resize(std::vector<Hex::Edge * >::size_type,std::vector<Hex::Edge * >::value_type)\n");
9952   return NULL;
9953 }
9954
9955
9956 SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9957   PyObject *resultobj = 0;
9958   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
9959   std::vector<Hex::Edge * >::iterator arg2 ;
9960   std::vector<Hex::Edge * >::value_type arg3 = (std::vector<Hex::Edge * >::value_type) 0 ;
9961   std::vector<Hex::Edge * >::iterator result;
9962   void *argp1 = 0 ;
9963   int res1 = 0 ;
9964   swig::PySwigIterator *iter2 = 0 ;
9965   int res2 ;
9966   void *argp3 = 0 ;
9967   int res3 = 0 ;
9968   PyObject * obj0 = 0 ;
9969   PyObject * obj1 = 0 ;
9970   PyObject * obj2 = 0 ;
9971
9972   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_insert",&obj0,&obj1,&obj2)) SWIG_fail;
9973   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
9974   if (!SWIG_IsOK(res1)) {
9975     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
9976   }
9977   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
9978   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
9979   if (!SWIG_IsOK(res2) || !iter2) {
9980     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9981   } else {
9982     swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
9983     if (iter_t) {
9984       arg2 = iter_t->get_current();
9985     } else {
9986       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
9987     }
9988   }
9989   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
9990   if (!SWIG_IsOK(res3)) {
9991     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::value_type""'");
9992   }
9993   arg3 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp3);
9994   result = (arg1)->insert(arg2,arg3);
9995   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Edge * >::iterator & >(result)),
9996     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9997   return resultobj;
9998 fail:
9999   return NULL;
10000 }
10001
10002
10003 SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10004   PyObject *resultobj = 0;
10005   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
10006   std::vector<Hex::Edge * >::iterator arg2 ;
10007   std::vector<Hex::Edge * >::size_type arg3 ;
10008   std::vector<Hex::Edge * >::value_type arg4 = (std::vector<Hex::Edge * >::value_type) 0 ;
10009   void *argp1 = 0 ;
10010   int res1 = 0 ;
10011   swig::PySwigIterator *iter2 = 0 ;
10012   int res2 ;
10013   size_t val3 ;
10014   int ecode3 = 0 ;
10015   void *argp4 = 0 ;
10016   int res4 = 0 ;
10017   PyObject * obj0 = 0 ;
10018   PyObject * obj1 = 0 ;
10019   PyObject * obj2 = 0 ;
10020   PyObject * obj3 = 0 ;
10021
10022   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10023   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
10024   if (!SWIG_IsOK(res1)) {
10025     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
10026   }
10027   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
10028   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
10029   if (!SWIG_IsOK(res2) || !iter2) {
10030     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
10031   } else {
10032     swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter2);
10033     if (iter_t) {
10034       arg2 = iter_t->get_current();
10035     } else {
10036       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::iterator""'");
10037     }
10038   }
10039   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
10040   if (!SWIG_IsOK(ecode3)) {
10041     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector<Hex::Edge * >::size_type""'");
10042   }
10043   arg3 = static_cast< std::vector<Hex::Edge * >::size_type >(val3);
10044   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0 |  0 );
10045   if (!SWIG_IsOK(res4)) {
10046     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges_insert" "', argument " "4"" of type '" "std::vector<Hex::Edge * >::value_type""'");
10047   }
10048   arg4 = reinterpret_cast< std::vector<Hex::Edge * >::value_type >(argp4);
10049   (arg1)->insert(arg2,arg3,arg4);
10050   resultobj = SWIG_Py_Void();
10051   return resultobj;
10052 fail:
10053   return NULL;
10054 }
10055
10056
10057 SWIGINTERN PyObject *_wrap_VectorEdges_insert(PyObject *self, PyObject *args) {
10058   int argc;
10059   PyObject *argv[5];
10060   int ii;
10061
10062   if (!PyTuple_Check(args)) SWIG_fail;
10063   argc = PyObject_Length(args);
10064   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
10065     argv[ii] = PyTuple_GET_ITEM(args,ii);
10066   }
10067   if (argc == 3) {
10068     int _v;
10069     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
10070     _v = SWIG_CheckState(res);
10071     if (_v) {
10072       swig::PySwigIterator *iter = 0;
10073       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
10074       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
10075       if (_v) {
10076         void *vptr = 0;
10077         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
10078         _v = SWIG_CheckState(res);
10079         if (_v) {
10080           return _wrap_VectorEdges_insert__SWIG_0(self, args);
10081         }
10082       }
10083     }
10084   }
10085   if (argc == 4) {
10086     int _v;
10087     int res = swig::asptr(argv[0], (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > >**)(0));
10088     _v = SWIG_CheckState(res);
10089     if (_v) {
10090       swig::PySwigIterator *iter = 0;
10091       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
10092       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Edge * >::iterator > *>(iter) != 0));
10093       if (_v) {
10094         {
10095           int res = SWIG_AsVal_size_t(argv[2], NULL);
10096           _v = SWIG_CheckState(res);
10097         }
10098         if (_v) {
10099           void *vptr = 0;
10100           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0);
10101           _v = SWIG_CheckState(res);
10102           if (_v) {
10103             return _wrap_VectorEdges_insert__SWIG_1(self, args);
10104           }
10105         }
10106       }
10107     }
10108   }
10109
10110 fail:
10111   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorEdges_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<Hex::Edge * >::iterator,std::vector<Hex::Edge * >::value_type)\n    insert(std::vector<Hex::Edge * >::iterator,std::vector<Hex::Edge * >::size_type,std::vector<Hex::Edge * >::value_type)\n");
10112   return NULL;
10113 }
10114
10115
10116 SWIGINTERN PyObject *_wrap_VectorEdges_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10117   PyObject *resultobj = 0;
10118   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
10119   std::vector<Hex::Edge * >::size_type arg2 ;
10120   void *argp1 = 0 ;
10121   int res1 = 0 ;
10122   size_t val2 ;
10123   int ecode2 = 0 ;
10124   PyObject * obj0 = 0 ;
10125   PyObject * obj1 = 0 ;
10126
10127   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_reserve",&obj0,&obj1)) SWIG_fail;
10128   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
10129   if (!SWIG_IsOK(res1)) {
10130     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_reserve" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
10131   }
10132   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
10133   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10134   if (!SWIG_IsOK(ecode2)) {
10135     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_reserve" "', argument " "2"" of type '" "std::vector<Hex::Edge * >::size_type""'");
10136   }
10137   arg2 = static_cast< std::vector<Hex::Edge * >::size_type >(val2);
10138   (arg1)->reserve(arg2);
10139   resultobj = SWIG_Py_Void();
10140   return resultobj;
10141 fail:
10142   return NULL;
10143 }
10144
10145
10146 SWIGINTERN PyObject *_wrap_VectorEdges_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10147   PyObject *resultobj = 0;
10148   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
10149   std::vector<Hex::Edge * >::size_type result;
10150   void *argp1 = 0 ;
10151   int res1 = 0 ;
10152   PyObject * obj0 = 0 ;
10153
10154   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_capacity",&obj0)) SWIG_fail;
10155   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0 |  0 );
10156   if (!SWIG_IsOK(res1)) {
10157     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_capacity" "', argument " "1"" of type '" "std::vector<Hex::Edge * > const *""'");
10158   }
10159   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
10160   result = ((std::vector<Hex::Edge * > const *)arg1)->capacity();
10161   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10162   return resultobj;
10163 fail:
10164   return NULL;
10165 }
10166
10167
10168 SWIGINTERN PyObject *_wrap_delete_VectorEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10169   PyObject *resultobj = 0;
10170   std::vector<Hex::Edge * > *arg1 = (std::vector<Hex::Edge * > *) 0 ;
10171   void *argp1 = 0 ;
10172   int res1 = 0 ;
10173   PyObject * obj0 = 0 ;
10174
10175   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorEdges",&obj0)) SWIG_fail;
10176   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_POINTER_DISOWN |  0 );
10177   if (!SWIG_IsOK(res1)) {
10178     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorEdges" "', argument " "1"" of type '" "std::vector<Hex::Edge * > *""'");
10179   }
10180   arg1 = reinterpret_cast< std::vector<Hex::Edge * > * >(argp1);
10181   delete arg1;
10182
10183   resultobj = SWIG_Py_Void();
10184   return resultobj;
10185 fail:
10186   return NULL;
10187 }
10188
10189
10190 SWIGINTERN PyObject *VectorEdges_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10191   PyObject *obj;
10192   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
10193   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, SWIG_NewClientData(obj));
10194   return SWIG_Py_Void();
10195 }
10196
10197 SWIGINTERN PyObject *_wrap_VectorVertices_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10198   PyObject *resultobj = 0;
10199   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10200   PyObject **arg2 = (PyObject **) 0 ;
10201   swig::PySwigIterator *result = 0 ;
10202   void *argp1 = 0 ;
10203   int res1 = 0 ;
10204   PyObject * obj0 = 0 ;
10205
10206   arg2 = &obj0;
10207   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_iterator",&obj0)) SWIG_fail;
10208   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10209   if (!SWIG_IsOK(res1)) {
10210     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_iterator" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10211   }
10212   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10213   result = (swig::PySwigIterator *)std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(arg1,arg2);
10214   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
10215   return resultobj;
10216 fail:
10217   return NULL;
10218 }
10219
10220
10221 SWIGINTERN PyObject *_wrap_VectorVertices___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10222   PyObject *resultobj = 0;
10223   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10224   bool result;
10225   void *argp1 = 0 ;
10226   int res1 = 0 ;
10227   PyObject * obj0 = 0 ;
10228
10229   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___nonzero__",&obj0)) SWIG_fail;
10230   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10231   if (!SWIG_IsOK(res1)) {
10232     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10233   }
10234   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10235   result = (bool)std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__((std::vector<Hex::Vertex * > const *)arg1);
10236   resultobj = SWIG_From_bool(static_cast< bool >(result));
10237   return resultobj;
10238 fail:
10239   return NULL;
10240 }
10241
10242
10243 SWIGINTERN PyObject *_wrap_VectorVertices___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10244   PyObject *resultobj = 0;
10245   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10246   std::vector<Hex::Vertex * >::size_type result;
10247   void *argp1 = 0 ;
10248   int res1 = 0 ;
10249   PyObject * obj0 = 0 ;
10250
10251   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___len__",&obj0)) SWIG_fail;
10252   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10253   if (!SWIG_IsOK(res1)) {
10254     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___len__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10255   }
10256   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10257   result = std_vector_Sl_Hex_Vertex_Sm__Sg____len__((std::vector<Hex::Vertex * > const *)arg1);
10258   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10259   return resultobj;
10260 fail:
10261   return NULL;
10262 }
10263
10264
10265 SWIGINTERN PyObject *_wrap_VectorVertices_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10266   PyObject *resultobj = 0;
10267   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10268   std::vector<Hex::Vertex * >::value_type result;
10269   void *argp1 = 0 ;
10270   int res1 = 0 ;
10271   PyObject * obj0 = 0 ;
10272
10273   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop",&obj0)) SWIG_fail;
10274   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10275   if (!SWIG_IsOK(res1)) {
10276     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10277   }
10278   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10279   try {
10280     result = (std::vector<Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg__pop(arg1);
10281   }
10282   catch(std::out_of_range &_e) {
10283     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10284   }
10285
10286   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
10287   return resultobj;
10288 fail:
10289   return NULL;
10290 }
10291
10292
10293 SWIGINTERN PyObject *_wrap_VectorVertices___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10294   PyObject *resultobj = 0;
10295   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10296   std::vector<Hex::Vertex * >::difference_type arg2 ;
10297   std::vector<Hex::Vertex * >::difference_type arg3 ;
10298   std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *result = 0 ;
10299   void *argp1 = 0 ;
10300   int res1 = 0 ;
10301   ptrdiff_t val2 ;
10302   int ecode2 = 0 ;
10303   ptrdiff_t val3 ;
10304   int ecode3 = 0 ;
10305   PyObject * obj0 = 0 ;
10306   PyObject * obj1 = 0 ;
10307   PyObject * obj2 = 0 ;
10308
10309   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
10310   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10311   if (!SWIG_IsOK(res1)) {
10312     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getslice__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10313   }
10314   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10315   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10316   if (!SWIG_IsOK(ecode2)) {
10317     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getslice__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10318   }
10319   arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10320   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10321   if (!SWIG_IsOK(ecode3)) {
10322     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___getslice__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10323   }
10324   arg3 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val3);
10325   try {
10326     result = (std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *)std_vector_Sl_Hex_Vertex_Sm__Sg____getslice__(arg1,arg2,arg3);
10327   }
10328   catch(std::out_of_range &_e) {
10329     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10330   }
10331
10332   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_OWN |  0 );
10333   return resultobj;
10334 fail:
10335   return NULL;
10336 }
10337
10338
10339 SWIGINTERN PyObject *_wrap_VectorVertices___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10340   PyObject *resultobj = 0;
10341   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10342   std::vector<Hex::Vertex * >::difference_type arg2 ;
10343   std::vector<Hex::Vertex * >::difference_type arg3 ;
10344   std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *arg4 = 0 ;
10345   void *argp1 = 0 ;
10346   int res1 = 0 ;
10347   ptrdiff_t val2 ;
10348   int ecode2 = 0 ;
10349   ptrdiff_t val3 ;
10350   int ecode3 = 0 ;
10351   int res4 = SWIG_OLDOBJ ;
10352   PyObject * obj0 = 0 ;
10353   PyObject * obj1 = 0 ;
10354   PyObject * obj2 = 0 ;
10355   PyObject * obj3 = 0 ;
10356
10357   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10358   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10359   if (!SWIG_IsOK(res1)) {
10360     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setslice__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10361   }
10362   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10363   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10364   if (!SWIG_IsOK(ecode2)) {
10365     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setslice__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10366   }
10367   arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10368   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10369   if (!SWIG_IsOK(ecode3)) {
10370     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___setslice__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10371   }
10372   arg3 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val3);
10373   {
10374     std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *)0;
10375     res4 = swig::asptr(obj3, &ptr);
10376     if (!SWIG_IsOK(res4)) {
10377       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices___setslice__" "', argument " "4"" of type '" "std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > const &""'");
10378     }
10379     if (!ptr) {
10380       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 &""'");
10381     }
10382     arg4 = ptr;
10383   }
10384   try {
10385     std_vector_Sl_Hex_Vertex_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > const &)*arg4);
10386   }
10387   catch(std::out_of_range &_e) {
10388     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10389   }
10390   catch(std::invalid_argument &_e) {
10391     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10392   }
10393
10394   resultobj = SWIG_Py_Void();
10395   if (SWIG_IsNewObj(res4)) delete arg4;
10396   return resultobj;
10397 fail:
10398   if (SWIG_IsNewObj(res4)) delete arg4;
10399   return NULL;
10400 }
10401
10402
10403 SWIGINTERN PyObject *_wrap_VectorVertices___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10404   PyObject *resultobj = 0;
10405   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10406   std::vector<Hex::Vertex * >::difference_type arg2 ;
10407   std::vector<Hex::Vertex * >::difference_type arg3 ;
10408   void *argp1 = 0 ;
10409   int res1 = 0 ;
10410   ptrdiff_t val2 ;
10411   int ecode2 = 0 ;
10412   ptrdiff_t val3 ;
10413   int ecode3 = 0 ;
10414   PyObject * obj0 = 0 ;
10415   PyObject * obj1 = 0 ;
10416   PyObject * obj2 = 0 ;
10417
10418   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
10419   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10420   if (!SWIG_IsOK(res1)) {
10421     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delslice__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10422   }
10423   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10424   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10425   if (!SWIG_IsOK(ecode2)) {
10426     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delslice__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10427   }
10428   arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10429   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10430   if (!SWIG_IsOK(ecode3)) {
10431     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___delslice__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10432   }
10433   arg3 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val3);
10434   try {
10435     std_vector_Sl_Hex_Vertex_Sm__Sg____delslice__(arg1,arg2,arg3);
10436   }
10437   catch(std::out_of_range &_e) {
10438     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10439   }
10440
10441   resultobj = SWIG_Py_Void();
10442   return resultobj;
10443 fail:
10444   return NULL;
10445 }
10446
10447
10448 SWIGINTERN PyObject *_wrap_VectorVertices___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10449   PyObject *resultobj = 0;
10450   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10451   std::vector<Hex::Vertex * >::difference_type arg2 ;
10452   void *argp1 = 0 ;
10453   int res1 = 0 ;
10454   ptrdiff_t val2 ;
10455   int ecode2 = 0 ;
10456   PyObject * obj0 = 0 ;
10457   PyObject * obj1 = 0 ;
10458
10459   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___delitem__",&obj0,&obj1)) SWIG_fail;
10460   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10461   if (!SWIG_IsOK(res1)) {
10462     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delitem__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10463   }
10464   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10465   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10466   if (!SWIG_IsOK(ecode2)) {
10467     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delitem__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10468   }
10469   arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10470   try {
10471     std_vector_Sl_Hex_Vertex_Sm__Sg____delitem__(arg1,arg2);
10472   }
10473   catch(std::out_of_range &_e) {
10474     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10475   }
10476
10477   resultobj = SWIG_Py_Void();
10478   return resultobj;
10479 fail:
10480   return NULL;
10481 }
10482
10483
10484 SWIGINTERN PyObject *_wrap_VectorVertices___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10485   PyObject *resultobj = 0;
10486   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10487   std::vector<Hex::Vertex * >::difference_type arg2 ;
10488   std::vector<Hex::Vertex * >::value_type result;
10489   void *argp1 = 0 ;
10490   int res1 = 0 ;
10491   ptrdiff_t val2 ;
10492   int ecode2 = 0 ;
10493   PyObject * obj0 = 0 ;
10494   PyObject * obj1 = 0 ;
10495
10496   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___getitem__",&obj0,&obj1)) SWIG_fail;
10497   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10498   if (!SWIG_IsOK(res1)) {
10499     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getitem__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10500   }
10501   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10502   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10503   if (!SWIG_IsOK(ecode2)) {
10504     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getitem__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10505   }
10506   arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10507   try {
10508     result = (std::vector<Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg____getitem__(arg1,arg2);
10509   }
10510   catch(std::out_of_range &_e) {
10511     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10512   }
10513
10514   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
10515   return resultobj;
10516 fail:
10517   return NULL;
10518 }
10519
10520
10521 SWIGINTERN PyObject *_wrap_VectorVertices___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10522   PyObject *resultobj = 0;
10523   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10524   std::vector<Hex::Vertex * >::difference_type arg2 ;
10525   std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
10526   void *argp1 = 0 ;
10527   int res1 = 0 ;
10528   ptrdiff_t val2 ;
10529   int ecode2 = 0 ;
10530   void *argp3 = 0 ;
10531   int res3 = 0 ;
10532   PyObject * obj0 = 0 ;
10533   PyObject * obj1 = 0 ;
10534   PyObject * obj2 = 0 ;
10535
10536   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
10537   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10538   if (!SWIG_IsOK(res1)) {
10539     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10540   }
10541   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10542   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10543   if (!SWIG_IsOK(ecode2)) {
10544     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setitem__" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::difference_type""'");
10545   }
10546   arg2 = static_cast< std::vector<Hex::Vertex * >::difference_type >(val2);
10547   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
10548   if (!SWIG_IsOK(res3)) {
10549     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
10550   }
10551   arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
10552   try {
10553     std_vector_Sl_Hex_Vertex_Sm__Sg____setitem__(arg1,arg2,arg3);
10554   }
10555   catch(std::out_of_range &_e) {
10556     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10557   }
10558
10559   resultobj = SWIG_Py_Void();
10560   return resultobj;
10561 fail:
10562   return NULL;
10563 }
10564
10565
10566 SWIGINTERN PyObject *_wrap_VectorVertices_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10567   PyObject *resultobj = 0;
10568   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10569   std::vector<Hex::Vertex * >::value_type arg2 = (std::vector<Hex::Vertex * >::value_type) 0 ;
10570   void *argp1 = 0 ;
10571   int res1 = 0 ;
10572   void *argp2 = 0 ;
10573   int res2 = 0 ;
10574   PyObject * obj0 = 0 ;
10575   PyObject * obj1 = 0 ;
10576
10577   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_append",&obj0,&obj1)) SWIG_fail;
10578   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10579   if (!SWIG_IsOK(res1)) {
10580     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_append" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10581   }
10582   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10583   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
10584   if (!SWIG_IsOK(res2)) {
10585     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_append" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
10586   }
10587   arg2 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp2);
10588   std_vector_Sl_Hex_Vertex_Sm__Sg__append(arg1,arg2);
10589   resultobj = SWIG_Py_Void();
10590   return resultobj;
10591 fail:
10592   return NULL;
10593 }
10594
10595
10596 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10597   PyObject *resultobj = 0;
10598   std::vector<Hex::Vertex * > *result = 0 ;
10599
10600   if (!PyArg_ParseTuple(args,(char *)":new_VectorVertices")) SWIG_fail;
10601   result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >();
10602   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
10603   return resultobj;
10604 fail:
10605   return NULL;
10606 }
10607
10608
10609 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10610   PyObject *resultobj = 0;
10611   std::vector<Hex::Vertex * > *arg1 = 0 ;
10612   std::vector<Hex::Vertex * > *result = 0 ;
10613   int res1 = SWIG_OLDOBJ ;
10614   PyObject * obj0 = 0 ;
10615
10616   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
10617   {
10618     std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *ptr = (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > > *)0;
10619     res1 = swig::asptr(obj0, &ptr);
10620     if (!SWIG_IsOK(res1)) {
10621       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const &""'");
10622     }
10623     if (!ptr) {
10624       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const &""'");
10625     }
10626     arg1 = ptr;
10627   }
10628   result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >((std::vector<Hex::Vertex * > const &)*arg1);
10629   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
10630   if (SWIG_IsNewObj(res1)) delete arg1;
10631   return resultobj;
10632 fail:
10633   if (SWIG_IsNewObj(res1)) delete arg1;
10634   return NULL;
10635 }
10636
10637
10638 SWIGINTERN PyObject *_wrap_VectorVertices_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10639   PyObject *resultobj = 0;
10640   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10641   bool result;
10642   void *argp1 = 0 ;
10643   int res1 = 0 ;
10644   PyObject * obj0 = 0 ;
10645
10646   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_empty",&obj0)) SWIG_fail;
10647   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10648   if (!SWIG_IsOK(res1)) {
10649     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_empty" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10650   }
10651   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10652   result = (bool)((std::vector<Hex::Vertex * > const *)arg1)->empty();
10653   resultobj = SWIG_From_bool(static_cast< bool >(result));
10654   return resultobj;
10655 fail:
10656   return NULL;
10657 }
10658
10659
10660 SWIGINTERN PyObject *_wrap_VectorVertices_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10661   PyObject *resultobj = 0;
10662   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10663   std::vector<Hex::Vertex * >::size_type result;
10664   void *argp1 = 0 ;
10665   int res1 = 0 ;
10666   PyObject * obj0 = 0 ;
10667
10668   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_size",&obj0)) SWIG_fail;
10669   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10670   if (!SWIG_IsOK(res1)) {
10671     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_size" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10672   }
10673   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10674   result = ((std::vector<Hex::Vertex * > const *)arg1)->size();
10675   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10676   return resultobj;
10677 fail:
10678   return NULL;
10679 }
10680
10681
10682 SWIGINTERN PyObject *_wrap_VectorVertices_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10683   PyObject *resultobj = 0;
10684   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10685   void *argp1 = 0 ;
10686   int res1 = 0 ;
10687   PyObject * obj0 = 0 ;
10688
10689   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_clear",&obj0)) SWIG_fail;
10690   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10691   if (!SWIG_IsOK(res1)) {
10692     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_clear" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10693   }
10694   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10695   (arg1)->clear();
10696   resultobj = SWIG_Py_Void();
10697   return resultobj;
10698 fail:
10699   return NULL;
10700 }
10701
10702
10703 SWIGINTERN PyObject *_wrap_VectorVertices_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10704   PyObject *resultobj = 0;
10705   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10706   std::vector<Hex::Vertex * > *arg2 = 0 ;
10707   void *argp1 = 0 ;
10708   int res1 = 0 ;
10709   void *argp2 = 0 ;
10710   int res2 = 0 ;
10711   PyObject * obj0 = 0 ;
10712   PyObject * obj1 = 0 ;
10713
10714   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_swap",&obj0,&obj1)) SWIG_fail;
10715   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10716   if (!SWIG_IsOK(res1)) {
10717     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_swap" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10718   }
10719   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10720   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t,  0 );
10721   if (!SWIG_IsOK(res2)) {
10722     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector<Hex::Vertex * > &""'");
10723   }
10724   if (!argp2) {
10725     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector<Hex::Vertex * > &""'");
10726   }
10727   arg2 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp2);
10728   (arg1)->swap(*arg2);
10729   resultobj = SWIG_Py_Void();
10730   return resultobj;
10731 fail:
10732   return NULL;
10733 }
10734
10735
10736 SWIGINTERN PyObject *_wrap_VectorVertices_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10737   PyObject *resultobj = 0;
10738   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10739   SwigValueWrapper<std::allocator<Hex::Vertex * > > result;
10740   void *argp1 = 0 ;
10741   int res1 = 0 ;
10742   PyObject * obj0 = 0 ;
10743
10744   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_get_allocator",&obj0)) SWIG_fail;
10745   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10746   if (!SWIG_IsOK(res1)) {
10747     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10748   }
10749   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10750   result = ((std::vector<Hex::Vertex * > const *)arg1)->get_allocator();
10751   resultobj = SWIG_NewPointerObj((new std::vector<Hex::Vertex * >::allocator_type(static_cast< const std::vector<Hex::Vertex * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
10752   return resultobj;
10753 fail:
10754   return NULL;
10755 }
10756
10757
10758 SWIGINTERN PyObject *_wrap_VectorVertices_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10759   PyObject *resultobj = 0;
10760   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10761   std::vector<Hex::Vertex * >::iterator result;
10762   void *argp1 = 0 ;
10763   int res1 = 0 ;
10764   PyObject * obj0 = 0 ;
10765
10766   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_begin",&obj0)) SWIG_fail;
10767   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10768   if (!SWIG_IsOK(res1)) {
10769     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_begin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10770   }
10771   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10772   result = (arg1)->begin();
10773   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
10774     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10775   return resultobj;
10776 fail:
10777   return NULL;
10778 }
10779
10780
10781 SWIGINTERN PyObject *_wrap_VectorVertices_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10782   PyObject *resultobj = 0;
10783   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10784   std::vector<Hex::Vertex * >::const_iterator result;
10785   void *argp1 = 0 ;
10786   int res1 = 0 ;
10787   PyObject * obj0 = 0 ;
10788
10789   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_begin",&obj0)) SWIG_fail;
10790   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10791   if (!SWIG_IsOK(res1)) {
10792     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_begin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10793   }
10794   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10795   result = ((std::vector<Hex::Vertex * > const *)arg1)->begin();
10796   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_iterator & >(result)),
10797     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10798   return resultobj;
10799 fail:
10800   return NULL;
10801 }
10802
10803
10804 SWIGINTERN PyObject *_wrap_VectorVertices_begin(PyObject *self, PyObject *args) {
10805   int argc;
10806   PyObject *argv[2];
10807   int ii;
10808
10809   if (!PyTuple_Check(args)) SWIG_fail;
10810   argc = PyObject_Length(args);
10811   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
10812     argv[ii] = PyTuple_GET_ITEM(args,ii);
10813   }
10814   if (argc == 1) {
10815     int _v;
10816     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10817     _v = SWIG_CheckState(res);
10818     if (_v) {
10819       return _wrap_VectorVertices_begin__SWIG_0(self, args);
10820     }
10821   }
10822   if (argc == 1) {
10823     int _v;
10824     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10825     _v = SWIG_CheckState(res);
10826     if (_v) {
10827       return _wrap_VectorVertices_begin__SWIG_1(self, args);
10828     }
10829   }
10830
10831 fail:
10832   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
10833   return NULL;
10834 }
10835
10836
10837 SWIGINTERN PyObject *_wrap_VectorVertices_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10838   PyObject *resultobj = 0;
10839   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10840   std::vector<Hex::Vertex * >::iterator result;
10841   void *argp1 = 0 ;
10842   int res1 = 0 ;
10843   PyObject * obj0 = 0 ;
10844
10845   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_end",&obj0)) SWIG_fail;
10846   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10847   if (!SWIG_IsOK(res1)) {
10848     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_end" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10849   }
10850   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10851   result = (arg1)->end();
10852   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
10853     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10854   return resultobj;
10855 fail:
10856   return NULL;
10857 }
10858
10859
10860 SWIGINTERN PyObject *_wrap_VectorVertices_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10861   PyObject *resultobj = 0;
10862   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10863   std::vector<Hex::Vertex * >::const_iterator result;
10864   void *argp1 = 0 ;
10865   int res1 = 0 ;
10866   PyObject * obj0 = 0 ;
10867
10868   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_end",&obj0)) SWIG_fail;
10869   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10870   if (!SWIG_IsOK(res1)) {
10871     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_end" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10872   }
10873   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10874   result = ((std::vector<Hex::Vertex * > const *)arg1)->end();
10875   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_iterator & >(result)),
10876     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10877   return resultobj;
10878 fail:
10879   return NULL;
10880 }
10881
10882
10883 SWIGINTERN PyObject *_wrap_VectorVertices_end(PyObject *self, PyObject *args) {
10884   int argc;
10885   PyObject *argv[2];
10886   int ii;
10887
10888   if (!PyTuple_Check(args)) SWIG_fail;
10889   argc = PyObject_Length(args);
10890   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
10891     argv[ii] = PyTuple_GET_ITEM(args,ii);
10892   }
10893   if (argc == 1) {
10894     int _v;
10895     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10896     _v = SWIG_CheckState(res);
10897     if (_v) {
10898       return _wrap_VectorVertices_end__SWIG_0(self, args);
10899     }
10900   }
10901   if (argc == 1) {
10902     int _v;
10903     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10904     _v = SWIG_CheckState(res);
10905     if (_v) {
10906       return _wrap_VectorVertices_end__SWIG_1(self, args);
10907     }
10908   }
10909
10910 fail:
10911   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
10912   return NULL;
10913 }
10914
10915
10916 SWIGINTERN PyObject *_wrap_VectorVertices_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10917   PyObject *resultobj = 0;
10918   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10919   std::vector<Hex::Vertex * >::reverse_iterator result;
10920   void *argp1 = 0 ;
10921   int res1 = 0 ;
10922   PyObject * obj0 = 0 ;
10923
10924   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rbegin",&obj0)) SWIG_fail;
10925   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10926   if (!SWIG_IsOK(res1)) {
10927     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
10928   }
10929   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10930   result = (arg1)->rbegin();
10931   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::reverse_iterator & >(result)),
10932     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10933   return resultobj;
10934 fail:
10935   return NULL;
10936 }
10937
10938
10939 SWIGINTERN PyObject *_wrap_VectorVertices_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10940   PyObject *resultobj = 0;
10941   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10942   std::vector<Hex::Vertex * >::const_reverse_iterator result;
10943   void *argp1 = 0 ;
10944   int res1 = 0 ;
10945   PyObject * obj0 = 0 ;
10946
10947   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rbegin",&obj0)) SWIG_fail;
10948   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
10949   if (!SWIG_IsOK(res1)) {
10950     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rbegin" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
10951   }
10952   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
10953   result = ((std::vector<Hex::Vertex * > const *)arg1)->rbegin();
10954   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_reverse_iterator & >(result)),
10955     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
10956   return resultobj;
10957 fail:
10958   return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *_wrap_VectorVertices_rbegin(PyObject *self, PyObject *args) {
10963   int argc;
10964   PyObject *argv[2];
10965   int ii;
10966
10967   if (!PyTuple_Check(args)) SWIG_fail;
10968   argc = PyObject_Length(args);
10969   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
10970     argv[ii] = PyTuple_GET_ITEM(args,ii);
10971   }
10972   if (argc == 1) {
10973     int _v;
10974     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10975     _v = SWIG_CheckState(res);
10976     if (_v) {
10977       return _wrap_VectorVertices_rbegin__SWIG_0(self, args);
10978     }
10979   }
10980   if (argc == 1) {
10981     int _v;
10982     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
10983     _v = SWIG_CheckState(res);
10984     if (_v) {
10985       return _wrap_VectorVertices_rbegin__SWIG_1(self, args);
10986     }
10987   }
10988
10989 fail:
10990   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
10991   return NULL;
10992 }
10993
10994
10995 SWIGINTERN PyObject *_wrap_VectorVertices_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10996   PyObject *resultobj = 0;
10997   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
10998   std::vector<Hex::Vertex * >::reverse_iterator result;
10999   void *argp1 = 0 ;
11000   int res1 = 0 ;
11001   PyObject * obj0 = 0 ;
11002
11003   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rend",&obj0)) SWIG_fail;
11004   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11005   if (!SWIG_IsOK(res1)) {
11006     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rend" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11007   }
11008   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11009   result = (arg1)->rend();
11010   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::reverse_iterator & >(result)),
11011     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
11012   return resultobj;
11013 fail:
11014   return NULL;
11015 }
11016
11017
11018 SWIGINTERN PyObject *_wrap_VectorVertices_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019   PyObject *resultobj = 0;
11020   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11021   std::vector<Hex::Vertex * >::const_reverse_iterator result;
11022   void *argp1 = 0 ;
11023   int res1 = 0 ;
11024   PyObject * obj0 = 0 ;
11025
11026   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rend",&obj0)) SWIG_fail;
11027   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11028   if (!SWIG_IsOK(res1)) {
11029     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rend" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
11030   }
11031   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11032   result = ((std::vector<Hex::Vertex * > const *)arg1)->rend();
11033   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::const_reverse_iterator & >(result)),
11034     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
11035   return resultobj;
11036 fail:
11037   return NULL;
11038 }
11039
11040
11041 SWIGINTERN PyObject *_wrap_VectorVertices_rend(PyObject *self, PyObject *args) {
11042   int argc;
11043   PyObject *argv[2];
11044   int ii;
11045
11046   if (!PyTuple_Check(args)) SWIG_fail;
11047   argc = PyObject_Length(args);
11048   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
11049     argv[ii] = PyTuple_GET_ITEM(args,ii);
11050   }
11051   if (argc == 1) {
11052     int _v;
11053     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11054     _v = SWIG_CheckState(res);
11055     if (_v) {
11056       return _wrap_VectorVertices_rend__SWIG_0(self, args);
11057     }
11058   }
11059   if (argc == 1) {
11060     int _v;
11061     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11062     _v = SWIG_CheckState(res);
11063     if (_v) {
11064       return _wrap_VectorVertices_rend__SWIG_1(self, args);
11065     }
11066   }
11067
11068 fail:
11069   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
11070   return NULL;
11071 }
11072
11073
11074 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11075   PyObject *resultobj = 0;
11076   std::vector<Hex::Vertex * >::size_type arg1 ;
11077   std::vector<Hex::Vertex * > *result = 0 ;
11078   size_t val1 ;
11079   int ecode1 = 0 ;
11080   PyObject * obj0 = 0 ;
11081
11082   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
11083   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11084   if (!SWIG_IsOK(ecode1)) {
11085     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11086   }
11087   arg1 = static_cast< std::vector<Hex::Vertex * >::size_type >(val1);
11088   result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >(arg1);
11089   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
11090   return resultobj;
11091 fail:
11092   return NULL;
11093 }
11094
11095
11096 SWIGINTERN PyObject *_wrap_VectorVertices_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11097   PyObject *resultobj = 0;
11098   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11099   void *argp1 = 0 ;
11100   int res1 = 0 ;
11101   PyObject * obj0 = 0 ;
11102
11103   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop_back",&obj0)) SWIG_fail;
11104   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11105   if (!SWIG_IsOK(res1)) {
11106     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop_back" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11107   }
11108   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11109   (arg1)->pop_back();
11110   resultobj = SWIG_Py_Void();
11111   return resultobj;
11112 fail:
11113   return NULL;
11114 }
11115
11116
11117 SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11118   PyObject *resultobj = 0;
11119   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11120   std::vector<Hex::Vertex * >::size_type arg2 ;
11121   void *argp1 = 0 ;
11122   int res1 = 0 ;
11123   size_t val2 ;
11124   int ecode2 = 0 ;
11125   PyObject * obj0 = 0 ;
11126   PyObject * obj1 = 0 ;
11127
11128   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_resize",&obj0,&obj1)) SWIG_fail;
11129   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11130   if (!SWIG_IsOK(res1)) {
11131     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11132   }
11133   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11134   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11135   if (!SWIG_IsOK(ecode2)) {
11136     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11137   }
11138   arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
11139   (arg1)->resize(arg2);
11140   resultobj = SWIG_Py_Void();
11141   return resultobj;
11142 fail:
11143   return NULL;
11144 }
11145
11146
11147 SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11148   PyObject *resultobj = 0;
11149   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11150   std::vector<Hex::Vertex * >::iterator arg2 ;
11151   std::vector<Hex::Vertex * >::iterator result;
11152   void *argp1 = 0 ;
11153   int res1 = 0 ;
11154   swig::PySwigIterator *iter2 = 0 ;
11155   int res2 ;
11156   PyObject * obj0 = 0 ;
11157   PyObject * obj1 = 0 ;
11158
11159   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_erase",&obj0,&obj1)) SWIG_fail;
11160   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11161   if (!SWIG_IsOK(res1)) {
11162     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11163   }
11164   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11165   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
11166   if (!SWIG_IsOK(res2) || !iter2) {
11167     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11168   } else {
11169     swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
11170     if (iter_t) {
11171       arg2 = iter_t->get_current();
11172     } else {
11173       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11174     }
11175   }
11176   result = (arg1)->erase(arg2);
11177   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
11178     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
11179   return resultobj;
11180 fail:
11181   return NULL;
11182 }
11183
11184
11185 SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11186   PyObject *resultobj = 0;
11187   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11188   std::vector<Hex::Vertex * >::iterator arg2 ;
11189   std::vector<Hex::Vertex * >::iterator arg3 ;
11190   std::vector<Hex::Vertex * >::iterator result;
11191   void *argp1 = 0 ;
11192   int res1 = 0 ;
11193   swig::PySwigIterator *iter2 = 0 ;
11194   int res2 ;
11195   swig::PySwigIterator *iter3 = 0 ;
11196   int res3 ;
11197   PyObject * obj0 = 0 ;
11198   PyObject * obj1 = 0 ;
11199   PyObject * obj2 = 0 ;
11200
11201   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_erase",&obj0,&obj1,&obj2)) SWIG_fail;
11202   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11203   if (!SWIG_IsOK(res1)) {
11204     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11205   }
11206   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11207   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
11208   if (!SWIG_IsOK(res2) || !iter2) {
11209     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11210   } else {
11211     swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
11212     if (iter_t) {
11213       arg2 = iter_t->get_current();
11214     } else {
11215       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11216     }
11217   }
11218   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
11219   if (!SWIG_IsOK(res3) || !iter3) {
11220     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11221   } else {
11222     swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter3);
11223     if (iter_t) {
11224       arg3 = iter_t->get_current();
11225     } else {
11226       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11227     }
11228   }
11229   result = (arg1)->erase(arg2,arg3);
11230   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
11231     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
11232   return resultobj;
11233 fail:
11234   return NULL;
11235 }
11236
11237
11238 SWIGINTERN PyObject *_wrap_VectorVertices_erase(PyObject *self, PyObject *args) {
11239   int argc;
11240   PyObject *argv[4];
11241   int ii;
11242
11243   if (!PyTuple_Check(args)) SWIG_fail;
11244   argc = PyObject_Length(args);
11245   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11246     argv[ii] = PyTuple_GET_ITEM(args,ii);
11247   }
11248   if (argc == 2) {
11249     int _v;
11250     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11251     _v = SWIG_CheckState(res);
11252     if (_v) {
11253       swig::PySwigIterator *iter = 0;
11254       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
11255       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
11256       if (_v) {
11257         return _wrap_VectorVertices_erase__SWIG_0(self, args);
11258       }
11259     }
11260   }
11261   if (argc == 3) {
11262     int _v;
11263     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11264     _v = SWIG_CheckState(res);
11265     if (_v) {
11266       swig::PySwigIterator *iter = 0;
11267       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
11268       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
11269       if (_v) {
11270         swig::PySwigIterator *iter = 0;
11271         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
11272         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
11273         if (_v) {
11274           return _wrap_VectorVertices_erase__SWIG_1(self, args);
11275         }
11276       }
11277     }
11278   }
11279
11280 fail:
11281   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<Hex::Vertex * >::iterator)\n    erase(std::vector<Hex::Vertex * >::iterator,std::vector<Hex::Vertex * >::iterator)\n");
11282   return NULL;
11283 }
11284
11285
11286 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11287   PyObject *resultobj = 0;
11288   std::vector<Hex::Vertex * >::size_type arg1 ;
11289   std::vector<Hex::Vertex * >::value_type arg2 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11290   std::vector<Hex::Vertex * > *result = 0 ;
11291   size_t val1 ;
11292   int ecode1 = 0 ;
11293   void *argp2 = 0 ;
11294   int res2 = 0 ;
11295   PyObject * obj0 = 0 ;
11296   PyObject * obj1 = 0 ;
11297
11298   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorVertices",&obj0,&obj1)) SWIG_fail;
11299   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11300   if (!SWIG_IsOK(ecode1)) {
11301     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11302   }
11303   arg1 = static_cast< std::vector<Hex::Vertex * >::size_type >(val1);
11304   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
11305   if (!SWIG_IsOK(res2)) {
11306     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorVertices" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11307   }
11308   arg2 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp2);
11309   result = (std::vector<Hex::Vertex * > *)new std::vector<Hex::Vertex * >(arg1,arg2);
11310   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
11311   return resultobj;
11312 fail:
11313   return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap_new_VectorVertices(PyObject *self, PyObject *args) {
11318   int argc;
11319   PyObject *argv[3];
11320   int ii;
11321
11322   if (!PyTuple_Check(args)) SWIG_fail;
11323   argc = PyObject_Length(args);
11324   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
11325     argv[ii] = PyTuple_GET_ITEM(args,ii);
11326   }
11327   if (argc == 0) {
11328     return _wrap_new_VectorVertices__SWIG_0(self, args);
11329   }
11330   if (argc == 1) {
11331     int _v;
11332     {
11333       int res = SWIG_AsVal_size_t(argv[0], NULL);
11334       _v = SWIG_CheckState(res);
11335     }
11336     if (_v) {
11337       return _wrap_new_VectorVertices__SWIG_2(self, args);
11338     }
11339   }
11340   if (argc == 1) {
11341     int _v;
11342     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11343     _v = SWIG_CheckState(res);
11344     if (_v) {
11345       return _wrap_new_VectorVertices__SWIG_1(self, args);
11346     }
11347   }
11348   if (argc == 2) {
11349     int _v;
11350     {
11351       int res = SWIG_AsVal_size_t(argv[0], NULL);
11352       _v = SWIG_CheckState(res);
11353     }
11354     if (_v) {
11355       void *vptr = 0;
11356       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
11357       _v = SWIG_CheckState(res);
11358       if (_v) {
11359         return _wrap_new_VectorVertices__SWIG_3(self, args);
11360       }
11361     }
11362   }
11363
11364 fail:
11365   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorVertices'.\n  Possible C/C++ prototypes are:\n    std::vector<(p.Hex::Vertex)>()\n    std::vector<(p.Hex::Vertex)>(std::vector<Hex::Vertex * > const &)\n    std::vector<(p.Hex::Vertex)>(std::vector<Hex::Vertex * >::size_type)\n    std::vector<(p.Hex::Vertex)>(std::vector<Hex::Vertex * >::size_type,std::vector<Hex::Vertex * >::value_type)\n");
11366   return NULL;
11367 }
11368
11369
11370 SWIGINTERN PyObject *_wrap_VectorVertices_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11371   PyObject *resultobj = 0;
11372   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11373   std::vector<Hex::Vertex * >::value_type arg2 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11374   void *argp1 = 0 ;
11375   int res1 = 0 ;
11376   void *argp2 = 0 ;
11377   int res2 = 0 ;
11378   PyObject * obj0 = 0 ;
11379   PyObject * obj1 = 0 ;
11380
11381   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_push_back",&obj0,&obj1)) SWIG_fail;
11382   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11383   if (!SWIG_IsOK(res1)) {
11384     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_push_back" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11385   }
11386   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11387   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
11388   if (!SWIG_IsOK(res2)) {
11389     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_push_back" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11390   }
11391   arg2 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp2);
11392   (arg1)->push_back(arg2);
11393   resultobj = SWIG_Py_Void();
11394   return resultobj;
11395 fail:
11396   return NULL;
11397 }
11398
11399
11400 SWIGINTERN PyObject *_wrap_VectorVertices_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11401   PyObject *resultobj = 0;
11402   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11403   std::vector<Hex::Vertex * >::value_type result;
11404   void *argp1 = 0 ;
11405   int res1 = 0 ;
11406   PyObject * obj0 = 0 ;
11407
11408   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_front",&obj0)) SWIG_fail;
11409   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11410   if (!SWIG_IsOK(res1)) {
11411     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_front" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
11412   }
11413   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11414   result = (std::vector<Hex::Vertex * >::value_type)((std::vector<Hex::Vertex * > const *)arg1)->front();
11415   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
11416   return resultobj;
11417 fail:
11418   return NULL;
11419 }
11420
11421
11422 SWIGINTERN PyObject *_wrap_VectorVertices_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11423   PyObject *resultobj = 0;
11424   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11425   std::vector<Hex::Vertex * >::value_type result;
11426   void *argp1 = 0 ;
11427   int res1 = 0 ;
11428   PyObject * obj0 = 0 ;
11429
11430   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_back",&obj0)) SWIG_fail;
11431   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11432   if (!SWIG_IsOK(res1)) {
11433     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_back" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
11434   }
11435   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11436   result = (std::vector<Hex::Vertex * >::value_type)((std::vector<Hex::Vertex * > const *)arg1)->back();
11437   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
11438   return resultobj;
11439 fail:
11440   return NULL;
11441 }
11442
11443
11444 SWIGINTERN PyObject *_wrap_VectorVertices_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11445   PyObject *resultobj = 0;
11446   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11447   std::vector<Hex::Vertex * >::size_type arg2 ;
11448   std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11449   void *argp1 = 0 ;
11450   int res1 = 0 ;
11451   size_t val2 ;
11452   int ecode2 = 0 ;
11453   void *argp3 = 0 ;
11454   int res3 = 0 ;
11455   PyObject * obj0 = 0 ;
11456   PyObject * obj1 = 0 ;
11457   PyObject * obj2 = 0 ;
11458
11459   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_assign",&obj0,&obj1,&obj2)) SWIG_fail;
11460   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11461   if (!SWIG_IsOK(res1)) {
11462     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_assign" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11463   }
11464   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11465   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11466   if (!SWIG_IsOK(ecode2)) {
11467     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_assign" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11468   }
11469   arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
11470   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
11471   if (!SWIG_IsOK(res3)) {
11472     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_assign" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11473   }
11474   arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
11475   (arg1)->assign(arg2,arg3);
11476   resultobj = SWIG_Py_Void();
11477   return resultobj;
11478 fail:
11479   return NULL;
11480 }
11481
11482
11483 SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11484   PyObject *resultobj = 0;
11485   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11486   std::vector<Hex::Vertex * >::size_type arg2 ;
11487   std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11488   void *argp1 = 0 ;
11489   int res1 = 0 ;
11490   size_t val2 ;
11491   int ecode2 = 0 ;
11492   void *argp3 = 0 ;
11493   int res3 = 0 ;
11494   PyObject * obj0 = 0 ;
11495   PyObject * obj1 = 0 ;
11496   PyObject * obj2 = 0 ;
11497
11498   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_resize",&obj0,&obj1,&obj2)) SWIG_fail;
11499   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11500   if (!SWIG_IsOK(res1)) {
11501     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11502   }
11503   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11504   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11505   if (!SWIG_IsOK(ecode2)) {
11506     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11507   }
11508   arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
11509   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
11510   if (!SWIG_IsOK(res3)) {
11511     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_resize" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11512   }
11513   arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
11514   (arg1)->resize(arg2,arg3);
11515   resultobj = SWIG_Py_Void();
11516   return resultobj;
11517 fail:
11518   return NULL;
11519 }
11520
11521
11522 SWIGINTERN PyObject *_wrap_VectorVertices_resize(PyObject *self, PyObject *args) {
11523   int argc;
11524   PyObject *argv[4];
11525   int ii;
11526
11527   if (!PyTuple_Check(args)) SWIG_fail;
11528   argc = PyObject_Length(args);
11529   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11530     argv[ii] = PyTuple_GET_ITEM(args,ii);
11531   }
11532   if (argc == 2) {
11533     int _v;
11534     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11535     _v = SWIG_CheckState(res);
11536     if (_v) {
11537       {
11538         int res = SWIG_AsVal_size_t(argv[1], NULL);
11539         _v = SWIG_CheckState(res);
11540       }
11541       if (_v) {
11542         return _wrap_VectorVertices_resize__SWIG_0(self, args);
11543       }
11544     }
11545   }
11546   if (argc == 3) {
11547     int _v;
11548     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11549     _v = SWIG_CheckState(res);
11550     if (_v) {
11551       {
11552         int res = SWIG_AsVal_size_t(argv[1], NULL);
11553         _v = SWIG_CheckState(res);
11554       }
11555       if (_v) {
11556         void *vptr = 0;
11557         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
11558         _v = SWIG_CheckState(res);
11559         if (_v) {
11560           return _wrap_VectorVertices_resize__SWIG_1(self, args);
11561         }
11562       }
11563     }
11564   }
11565
11566 fail:
11567   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<Hex::Vertex * >::size_type)\n    resize(std::vector<Hex::Vertex * >::size_type,std::vector<Hex::Vertex * >::value_type)\n");
11568   return NULL;
11569 }
11570
11571
11572 SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11573   PyObject *resultobj = 0;
11574   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11575   std::vector<Hex::Vertex * >::iterator arg2 ;
11576   std::vector<Hex::Vertex * >::value_type arg3 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11577   std::vector<Hex::Vertex * >::iterator result;
11578   void *argp1 = 0 ;
11579   int res1 = 0 ;
11580   swig::PySwigIterator *iter2 = 0 ;
11581   int res2 ;
11582   void *argp3 = 0 ;
11583   int res3 = 0 ;
11584   PyObject * obj0 = 0 ;
11585   PyObject * obj1 = 0 ;
11586   PyObject * obj2 = 0 ;
11587
11588   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_insert",&obj0,&obj1,&obj2)) SWIG_fail;
11589   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11590   if (!SWIG_IsOK(res1)) {
11591     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11592   }
11593   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11594   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
11595   if (!SWIG_IsOK(res2) || !iter2) {
11596     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11597   } else {
11598     swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
11599     if (iter_t) {
11600       arg2 = iter_t->get_current();
11601     } else {
11602       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11603     }
11604   }
11605   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
11606   if (!SWIG_IsOK(res3)) {
11607     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11608   }
11609   arg3 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp3);
11610   result = (arg1)->insert(arg2,arg3);
11611   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::Vertex * >::iterator & >(result)),
11612     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
11613   return resultobj;
11614 fail:
11615   return NULL;
11616 }
11617
11618
11619 SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11620   PyObject *resultobj = 0;
11621   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11622   std::vector<Hex::Vertex * >::iterator arg2 ;
11623   std::vector<Hex::Vertex * >::size_type arg3 ;
11624   std::vector<Hex::Vertex * >::value_type arg4 = (std::vector<Hex::Vertex * >::value_type) 0 ;
11625   void *argp1 = 0 ;
11626   int res1 = 0 ;
11627   swig::PySwigIterator *iter2 = 0 ;
11628   int res2 ;
11629   size_t val3 ;
11630   int ecode3 = 0 ;
11631   void *argp4 = 0 ;
11632   int res4 = 0 ;
11633   PyObject * obj0 = 0 ;
11634   PyObject * obj1 = 0 ;
11635   PyObject * obj2 = 0 ;
11636   PyObject * obj3 = 0 ;
11637
11638   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11639   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11640   if (!SWIG_IsOK(res1)) {
11641     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11642   }
11643   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11644   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
11645   if (!SWIG_IsOK(res2) || !iter2) {
11646     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11647   } else {
11648     swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter2);
11649     if (iter_t) {
11650       arg2 = iter_t->get_current();
11651     } else {
11652       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::iterator""'");
11653     }
11654   }
11655   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
11656   if (!SWIG_IsOK(ecode3)) {
11657     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11658   }
11659   arg3 = static_cast< std::vector<Hex::Vertex * >::size_type >(val3);
11660   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0 |  0 );
11661   if (!SWIG_IsOK(res4)) {
11662     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices_insert" "', argument " "4"" of type '" "std::vector<Hex::Vertex * >::value_type""'");
11663   }
11664   arg4 = reinterpret_cast< std::vector<Hex::Vertex * >::value_type >(argp4);
11665   (arg1)->insert(arg2,arg3,arg4);
11666   resultobj = SWIG_Py_Void();
11667   return resultobj;
11668 fail:
11669   return NULL;
11670 }
11671
11672
11673 SWIGINTERN PyObject *_wrap_VectorVertices_insert(PyObject *self, PyObject *args) {
11674   int argc;
11675   PyObject *argv[5];
11676   int ii;
11677
11678   if (!PyTuple_Check(args)) SWIG_fail;
11679   argc = PyObject_Length(args);
11680   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
11681     argv[ii] = PyTuple_GET_ITEM(args,ii);
11682   }
11683   if (argc == 3) {
11684     int _v;
11685     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11686     _v = SWIG_CheckState(res);
11687     if (_v) {
11688       swig::PySwigIterator *iter = 0;
11689       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
11690       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
11691       if (_v) {
11692         void *vptr = 0;
11693         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
11694         _v = SWIG_CheckState(res);
11695         if (_v) {
11696           return _wrap_VectorVertices_insert__SWIG_0(self, args);
11697         }
11698       }
11699     }
11700   }
11701   if (argc == 4) {
11702     int _v;
11703     int res = swig::asptr(argv[0], (std::vector<Hex::Vertex*,std::allocator<Hex::Vertex * > >**)(0));
11704     _v = SWIG_CheckState(res);
11705     if (_v) {
11706       swig::PySwigIterator *iter = 0;
11707       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
11708       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::Vertex * >::iterator > *>(iter) != 0));
11709       if (_v) {
11710         {
11711           int res = SWIG_AsVal_size_t(argv[2], NULL);
11712           _v = SWIG_CheckState(res);
11713         }
11714         if (_v) {
11715           void *vptr = 0;
11716           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0);
11717           _v = SWIG_CheckState(res);
11718           if (_v) {
11719             return _wrap_VectorVertices_insert__SWIG_1(self, args);
11720           }
11721         }
11722       }
11723     }
11724   }
11725
11726 fail:
11727   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorVertices_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<Hex::Vertex * >::iterator,std::vector<Hex::Vertex * >::value_type)\n    insert(std::vector<Hex::Vertex * >::iterator,std::vector<Hex::Vertex * >::size_type,std::vector<Hex::Vertex * >::value_type)\n");
11728   return NULL;
11729 }
11730
11731
11732 SWIGINTERN PyObject *_wrap_VectorVertices_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11733   PyObject *resultobj = 0;
11734   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11735   std::vector<Hex::Vertex * >::size_type arg2 ;
11736   void *argp1 = 0 ;
11737   int res1 = 0 ;
11738   size_t val2 ;
11739   int ecode2 = 0 ;
11740   PyObject * obj0 = 0 ;
11741   PyObject * obj1 = 0 ;
11742
11743   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_reserve",&obj0,&obj1)) SWIG_fail;
11744   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11745   if (!SWIG_IsOK(res1)) {
11746     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_reserve" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11747   }
11748   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11749   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11750   if (!SWIG_IsOK(ecode2)) {
11751     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_reserve" "', argument " "2"" of type '" "std::vector<Hex::Vertex * >::size_type""'");
11752   }
11753   arg2 = static_cast< std::vector<Hex::Vertex * >::size_type >(val2);
11754   (arg1)->reserve(arg2);
11755   resultobj = SWIG_Py_Void();
11756   return resultobj;
11757 fail:
11758   return NULL;
11759 }
11760
11761
11762 SWIGINTERN PyObject *_wrap_VectorVertices_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763   PyObject *resultobj = 0;
11764   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11765   std::vector<Hex::Vertex * >::size_type result;
11766   void *argp1 = 0 ;
11767   int res1 = 0 ;
11768   PyObject * obj0 = 0 ;
11769
11770   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_capacity",&obj0)) SWIG_fail;
11771   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0 |  0 );
11772   if (!SWIG_IsOK(res1)) {
11773     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_capacity" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > const *""'");
11774   }
11775   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11776   result = ((std::vector<Hex::Vertex * > const *)arg1)->capacity();
11777   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11778   return resultobj;
11779 fail:
11780   return NULL;
11781 }
11782
11783
11784 SWIGINTERN PyObject *_wrap_delete_VectorVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11785   PyObject *resultobj = 0;
11786   std::vector<Hex::Vertex * > *arg1 = (std::vector<Hex::Vertex * > *) 0 ;
11787   void *argp1 = 0 ;
11788   int res1 = 0 ;
11789   PyObject * obj0 = 0 ;
11790
11791   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorVertices",&obj0)) SWIG_fail;
11792   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_POINTER_DISOWN |  0 );
11793   if (!SWIG_IsOK(res1)) {
11794     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorVertices" "', argument " "1"" of type '" "std::vector<Hex::Vertex * > *""'");
11795   }
11796   arg1 = reinterpret_cast< std::vector<Hex::Vertex * > * >(argp1);
11797   delete arg1;
11798
11799   resultobj = SWIG_Py_Void();
11800   return resultobj;
11801 fail:
11802   return NULL;
11803 }
11804
11805
11806 SWIGINTERN PyObject *VectorVertices_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11807   PyObject *obj;
11808   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
11809   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, SWIG_NewClientData(obj));
11810   return SWIG_Py_Void();
11811 }
11812
11813 SWIGINTERN PyObject *_wrap_VectorShapes_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11814   PyObject *resultobj = 0;
11815   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11816   PyObject **arg2 = (PyObject **) 0 ;
11817   swig::PySwigIterator *result = 0 ;
11818   void *argp1 = 0 ;
11819   int res1 = 0 ;
11820   PyObject * obj0 = 0 ;
11821
11822   arg2 = &obj0;
11823   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_iterator",&obj0)) SWIG_fail;
11824   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
11825   if (!SWIG_IsOK(res1)) {
11826     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_iterator" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
11827   }
11828   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11829   result = (swig::PySwigIterator *)std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(arg1,arg2);
11830   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
11831   return resultobj;
11832 fail:
11833   return NULL;
11834 }
11835
11836
11837 SWIGINTERN PyObject *_wrap_VectorShapes___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11838   PyObject *resultobj = 0;
11839   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11840   bool result;
11841   void *argp1 = 0 ;
11842   int res1 = 0 ;
11843   PyObject * obj0 = 0 ;
11844
11845   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___nonzero__",&obj0)) SWIG_fail;
11846   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
11847   if (!SWIG_IsOK(res1)) {
11848     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___nonzero__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
11849   }
11850   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11851   result = (bool)std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__((std::vector<Hex::NewShape * > const *)arg1);
11852   resultobj = SWIG_From_bool(static_cast< bool >(result));
11853   return resultobj;
11854 fail:
11855   return NULL;
11856 }
11857
11858
11859 SWIGINTERN PyObject *_wrap_VectorShapes___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11860   PyObject *resultobj = 0;
11861   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11862   std::vector<Hex::NewShape * >::size_type result;
11863   void *argp1 = 0 ;
11864   int res1 = 0 ;
11865   PyObject * obj0 = 0 ;
11866
11867   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___len__",&obj0)) SWIG_fail;
11868   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
11869   if (!SWIG_IsOK(res1)) {
11870     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___len__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
11871   }
11872   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11873   result = std_vector_Sl_Hex_NewShape_Sm__Sg____len__((std::vector<Hex::NewShape * > const *)arg1);
11874   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11875   return resultobj;
11876 fail:
11877   return NULL;
11878 }
11879
11880
11881 SWIGINTERN PyObject *_wrap_VectorShapes_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11882   PyObject *resultobj = 0;
11883   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11884   std::vector<Hex::NewShape * >::value_type result;
11885   void *argp1 = 0 ;
11886   int res1 = 0 ;
11887   PyObject * obj0 = 0 ;
11888
11889   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop",&obj0)) SWIG_fail;
11890   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
11891   if (!SWIG_IsOK(res1)) {
11892     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
11893   }
11894   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11895   try {
11896     result = (std::vector<Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg__pop(arg1);
11897   }
11898   catch(std::out_of_range &_e) {
11899     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11900   }
11901
11902   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
11903   return resultobj;
11904 fail:
11905   return NULL;
11906 }
11907
11908
11909 SWIGINTERN PyObject *_wrap_VectorShapes___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11910   PyObject *resultobj = 0;
11911   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11912   std::vector<Hex::NewShape * >::difference_type arg2 ;
11913   std::vector<Hex::NewShape * >::difference_type arg3 ;
11914   std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *result = 0 ;
11915   void *argp1 = 0 ;
11916   int res1 = 0 ;
11917   ptrdiff_t val2 ;
11918   int ecode2 = 0 ;
11919   ptrdiff_t val3 ;
11920   int ecode3 = 0 ;
11921   PyObject * obj0 = 0 ;
11922   PyObject * obj1 = 0 ;
11923   PyObject * obj2 = 0 ;
11924
11925   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
11926   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
11927   if (!SWIG_IsOK(res1)) {
11928     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getslice__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
11929   }
11930   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11931   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11932   if (!SWIG_IsOK(ecode2)) {
11933     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getslice__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
11934   }
11935   arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
11936   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
11937   if (!SWIG_IsOK(ecode3)) {
11938     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___getslice__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
11939   }
11940   arg3 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val3);
11941   try {
11942     result = (std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *)std_vector_Sl_Hex_NewShape_Sm__Sg____getslice__(arg1,arg2,arg3);
11943   }
11944   catch(std::out_of_range &_e) {
11945     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11946   }
11947
11948   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_OWN |  0 );
11949   return resultobj;
11950 fail:
11951   return NULL;
11952 }
11953
11954
11955 SWIGINTERN PyObject *_wrap_VectorShapes___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11956   PyObject *resultobj = 0;
11957   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
11958   std::vector<Hex::NewShape * >::difference_type arg2 ;
11959   std::vector<Hex::NewShape * >::difference_type arg3 ;
11960   std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *arg4 = 0 ;
11961   void *argp1 = 0 ;
11962   int res1 = 0 ;
11963   ptrdiff_t val2 ;
11964   int ecode2 = 0 ;
11965   ptrdiff_t val3 ;
11966   int ecode3 = 0 ;
11967   int res4 = SWIG_OLDOBJ ;
11968   PyObject * obj0 = 0 ;
11969   PyObject * obj1 = 0 ;
11970   PyObject * obj2 = 0 ;
11971   PyObject * obj3 = 0 ;
11972
11973   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11974   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
11975   if (!SWIG_IsOK(res1)) {
11976     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setslice__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
11977   }
11978   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
11979   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11980   if (!SWIG_IsOK(ecode2)) {
11981     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setslice__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
11982   }
11983   arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
11984   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
11985   if (!SWIG_IsOK(ecode3)) {
11986     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___setslice__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
11987   }
11988   arg3 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val3);
11989   {
11990     std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
11991     res4 = swig::asptr(obj3, &ptr);
11992     if (!SWIG_IsOK(res4)) {
11993       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes___setslice__" "', argument " "4"" of type '" "std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > const &""'");
11994     }
11995     if (!ptr) {
11996       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 &""'");
11997     }
11998     arg4 = ptr;
11999   }
12000   try {
12001     std_vector_Sl_Hex_NewShape_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > const &)*arg4);
12002   }
12003   catch(std::out_of_range &_e) {
12004     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12005   }
12006   catch(std::invalid_argument &_e) {
12007     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12008   }
12009
12010   resultobj = SWIG_Py_Void();
12011   if (SWIG_IsNewObj(res4)) delete arg4;
12012   return resultobj;
12013 fail:
12014   if (SWIG_IsNewObj(res4)) delete arg4;
12015   return NULL;
12016 }
12017
12018
12019 SWIGINTERN PyObject *_wrap_VectorShapes___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12020   PyObject *resultobj = 0;
12021   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12022   std::vector<Hex::NewShape * >::difference_type arg2 ;
12023   std::vector<Hex::NewShape * >::difference_type arg3 ;
12024   void *argp1 = 0 ;
12025   int res1 = 0 ;
12026   ptrdiff_t val2 ;
12027   int ecode2 = 0 ;
12028   ptrdiff_t val3 ;
12029   int ecode3 = 0 ;
12030   PyObject * obj0 = 0 ;
12031   PyObject * obj1 = 0 ;
12032   PyObject * obj2 = 0 ;
12033
12034   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
12035   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12036   if (!SWIG_IsOK(res1)) {
12037     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delslice__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12038   }
12039   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12040   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12041   if (!SWIG_IsOK(ecode2)) {
12042     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delslice__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
12043   }
12044   arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
12045   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12046   if (!SWIG_IsOK(ecode3)) {
12047     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___delslice__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
12048   }
12049   arg3 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val3);
12050   try {
12051     std_vector_Sl_Hex_NewShape_Sm__Sg____delslice__(arg1,arg2,arg3);
12052   }
12053   catch(std::out_of_range &_e) {
12054     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12055   }
12056
12057   resultobj = SWIG_Py_Void();
12058   return resultobj;
12059 fail:
12060   return NULL;
12061 }
12062
12063
12064 SWIGINTERN PyObject *_wrap_VectorShapes___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12065   PyObject *resultobj = 0;
12066   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12067   std::vector<Hex::NewShape * >::difference_type arg2 ;
12068   void *argp1 = 0 ;
12069   int res1 = 0 ;
12070   ptrdiff_t val2 ;
12071   int ecode2 = 0 ;
12072   PyObject * obj0 = 0 ;
12073   PyObject * obj1 = 0 ;
12074
12075   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___delitem__",&obj0,&obj1)) SWIG_fail;
12076   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12077   if (!SWIG_IsOK(res1)) {
12078     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delitem__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12079   }
12080   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12081   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12082   if (!SWIG_IsOK(ecode2)) {
12083     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delitem__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
12084   }
12085   arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
12086   try {
12087     std_vector_Sl_Hex_NewShape_Sm__Sg____delitem__(arg1,arg2);
12088   }
12089   catch(std::out_of_range &_e) {
12090     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12091   }
12092
12093   resultobj = SWIG_Py_Void();
12094   return resultobj;
12095 fail:
12096   return NULL;
12097 }
12098
12099
12100 SWIGINTERN PyObject *_wrap_VectorShapes___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101   PyObject *resultobj = 0;
12102   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12103   std::vector<Hex::NewShape * >::difference_type arg2 ;
12104   std::vector<Hex::NewShape * >::value_type result;
12105   void *argp1 = 0 ;
12106   int res1 = 0 ;
12107   ptrdiff_t val2 ;
12108   int ecode2 = 0 ;
12109   PyObject * obj0 = 0 ;
12110   PyObject * obj1 = 0 ;
12111
12112   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___getitem__",&obj0,&obj1)) SWIG_fail;
12113   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12114   if (!SWIG_IsOK(res1)) {
12115     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getitem__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12116   }
12117   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12118   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12119   if (!SWIG_IsOK(ecode2)) {
12120     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getitem__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
12121   }
12122   arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
12123   try {
12124     result = (std::vector<Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg____getitem__(arg1,arg2);
12125   }
12126   catch(std::out_of_range &_e) {
12127     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12128   }
12129
12130   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
12131   return resultobj;
12132 fail:
12133   return NULL;
12134 }
12135
12136
12137 SWIGINTERN PyObject *_wrap_VectorShapes___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12138   PyObject *resultobj = 0;
12139   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12140   std::vector<Hex::NewShape * >::difference_type arg2 ;
12141   std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
12142   void *argp1 = 0 ;
12143   int res1 = 0 ;
12144   ptrdiff_t val2 ;
12145   int ecode2 = 0 ;
12146   void *argp3 = 0 ;
12147   int res3 = 0 ;
12148   PyObject * obj0 = 0 ;
12149   PyObject * obj1 = 0 ;
12150   PyObject * obj2 = 0 ;
12151
12152   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
12153   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12154   if (!SWIG_IsOK(res1)) {
12155     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12156   }
12157   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12158   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12159   if (!SWIG_IsOK(ecode2)) {
12160     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setitem__" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::difference_type""'");
12161   }
12162   arg2 = static_cast< std::vector<Hex::NewShape * >::difference_type >(val2);
12163   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
12164   if (!SWIG_IsOK(res3)) {
12165     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
12166   }
12167   arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
12168   try {
12169     std_vector_Sl_Hex_NewShape_Sm__Sg____setitem__(arg1,arg2,arg3);
12170   }
12171   catch(std::out_of_range &_e) {
12172     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12173   }
12174
12175   resultobj = SWIG_Py_Void();
12176   return resultobj;
12177 fail:
12178   return NULL;
12179 }
12180
12181
12182 SWIGINTERN PyObject *_wrap_VectorShapes_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12183   PyObject *resultobj = 0;
12184   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12185   std::vector<Hex::NewShape * >::value_type arg2 = (std::vector<Hex::NewShape * >::value_type) 0 ;
12186   void *argp1 = 0 ;
12187   int res1 = 0 ;
12188   void *argp2 = 0 ;
12189   int res2 = 0 ;
12190   PyObject * obj0 = 0 ;
12191   PyObject * obj1 = 0 ;
12192
12193   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_append",&obj0,&obj1)) SWIG_fail;
12194   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12195   if (!SWIG_IsOK(res1)) {
12196     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_append" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12197   }
12198   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12199   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
12200   if (!SWIG_IsOK(res2)) {
12201     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_append" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
12202   }
12203   arg2 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp2);
12204   std_vector_Sl_Hex_NewShape_Sm__Sg__append(arg1,arg2);
12205   resultobj = SWIG_Py_Void();
12206   return resultobj;
12207 fail:
12208   return NULL;
12209 }
12210
12211
12212 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12213   PyObject *resultobj = 0;
12214   std::vector<Hex::NewShape * > *result = 0 ;
12215
12216   if (!PyArg_ParseTuple(args,(char *)":new_VectorShapes")) SWIG_fail;
12217   result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >();
12218   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
12219   return resultobj;
12220 fail:
12221   return NULL;
12222 }
12223
12224
12225 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12226   PyObject *resultobj = 0;
12227   std::vector<Hex::NewShape * > *arg1 = 0 ;
12228   std::vector<Hex::NewShape * > *result = 0 ;
12229   int res1 = SWIG_OLDOBJ ;
12230   PyObject * obj0 = 0 ;
12231
12232   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
12233   {
12234     std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
12235     res1 = swig::asptr(obj0, &ptr);
12236     if (!SWIG_IsOK(res1)) {
12237       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const &""'");
12238     }
12239     if (!ptr) {
12240       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const &""'");
12241     }
12242     arg1 = ptr;
12243   }
12244   result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >((std::vector<Hex::NewShape * > const &)*arg1);
12245   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
12246   if (SWIG_IsNewObj(res1)) delete arg1;
12247   return resultobj;
12248 fail:
12249   if (SWIG_IsNewObj(res1)) delete arg1;
12250   return NULL;
12251 }
12252
12253
12254 SWIGINTERN PyObject *_wrap_VectorShapes_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12255   PyObject *resultobj = 0;
12256   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12257   bool result;
12258   void *argp1 = 0 ;
12259   int res1 = 0 ;
12260   PyObject * obj0 = 0 ;
12261
12262   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_empty",&obj0)) SWIG_fail;
12263   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12264   if (!SWIG_IsOK(res1)) {
12265     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_empty" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12266   }
12267   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12268   result = (bool)((std::vector<Hex::NewShape * > const *)arg1)->empty();
12269   resultobj = SWIG_From_bool(static_cast< bool >(result));
12270   return resultobj;
12271 fail:
12272   return NULL;
12273 }
12274
12275
12276 SWIGINTERN PyObject *_wrap_VectorShapes_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12277   PyObject *resultobj = 0;
12278   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12279   std::vector<Hex::NewShape * >::size_type result;
12280   void *argp1 = 0 ;
12281   int res1 = 0 ;
12282   PyObject * obj0 = 0 ;
12283
12284   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_size",&obj0)) SWIG_fail;
12285   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12286   if (!SWIG_IsOK(res1)) {
12287     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_size" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12288   }
12289   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12290   result = ((std::vector<Hex::NewShape * > const *)arg1)->size();
12291   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12292   return resultobj;
12293 fail:
12294   return NULL;
12295 }
12296
12297
12298 SWIGINTERN PyObject *_wrap_VectorShapes_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12299   PyObject *resultobj = 0;
12300   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12301   void *argp1 = 0 ;
12302   int res1 = 0 ;
12303   PyObject * obj0 = 0 ;
12304
12305   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_clear",&obj0)) SWIG_fail;
12306   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12307   if (!SWIG_IsOK(res1)) {
12308     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_clear" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12309   }
12310   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12311   (arg1)->clear();
12312   resultobj = SWIG_Py_Void();
12313   return resultobj;
12314 fail:
12315   return NULL;
12316 }
12317
12318
12319 SWIGINTERN PyObject *_wrap_VectorShapes_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12320   PyObject *resultobj = 0;
12321   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12322   std::vector<Hex::NewShape * > *arg2 = 0 ;
12323   void *argp1 = 0 ;
12324   int res1 = 0 ;
12325   void *argp2 = 0 ;
12326   int res2 = 0 ;
12327   PyObject * obj0 = 0 ;
12328   PyObject * obj1 = 0 ;
12329
12330   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_swap",&obj0,&obj1)) SWIG_fail;
12331   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12332   if (!SWIG_IsOK(res1)) {
12333     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_swap" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12334   }
12335   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12336   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t,  0 );
12337   if (!SWIG_IsOK(res2)) {
12338     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector<Hex::NewShape * > &""'");
12339   }
12340   if (!argp2) {
12341     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector<Hex::NewShape * > &""'");
12342   }
12343   arg2 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp2);
12344   (arg1)->swap(*arg2);
12345   resultobj = SWIG_Py_Void();
12346   return resultobj;
12347 fail:
12348   return NULL;
12349 }
12350
12351
12352 SWIGINTERN PyObject *_wrap_VectorShapes_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12353   PyObject *resultobj = 0;
12354   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12355   SwigValueWrapper<std::allocator<Hex::NewShape * > > result;
12356   void *argp1 = 0 ;
12357   int res1 = 0 ;
12358   PyObject * obj0 = 0 ;
12359
12360   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_get_allocator",&obj0)) SWIG_fail;
12361   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12362   if (!SWIG_IsOK(res1)) {
12363     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_get_allocator" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12364   }
12365   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12366   result = ((std::vector<Hex::NewShape * > const *)arg1)->get_allocator();
12367   resultobj = SWIG_NewPointerObj((new std::vector<Hex::NewShape * >::allocator_type(static_cast< const std::vector<Hex::NewShape * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
12368   return resultobj;
12369 fail:
12370   return NULL;
12371 }
12372
12373
12374 SWIGINTERN PyObject *_wrap_VectorShapes_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12375   PyObject *resultobj = 0;
12376   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12377   std::vector<Hex::NewShape * >::iterator result;
12378   void *argp1 = 0 ;
12379   int res1 = 0 ;
12380   PyObject * obj0 = 0 ;
12381
12382   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_begin",&obj0)) SWIG_fail;
12383   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12384   if (!SWIG_IsOK(res1)) {
12385     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_begin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12386   }
12387   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12388   result = (arg1)->begin();
12389   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
12390     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12391   return resultobj;
12392 fail:
12393   return NULL;
12394 }
12395
12396
12397 SWIGINTERN PyObject *_wrap_VectorShapes_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12398   PyObject *resultobj = 0;
12399   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12400   std::vector<Hex::NewShape * >::const_iterator result;
12401   void *argp1 = 0 ;
12402   int res1 = 0 ;
12403   PyObject * obj0 = 0 ;
12404
12405   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_begin",&obj0)) SWIG_fail;
12406   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12407   if (!SWIG_IsOK(res1)) {
12408     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_begin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12409   }
12410   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12411   result = ((std::vector<Hex::NewShape * > const *)arg1)->begin();
12412   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_iterator & >(result)),
12413     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12414   return resultobj;
12415 fail:
12416   return NULL;
12417 }
12418
12419
12420 SWIGINTERN PyObject *_wrap_VectorShapes_begin(PyObject *self, PyObject *args) {
12421   int argc;
12422   PyObject *argv[2];
12423   int ii;
12424
12425   if (!PyTuple_Check(args)) SWIG_fail;
12426   argc = PyObject_Length(args);
12427   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
12428     argv[ii] = PyTuple_GET_ITEM(args,ii);
12429   }
12430   if (argc == 1) {
12431     int _v;
12432     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12433     _v = SWIG_CheckState(res);
12434     if (_v) {
12435       return _wrap_VectorShapes_begin__SWIG_0(self, args);
12436     }
12437   }
12438   if (argc == 1) {
12439     int _v;
12440     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12441     _v = SWIG_CheckState(res);
12442     if (_v) {
12443       return _wrap_VectorShapes_begin__SWIG_1(self, args);
12444     }
12445   }
12446
12447 fail:
12448   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
12449   return NULL;
12450 }
12451
12452
12453 SWIGINTERN PyObject *_wrap_VectorShapes_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12454   PyObject *resultobj = 0;
12455   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12456   std::vector<Hex::NewShape * >::iterator result;
12457   void *argp1 = 0 ;
12458   int res1 = 0 ;
12459   PyObject * obj0 = 0 ;
12460
12461   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_end",&obj0)) SWIG_fail;
12462   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12463   if (!SWIG_IsOK(res1)) {
12464     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_end" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12465   }
12466   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12467   result = (arg1)->end();
12468   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
12469     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12470   return resultobj;
12471 fail:
12472   return NULL;
12473 }
12474
12475
12476 SWIGINTERN PyObject *_wrap_VectorShapes_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12477   PyObject *resultobj = 0;
12478   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12479   std::vector<Hex::NewShape * >::const_iterator result;
12480   void *argp1 = 0 ;
12481   int res1 = 0 ;
12482   PyObject * obj0 = 0 ;
12483
12484   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_end",&obj0)) SWIG_fail;
12485   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12486   if (!SWIG_IsOK(res1)) {
12487     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_end" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12488   }
12489   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12490   result = ((std::vector<Hex::NewShape * > const *)arg1)->end();
12491   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_iterator & >(result)),
12492     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12493   return resultobj;
12494 fail:
12495   return NULL;
12496 }
12497
12498
12499 SWIGINTERN PyObject *_wrap_VectorShapes_end(PyObject *self, PyObject *args) {
12500   int argc;
12501   PyObject *argv[2];
12502   int ii;
12503
12504   if (!PyTuple_Check(args)) SWIG_fail;
12505   argc = PyObject_Length(args);
12506   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
12507     argv[ii] = PyTuple_GET_ITEM(args,ii);
12508   }
12509   if (argc == 1) {
12510     int _v;
12511     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12512     _v = SWIG_CheckState(res);
12513     if (_v) {
12514       return _wrap_VectorShapes_end__SWIG_0(self, args);
12515     }
12516   }
12517   if (argc == 1) {
12518     int _v;
12519     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12520     _v = SWIG_CheckState(res);
12521     if (_v) {
12522       return _wrap_VectorShapes_end__SWIG_1(self, args);
12523     }
12524   }
12525
12526 fail:
12527   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
12528   return NULL;
12529 }
12530
12531
12532 SWIGINTERN PyObject *_wrap_VectorShapes_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12533   PyObject *resultobj = 0;
12534   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12535   std::vector<Hex::NewShape * >::reverse_iterator result;
12536   void *argp1 = 0 ;
12537   int res1 = 0 ;
12538   PyObject * obj0 = 0 ;
12539
12540   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rbegin",&obj0)) SWIG_fail;
12541   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12542   if (!SWIG_IsOK(res1)) {
12543     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rbegin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12544   }
12545   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12546   result = (arg1)->rbegin();
12547   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::reverse_iterator & >(result)),
12548     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12549   return resultobj;
12550 fail:
12551   return NULL;
12552 }
12553
12554
12555 SWIGINTERN PyObject *_wrap_VectorShapes_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12556   PyObject *resultobj = 0;
12557   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12558   std::vector<Hex::NewShape * >::const_reverse_iterator result;
12559   void *argp1 = 0 ;
12560   int res1 = 0 ;
12561   PyObject * obj0 = 0 ;
12562
12563   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rbegin",&obj0)) SWIG_fail;
12564   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12565   if (!SWIG_IsOK(res1)) {
12566     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rbegin" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12567   }
12568   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12569   result = ((std::vector<Hex::NewShape * > const *)arg1)->rbegin();
12570   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_reverse_iterator & >(result)),
12571     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12572   return resultobj;
12573 fail:
12574   return NULL;
12575 }
12576
12577
12578 SWIGINTERN PyObject *_wrap_VectorShapes_rbegin(PyObject *self, PyObject *args) {
12579   int argc;
12580   PyObject *argv[2];
12581   int ii;
12582
12583   if (!PyTuple_Check(args)) SWIG_fail;
12584   argc = PyObject_Length(args);
12585   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
12586     argv[ii] = PyTuple_GET_ITEM(args,ii);
12587   }
12588   if (argc == 1) {
12589     int _v;
12590     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12591     _v = SWIG_CheckState(res);
12592     if (_v) {
12593       return _wrap_VectorShapes_rbegin__SWIG_0(self, args);
12594     }
12595   }
12596   if (argc == 1) {
12597     int _v;
12598     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12599     _v = SWIG_CheckState(res);
12600     if (_v) {
12601       return _wrap_VectorShapes_rbegin__SWIG_1(self, args);
12602     }
12603   }
12604
12605 fail:
12606   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
12607   return NULL;
12608 }
12609
12610
12611 SWIGINTERN PyObject *_wrap_VectorShapes_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12612   PyObject *resultobj = 0;
12613   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12614   std::vector<Hex::NewShape * >::reverse_iterator result;
12615   void *argp1 = 0 ;
12616   int res1 = 0 ;
12617   PyObject * obj0 = 0 ;
12618
12619   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rend",&obj0)) SWIG_fail;
12620   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12621   if (!SWIG_IsOK(res1)) {
12622     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rend" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12623   }
12624   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12625   result = (arg1)->rend();
12626   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::reverse_iterator & >(result)),
12627     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12628   return resultobj;
12629 fail:
12630   return NULL;
12631 }
12632
12633
12634 SWIGINTERN PyObject *_wrap_VectorShapes_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12635   PyObject *resultobj = 0;
12636   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12637   std::vector<Hex::NewShape * >::const_reverse_iterator result;
12638   void *argp1 = 0 ;
12639   int res1 = 0 ;
12640   PyObject * obj0 = 0 ;
12641
12642   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rend",&obj0)) SWIG_fail;
12643   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12644   if (!SWIG_IsOK(res1)) {
12645     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rend" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
12646   }
12647   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12648   result = ((std::vector<Hex::NewShape * > const *)arg1)->rend();
12649   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::const_reverse_iterator & >(result)),
12650     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12651   return resultobj;
12652 fail:
12653   return NULL;
12654 }
12655
12656
12657 SWIGINTERN PyObject *_wrap_VectorShapes_rend(PyObject *self, PyObject *args) {
12658   int argc;
12659   PyObject *argv[2];
12660   int ii;
12661
12662   if (!PyTuple_Check(args)) SWIG_fail;
12663   argc = PyObject_Length(args);
12664   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
12665     argv[ii] = PyTuple_GET_ITEM(args,ii);
12666   }
12667   if (argc == 1) {
12668     int _v;
12669     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12670     _v = SWIG_CheckState(res);
12671     if (_v) {
12672       return _wrap_VectorShapes_rend__SWIG_0(self, args);
12673     }
12674   }
12675   if (argc == 1) {
12676     int _v;
12677     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12678     _v = SWIG_CheckState(res);
12679     if (_v) {
12680       return _wrap_VectorShapes_rend__SWIG_1(self, args);
12681     }
12682   }
12683
12684 fail:
12685   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
12686   return NULL;
12687 }
12688
12689
12690 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12691   PyObject *resultobj = 0;
12692   std::vector<Hex::NewShape * >::size_type arg1 ;
12693   std::vector<Hex::NewShape * > *result = 0 ;
12694   size_t val1 ;
12695   int ecode1 = 0 ;
12696   PyObject * obj0 = 0 ;
12697
12698   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
12699   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
12700   if (!SWIG_IsOK(ecode1)) {
12701     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
12702   }
12703   arg1 = static_cast< std::vector<Hex::NewShape * >::size_type >(val1);
12704   result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >(arg1);
12705   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
12706   return resultobj;
12707 fail:
12708   return NULL;
12709 }
12710
12711
12712 SWIGINTERN PyObject *_wrap_VectorShapes_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12713   PyObject *resultobj = 0;
12714   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12715   void *argp1 = 0 ;
12716   int res1 = 0 ;
12717   PyObject * obj0 = 0 ;
12718
12719   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop_back",&obj0)) SWIG_fail;
12720   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12721   if (!SWIG_IsOK(res1)) {
12722     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop_back" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12723   }
12724   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12725   (arg1)->pop_back();
12726   resultobj = SWIG_Py_Void();
12727   return resultobj;
12728 fail:
12729   return NULL;
12730 }
12731
12732
12733 SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12734   PyObject *resultobj = 0;
12735   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12736   std::vector<Hex::NewShape * >::size_type arg2 ;
12737   void *argp1 = 0 ;
12738   int res1 = 0 ;
12739   size_t val2 ;
12740   int ecode2 = 0 ;
12741   PyObject * obj0 = 0 ;
12742   PyObject * obj1 = 0 ;
12743
12744   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_resize",&obj0,&obj1)) SWIG_fail;
12745   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12746   if (!SWIG_IsOK(res1)) {
12747     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12748   }
12749   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12750   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12751   if (!SWIG_IsOK(ecode2)) {
12752     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
12753   }
12754   arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
12755   (arg1)->resize(arg2);
12756   resultobj = SWIG_Py_Void();
12757   return resultobj;
12758 fail:
12759   return NULL;
12760 }
12761
12762
12763 SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12764   PyObject *resultobj = 0;
12765   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12766   std::vector<Hex::NewShape * >::iterator arg2 ;
12767   std::vector<Hex::NewShape * >::iterator result;
12768   void *argp1 = 0 ;
12769   int res1 = 0 ;
12770   swig::PySwigIterator *iter2 = 0 ;
12771   int res2 ;
12772   PyObject * obj0 = 0 ;
12773   PyObject * obj1 = 0 ;
12774
12775   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_erase",&obj0,&obj1)) SWIG_fail;
12776   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12777   if (!SWIG_IsOK(res1)) {
12778     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12779   }
12780   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12781   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
12782   if (!SWIG_IsOK(res2) || !iter2) {
12783     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12784   } else {
12785     swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
12786     if (iter_t) {
12787       arg2 = iter_t->get_current();
12788     } else {
12789       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12790     }
12791   }
12792   result = (arg1)->erase(arg2);
12793   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
12794     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12795   return resultobj;
12796 fail:
12797   return NULL;
12798 }
12799
12800
12801 SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12802   PyObject *resultobj = 0;
12803   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12804   std::vector<Hex::NewShape * >::iterator arg2 ;
12805   std::vector<Hex::NewShape * >::iterator arg3 ;
12806   std::vector<Hex::NewShape * >::iterator result;
12807   void *argp1 = 0 ;
12808   int res1 = 0 ;
12809   swig::PySwigIterator *iter2 = 0 ;
12810   int res2 ;
12811   swig::PySwigIterator *iter3 = 0 ;
12812   int res3 ;
12813   PyObject * obj0 = 0 ;
12814   PyObject * obj1 = 0 ;
12815   PyObject * obj2 = 0 ;
12816
12817   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_erase",&obj0,&obj1,&obj2)) SWIG_fail;
12818   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12819   if (!SWIG_IsOK(res1)) {
12820     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
12821   }
12822   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
12823   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
12824   if (!SWIG_IsOK(res2) || !iter2) {
12825     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12826   } else {
12827     swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
12828     if (iter_t) {
12829       arg2 = iter_t->get_current();
12830     } else {
12831       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12832     }
12833   }
12834   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
12835   if (!SWIG_IsOK(res3) || !iter3) {
12836     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12837   } else {
12838     swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter3);
12839     if (iter_t) {
12840       arg3 = iter_t->get_current();
12841     } else {
12842       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
12843     }
12844   }
12845   result = (arg1)->erase(arg2,arg3);
12846   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
12847     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
12848   return resultobj;
12849 fail:
12850   return NULL;
12851 }
12852
12853
12854 SWIGINTERN PyObject *_wrap_VectorShapes_erase(PyObject *self, PyObject *args) {
12855   int argc;
12856   PyObject *argv[4];
12857   int ii;
12858
12859   if (!PyTuple_Check(args)) SWIG_fail;
12860   argc = PyObject_Length(args);
12861   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12862     argv[ii] = PyTuple_GET_ITEM(args,ii);
12863   }
12864   if (argc == 2) {
12865     int _v;
12866     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12867     _v = SWIG_CheckState(res);
12868     if (_v) {
12869       swig::PySwigIterator *iter = 0;
12870       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
12871       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
12872       if (_v) {
12873         return _wrap_VectorShapes_erase__SWIG_0(self, args);
12874       }
12875     }
12876   }
12877   if (argc == 3) {
12878     int _v;
12879     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12880     _v = SWIG_CheckState(res);
12881     if (_v) {
12882       swig::PySwigIterator *iter = 0;
12883       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
12884       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
12885       if (_v) {
12886         swig::PySwigIterator *iter = 0;
12887         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
12888         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
12889         if (_v) {
12890           return _wrap_VectorShapes_erase__SWIG_1(self, args);
12891         }
12892       }
12893     }
12894   }
12895
12896 fail:
12897   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<Hex::NewShape * >::iterator)\n    erase(std::vector<Hex::NewShape * >::iterator,std::vector<Hex::NewShape * >::iterator)\n");
12898   return NULL;
12899 }
12900
12901
12902 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12903   PyObject *resultobj = 0;
12904   std::vector<Hex::NewShape * >::size_type arg1 ;
12905   std::vector<Hex::NewShape * >::value_type arg2 = (std::vector<Hex::NewShape * >::value_type) 0 ;
12906   std::vector<Hex::NewShape * > *result = 0 ;
12907   size_t val1 ;
12908   int ecode1 = 0 ;
12909   void *argp2 = 0 ;
12910   int res2 = 0 ;
12911   PyObject * obj0 = 0 ;
12912   PyObject * obj1 = 0 ;
12913
12914   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorShapes",&obj0,&obj1)) SWIG_fail;
12915   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
12916   if (!SWIG_IsOK(ecode1)) {
12917     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
12918   }
12919   arg1 = static_cast< std::vector<Hex::NewShape * >::size_type >(val1);
12920   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
12921   if (!SWIG_IsOK(res2)) {
12922     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorShapes" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
12923   }
12924   arg2 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp2);
12925   result = (std::vector<Hex::NewShape * > *)new std::vector<Hex::NewShape * >(arg1,arg2);
12926   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
12927   return resultobj;
12928 fail:
12929   return NULL;
12930 }
12931
12932
12933 SWIGINTERN PyObject *_wrap_new_VectorShapes(PyObject *self, PyObject *args) {
12934   int argc;
12935   PyObject *argv[3];
12936   int ii;
12937
12938   if (!PyTuple_Check(args)) SWIG_fail;
12939   argc = PyObject_Length(args);
12940   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
12941     argv[ii] = PyTuple_GET_ITEM(args,ii);
12942   }
12943   if (argc == 0) {
12944     return _wrap_new_VectorShapes__SWIG_0(self, args);
12945   }
12946   if (argc == 1) {
12947     int _v;
12948     {
12949       int res = SWIG_AsVal_size_t(argv[0], NULL);
12950       _v = SWIG_CheckState(res);
12951     }
12952     if (_v) {
12953       return _wrap_new_VectorShapes__SWIG_2(self, args);
12954     }
12955   }
12956   if (argc == 1) {
12957     int _v;
12958     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
12959     _v = SWIG_CheckState(res);
12960     if (_v) {
12961       return _wrap_new_VectorShapes__SWIG_1(self, args);
12962     }
12963   }
12964   if (argc == 2) {
12965     int _v;
12966     {
12967       int res = SWIG_AsVal_size_t(argv[0], NULL);
12968       _v = SWIG_CheckState(res);
12969     }
12970     if (_v) {
12971       void *vptr = 0;
12972       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
12973       _v = SWIG_CheckState(res);
12974       if (_v) {
12975         return _wrap_new_VectorShapes__SWIG_3(self, args);
12976       }
12977     }
12978   }
12979
12980 fail:
12981   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorShapes'.\n  Possible C/C++ prototypes are:\n    std::vector<(p.Hex::NewShape)>()\n    std::vector<(p.Hex::NewShape)>(std::vector<Hex::NewShape * > const &)\n    std::vector<(p.Hex::NewShape)>(std::vector<Hex::NewShape * >::size_type)\n    std::vector<(p.Hex::NewShape)>(std::vector<Hex::NewShape * >::size_type,std::vector<Hex::NewShape * >::value_type)\n");
12982   return NULL;
12983 }
12984
12985
12986 SWIGINTERN PyObject *_wrap_VectorShapes_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12987   PyObject *resultobj = 0;
12988   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
12989   std::vector<Hex::NewShape * >::value_type arg2 = (std::vector<Hex::NewShape * >::value_type) 0 ;
12990   void *argp1 = 0 ;
12991   int res1 = 0 ;
12992   void *argp2 = 0 ;
12993   int res2 = 0 ;
12994   PyObject * obj0 = 0 ;
12995   PyObject * obj1 = 0 ;
12996
12997   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_push_back",&obj0,&obj1)) SWIG_fail;
12998   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
12999   if (!SWIG_IsOK(res1)) {
13000     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_push_back" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13001   }
13002   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13003   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
13004   if (!SWIG_IsOK(res2)) {
13005     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_push_back" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
13006   }
13007   arg2 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp2);
13008   (arg1)->push_back(arg2);
13009   resultobj = SWIG_Py_Void();
13010   return resultobj;
13011 fail:
13012   return NULL;
13013 }
13014
13015
13016 SWIGINTERN PyObject *_wrap_VectorShapes_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13017   PyObject *resultobj = 0;
13018   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13019   std::vector<Hex::NewShape * >::value_type result;
13020   void *argp1 = 0 ;
13021   int res1 = 0 ;
13022   PyObject * obj0 = 0 ;
13023
13024   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_front",&obj0)) SWIG_fail;
13025   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
13026   if (!SWIG_IsOK(res1)) {
13027     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_front" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
13028   }
13029   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13030   result = (std::vector<Hex::NewShape * >::value_type)((std::vector<Hex::NewShape * > const *)arg1)->front();
13031   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
13032   return resultobj;
13033 fail:
13034   return NULL;
13035 }
13036
13037
13038 SWIGINTERN PyObject *_wrap_VectorShapes_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13039   PyObject *resultobj = 0;
13040   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13041   std::vector<Hex::NewShape * >::value_type result;
13042   void *argp1 = 0 ;
13043   int res1 = 0 ;
13044   PyObject * obj0 = 0 ;
13045
13046   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_back",&obj0)) SWIG_fail;
13047   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
13048   if (!SWIG_IsOK(res1)) {
13049     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_back" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
13050   }
13051   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13052   result = (std::vector<Hex::NewShape * >::value_type)((std::vector<Hex::NewShape * > const *)arg1)->back();
13053   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
13054   return resultobj;
13055 fail:
13056   return NULL;
13057 }
13058
13059
13060 SWIGINTERN PyObject *_wrap_VectorShapes_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13061   PyObject *resultobj = 0;
13062   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13063   std::vector<Hex::NewShape * >::size_type arg2 ;
13064   std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
13065   void *argp1 = 0 ;
13066   int res1 = 0 ;
13067   size_t val2 ;
13068   int ecode2 = 0 ;
13069   void *argp3 = 0 ;
13070   int res3 = 0 ;
13071   PyObject * obj0 = 0 ;
13072   PyObject * obj1 = 0 ;
13073   PyObject * obj2 = 0 ;
13074
13075   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_assign",&obj0,&obj1,&obj2)) SWIG_fail;
13076   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
13077   if (!SWIG_IsOK(res1)) {
13078     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_assign" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13079   }
13080   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13081   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13082   if (!SWIG_IsOK(ecode2)) {
13083     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_assign" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
13084   }
13085   arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
13086   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
13087   if (!SWIG_IsOK(res3)) {
13088     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_assign" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
13089   }
13090   arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
13091   (arg1)->assign(arg2,arg3);
13092   resultobj = SWIG_Py_Void();
13093   return resultobj;
13094 fail:
13095   return NULL;
13096 }
13097
13098
13099 SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13100   PyObject *resultobj = 0;
13101   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13102   std::vector<Hex::NewShape * >::size_type arg2 ;
13103   std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
13104   void *argp1 = 0 ;
13105   int res1 = 0 ;
13106   size_t val2 ;
13107   int ecode2 = 0 ;
13108   void *argp3 = 0 ;
13109   int res3 = 0 ;
13110   PyObject * obj0 = 0 ;
13111   PyObject * obj1 = 0 ;
13112   PyObject * obj2 = 0 ;
13113
13114   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_resize",&obj0,&obj1,&obj2)) SWIG_fail;
13115   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
13116   if (!SWIG_IsOK(res1)) {
13117     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13118   }
13119   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13120   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13121   if (!SWIG_IsOK(ecode2)) {
13122     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
13123   }
13124   arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
13125   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
13126   if (!SWIG_IsOK(res3)) {
13127     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_resize" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
13128   }
13129   arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
13130   (arg1)->resize(arg2,arg3);
13131   resultobj = SWIG_Py_Void();
13132   return resultobj;
13133 fail:
13134   return NULL;
13135 }
13136
13137
13138 SWIGINTERN PyObject *_wrap_VectorShapes_resize(PyObject *self, PyObject *args) {
13139   int argc;
13140   PyObject *argv[4];
13141   int ii;
13142
13143   if (!PyTuple_Check(args)) SWIG_fail;
13144   argc = PyObject_Length(args);
13145   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
13146     argv[ii] = PyTuple_GET_ITEM(args,ii);
13147   }
13148   if (argc == 2) {
13149     int _v;
13150     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
13151     _v = SWIG_CheckState(res);
13152     if (_v) {
13153       {
13154         int res = SWIG_AsVal_size_t(argv[1], NULL);
13155         _v = SWIG_CheckState(res);
13156       }
13157       if (_v) {
13158         return _wrap_VectorShapes_resize__SWIG_0(self, args);
13159       }
13160     }
13161   }
13162   if (argc == 3) {
13163     int _v;
13164     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
13165     _v = SWIG_CheckState(res);
13166     if (_v) {
13167       {
13168         int res = SWIG_AsVal_size_t(argv[1], NULL);
13169         _v = SWIG_CheckState(res);
13170       }
13171       if (_v) {
13172         void *vptr = 0;
13173         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
13174         _v = SWIG_CheckState(res);
13175         if (_v) {
13176           return _wrap_VectorShapes_resize__SWIG_1(self, args);
13177         }
13178       }
13179     }
13180   }
13181
13182 fail:
13183   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<Hex::NewShape * >::size_type)\n    resize(std::vector<Hex::NewShape * >::size_type,std::vector<Hex::NewShape * >::value_type)\n");
13184   return NULL;
13185 }
13186
13187
13188 SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13189   PyObject *resultobj = 0;
13190   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13191   std::vector<Hex::NewShape * >::iterator arg2 ;
13192   std::vector<Hex::NewShape * >::value_type arg3 = (std::vector<Hex::NewShape * >::value_type) 0 ;
13193   std::vector<Hex::NewShape * >::iterator result;
13194   void *argp1 = 0 ;
13195   int res1 = 0 ;
13196   swig::PySwigIterator *iter2 = 0 ;
13197   int res2 ;
13198   void *argp3 = 0 ;
13199   int res3 = 0 ;
13200   PyObject * obj0 = 0 ;
13201   PyObject * obj1 = 0 ;
13202   PyObject * obj2 = 0 ;
13203
13204   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_insert",&obj0,&obj1,&obj2)) SWIG_fail;
13205   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
13206   if (!SWIG_IsOK(res1)) {
13207     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13208   }
13209   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13210   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
13211   if (!SWIG_IsOK(res2) || !iter2) {
13212     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
13213   } else {
13214     swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
13215     if (iter_t) {
13216       arg2 = iter_t->get_current();
13217     } else {
13218       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
13219     }
13220   }
13221   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
13222   if (!SWIG_IsOK(res3)) {
13223     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
13224   }
13225   arg3 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp3);
13226   result = (arg1)->insert(arg2,arg3);
13227   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<Hex::NewShape * >::iterator & >(result)),
13228     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
13229   return resultobj;
13230 fail:
13231   return NULL;
13232 }
13233
13234
13235 SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13236   PyObject *resultobj = 0;
13237   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13238   std::vector<Hex::NewShape * >::iterator arg2 ;
13239   std::vector<Hex::NewShape * >::size_type arg3 ;
13240   std::vector<Hex::NewShape * >::value_type arg4 = (std::vector<Hex::NewShape * >::value_type) 0 ;
13241   void *argp1 = 0 ;
13242   int res1 = 0 ;
13243   swig::PySwigIterator *iter2 = 0 ;
13244   int res2 ;
13245   size_t val3 ;
13246   int ecode3 = 0 ;
13247   void *argp4 = 0 ;
13248   int res4 = 0 ;
13249   PyObject * obj0 = 0 ;
13250   PyObject * obj1 = 0 ;
13251   PyObject * obj2 = 0 ;
13252   PyObject * obj3 = 0 ;
13253
13254   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13255   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
13256   if (!SWIG_IsOK(res1)) {
13257     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13258   }
13259   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13260   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
13261   if (!SWIG_IsOK(res2) || !iter2) {
13262     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
13263   } else {
13264     swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter2);
13265     if (iter_t) {
13266       arg2 = iter_t->get_current();
13267     } else {
13268       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::iterator""'");
13269     }
13270   }
13271   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
13272   if (!SWIG_IsOK(ecode3)) {
13273     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
13274   }
13275   arg3 = static_cast< std::vector<Hex::NewShape * >::size_type >(val3);
13276   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0 |  0 );
13277   if (!SWIG_IsOK(res4)) {
13278     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes_insert" "', argument " "4"" of type '" "std::vector<Hex::NewShape * >::value_type""'");
13279   }
13280   arg4 = reinterpret_cast< std::vector<Hex::NewShape * >::value_type >(argp4);
13281   (arg1)->insert(arg2,arg3,arg4);
13282   resultobj = SWIG_Py_Void();
13283   return resultobj;
13284 fail:
13285   return NULL;
13286 }
13287
13288
13289 SWIGINTERN PyObject *_wrap_VectorShapes_insert(PyObject *self, PyObject *args) {
13290   int argc;
13291   PyObject *argv[5];
13292   int ii;
13293
13294   if (!PyTuple_Check(args)) SWIG_fail;
13295   argc = PyObject_Length(args);
13296   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
13297     argv[ii] = PyTuple_GET_ITEM(args,ii);
13298   }
13299   if (argc == 3) {
13300     int _v;
13301     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
13302     _v = SWIG_CheckState(res);
13303     if (_v) {
13304       swig::PySwigIterator *iter = 0;
13305       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
13306       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
13307       if (_v) {
13308         void *vptr = 0;
13309         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
13310         _v = SWIG_CheckState(res);
13311         if (_v) {
13312           return _wrap_VectorShapes_insert__SWIG_0(self, args);
13313         }
13314       }
13315     }
13316   }
13317   if (argc == 4) {
13318     int _v;
13319     int res = swig::asptr(argv[0], (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > >**)(0));
13320     _v = SWIG_CheckState(res);
13321     if (_v) {
13322       swig::PySwigIterator *iter = 0;
13323       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
13324       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<Hex::NewShape * >::iterator > *>(iter) != 0));
13325       if (_v) {
13326         {
13327           int res = SWIG_AsVal_size_t(argv[2], NULL);
13328           _v = SWIG_CheckState(res);
13329         }
13330         if (_v) {
13331           void *vptr = 0;
13332           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0);
13333           _v = SWIG_CheckState(res);
13334           if (_v) {
13335             return _wrap_VectorShapes_insert__SWIG_1(self, args);
13336           }
13337         }
13338       }
13339     }
13340   }
13341
13342 fail:
13343   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorShapes_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<Hex::NewShape * >::iterator,std::vector<Hex::NewShape * >::value_type)\n    insert(std::vector<Hex::NewShape * >::iterator,std::vector<Hex::NewShape * >::size_type,std::vector<Hex::NewShape * >::value_type)\n");
13344   return NULL;
13345 }
13346
13347
13348 SWIGINTERN PyObject *_wrap_VectorShapes_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13349   PyObject *resultobj = 0;
13350   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13351   std::vector<Hex::NewShape * >::size_type arg2 ;
13352   void *argp1 = 0 ;
13353   int res1 = 0 ;
13354   size_t val2 ;
13355   int ecode2 = 0 ;
13356   PyObject * obj0 = 0 ;
13357   PyObject * obj1 = 0 ;
13358
13359   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_reserve",&obj0,&obj1)) SWIG_fail;
13360   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
13361   if (!SWIG_IsOK(res1)) {
13362     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_reserve" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13363   }
13364   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13365   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13366   if (!SWIG_IsOK(ecode2)) {
13367     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_reserve" "', argument " "2"" of type '" "std::vector<Hex::NewShape * >::size_type""'");
13368   }
13369   arg2 = static_cast< std::vector<Hex::NewShape * >::size_type >(val2);
13370   (arg1)->reserve(arg2);
13371   resultobj = SWIG_Py_Void();
13372   return resultobj;
13373 fail:
13374   return NULL;
13375 }
13376
13377
13378 SWIGINTERN PyObject *_wrap_VectorShapes_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13379   PyObject *resultobj = 0;
13380   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13381   std::vector<Hex::NewShape * >::size_type result;
13382   void *argp1 = 0 ;
13383   int res1 = 0 ;
13384   PyObject * obj0 = 0 ;
13385
13386   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_capacity",&obj0)) SWIG_fail;
13387   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0 |  0 );
13388   if (!SWIG_IsOK(res1)) {
13389     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_capacity" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > const *""'");
13390   }
13391   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13392   result = ((std::vector<Hex::NewShape * > const *)arg1)->capacity();
13393   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
13394   return resultobj;
13395 fail:
13396   return NULL;
13397 }
13398
13399
13400 SWIGINTERN PyObject *_wrap_delete_VectorShapes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13401   PyObject *resultobj = 0;
13402   std::vector<Hex::NewShape * > *arg1 = (std::vector<Hex::NewShape * > *) 0 ;
13403   void *argp1 = 0 ;
13404   int res1 = 0 ;
13405   PyObject * obj0 = 0 ;
13406
13407   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorShapes",&obj0)) SWIG_fail;
13408   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_POINTER_DISOWN |  0 );
13409   if (!SWIG_IsOK(res1)) {
13410     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorShapes" "', argument " "1"" of type '" "std::vector<Hex::NewShape * > *""'");
13411   }
13412   arg1 = reinterpret_cast< std::vector<Hex::NewShape * > * >(argp1);
13413   delete arg1;
13414
13415   resultobj = SWIG_Py_Void();
13416   return resultobj;
13417 fail:
13418   return NULL;
13419 }
13420
13421
13422 SWIGINTERN PyObject *VectorShapes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13423   PyObject *obj;
13424   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
13425   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, SWIG_NewClientData(obj));
13426   return SWIG_Py_Void();
13427 }
13428
13429 SWIGINTERN PyObject *_wrap_VectorReal_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13430   PyObject *resultobj = 0;
13431   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13432   PyObject **arg2 = (PyObject **) 0 ;
13433   swig::PySwigIterator *result = 0 ;
13434   void *argp1 = 0 ;
13435   int res1 = 0 ;
13436   PyObject * obj0 = 0 ;
13437
13438   arg2 = &obj0;
13439   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_iterator",&obj0)) SWIG_fail;
13440   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13441   if (!SWIG_IsOK(res1)) {
13442     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_iterator" "', argument " "1"" of type '" "std::vector<double > *""'");
13443   }
13444   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13445   result = (swig::PySwigIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
13446   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
13447   return resultobj;
13448 fail:
13449   return NULL;
13450 }
13451
13452
13453 SWIGINTERN PyObject *_wrap_VectorReal___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13454   PyObject *resultobj = 0;
13455   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13456   bool result;
13457   void *argp1 = 0 ;
13458   int res1 = 0 ;
13459   PyObject * obj0 = 0 ;
13460
13461   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___nonzero__",&obj0)) SWIG_fail;
13462   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13463   if (!SWIG_IsOK(res1)) {
13464     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___nonzero__" "', argument " "1"" of type '" "std::vector<double > const *""'");
13465   }
13466   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13467   result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector<double > const *)arg1);
13468   resultobj = SWIG_From_bool(static_cast< bool >(result));
13469   return resultobj;
13470 fail:
13471   return NULL;
13472 }
13473
13474
13475 SWIGINTERN PyObject *_wrap_VectorReal___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13476   PyObject *resultobj = 0;
13477   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13478   std::vector<double >::size_type result;
13479   void *argp1 = 0 ;
13480   int res1 = 0 ;
13481   PyObject * obj0 = 0 ;
13482
13483   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___len__",&obj0)) SWIG_fail;
13484   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13485   if (!SWIG_IsOK(res1)) {
13486     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___len__" "', argument " "1"" of type '" "std::vector<double > const *""'");
13487   }
13488   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13489   result = std_vector_Sl_double_Sg____len__((std::vector<double > const *)arg1);
13490   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
13491   return resultobj;
13492 fail:
13493   return NULL;
13494 }
13495
13496
13497 SWIGINTERN PyObject *_wrap_VectorReal_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13498   PyObject *resultobj = 0;
13499   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13500   std::vector<double >::value_type result;
13501   void *argp1 = 0 ;
13502   int res1 = 0 ;
13503   PyObject * obj0 = 0 ;
13504
13505   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop",&obj0)) SWIG_fail;
13506   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13507   if (!SWIG_IsOK(res1)) {
13508     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop" "', argument " "1"" of type '" "std::vector<double > *""'");
13509   }
13510   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13511   try {
13512     result = (std::vector<double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
13513   }
13514   catch(std::out_of_range &_e) {
13515     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13516   }
13517
13518   resultobj = SWIG_From_double(static_cast< double >(result));
13519   return resultobj;
13520 fail:
13521   return NULL;
13522 }
13523
13524
13525 SWIGINTERN PyObject *_wrap_VectorReal___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13526   PyObject *resultobj = 0;
13527   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13528   std::vector<double >::difference_type arg2 ;
13529   std::vector<double >::difference_type arg3 ;
13530   std::vector<double,std::allocator<double > > *result = 0 ;
13531   void *argp1 = 0 ;
13532   int res1 = 0 ;
13533   ptrdiff_t val2 ;
13534   int ecode2 = 0 ;
13535   ptrdiff_t val3 ;
13536   int ecode3 = 0 ;
13537   PyObject * obj0 = 0 ;
13538   PyObject * obj1 = 0 ;
13539   PyObject * obj2 = 0 ;
13540
13541   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
13542   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13543   if (!SWIG_IsOK(res1)) {
13544     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getslice__" "', argument " "1"" of type '" "std::vector<double > *""'");
13545   }
13546   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13547   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13548   if (!SWIG_IsOK(ecode2)) {
13549     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getslice__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13550   }
13551   arg2 = static_cast< std::vector<double >::difference_type >(val2);
13552   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
13553   if (!SWIG_IsOK(ecode3)) {
13554     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___getslice__" "', argument " "3"" of type '" "std::vector<double >::difference_type""'");
13555   }
13556   arg3 = static_cast< std::vector<double >::difference_type >(val3);
13557   try {
13558     result = (std::vector<double,std::allocator<double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
13559   }
13560   catch(std::out_of_range &_e) {
13561     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13562   }
13563
13564   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_OWN |  0 );
13565   return resultobj;
13566 fail:
13567   return NULL;
13568 }
13569
13570
13571 SWIGINTERN PyObject *_wrap_VectorReal___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13572   PyObject *resultobj = 0;
13573   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13574   std::vector<double >::difference_type arg2 ;
13575   std::vector<double >::difference_type arg3 ;
13576   std::vector<double,std::allocator<double > > *arg4 = 0 ;
13577   void *argp1 = 0 ;
13578   int res1 = 0 ;
13579   ptrdiff_t val2 ;
13580   int ecode2 = 0 ;
13581   ptrdiff_t val3 ;
13582   int ecode3 = 0 ;
13583   int res4 = SWIG_OLDOBJ ;
13584   PyObject * obj0 = 0 ;
13585   PyObject * obj1 = 0 ;
13586   PyObject * obj2 = 0 ;
13587   PyObject * obj3 = 0 ;
13588
13589   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13590   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13591   if (!SWIG_IsOK(res1)) {
13592     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setslice__" "', argument " "1"" of type '" "std::vector<double > *""'");
13593   }
13594   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13595   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13596   if (!SWIG_IsOK(ecode2)) {
13597     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setslice__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13598   }
13599   arg2 = static_cast< std::vector<double >::difference_type >(val2);
13600   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
13601   if (!SWIG_IsOK(ecode3)) {
13602     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setslice__" "', argument " "3"" of type '" "std::vector<double >::difference_type""'");
13603   }
13604   arg3 = static_cast< std::vector<double >::difference_type >(val3);
13605   {
13606     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
13607     res4 = swig::asptr(obj3, &ptr);
13608     if (!SWIG_IsOK(res4)) {
13609       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector<double,std::allocator<double > > const &""'");
13610     }
13611     if (!ptr) {
13612       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector<double,std::allocator<double > > const &""'");
13613     }
13614     arg4 = ptr;
13615   }
13616   try {
13617     std_vector_Sl_double_Sg____setslice__(arg1,arg2,arg3,(std::vector<double,std::allocator<double > > const &)*arg4);
13618   }
13619   catch(std::out_of_range &_e) {
13620     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13621   }
13622   catch(std::invalid_argument &_e) {
13623     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
13624   }
13625
13626   resultobj = SWIG_Py_Void();
13627   if (SWIG_IsNewObj(res4)) delete arg4;
13628   return resultobj;
13629 fail:
13630   if (SWIG_IsNewObj(res4)) delete arg4;
13631   return NULL;
13632 }
13633
13634
13635 SWIGINTERN PyObject *_wrap_VectorReal___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13636   PyObject *resultobj = 0;
13637   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13638   std::vector<double >::difference_type arg2 ;
13639   std::vector<double >::difference_type arg3 ;
13640   void *argp1 = 0 ;
13641   int res1 = 0 ;
13642   ptrdiff_t val2 ;
13643   int ecode2 = 0 ;
13644   ptrdiff_t val3 ;
13645   int ecode3 = 0 ;
13646   PyObject * obj0 = 0 ;
13647   PyObject * obj1 = 0 ;
13648   PyObject * obj2 = 0 ;
13649
13650   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
13651   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13652   if (!SWIG_IsOK(res1)) {
13653     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delslice__" "', argument " "1"" of type '" "std::vector<double > *""'");
13654   }
13655   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13656   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13657   if (!SWIG_IsOK(ecode2)) {
13658     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delslice__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13659   }
13660   arg2 = static_cast< std::vector<double >::difference_type >(val2);
13661   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
13662   if (!SWIG_IsOK(ecode3)) {
13663     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___delslice__" "', argument " "3"" of type '" "std::vector<double >::difference_type""'");
13664   }
13665   arg3 = static_cast< std::vector<double >::difference_type >(val3);
13666   try {
13667     std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
13668   }
13669   catch(std::out_of_range &_e) {
13670     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13671   }
13672
13673   resultobj = SWIG_Py_Void();
13674   return resultobj;
13675 fail:
13676   return NULL;
13677 }
13678
13679
13680 SWIGINTERN PyObject *_wrap_VectorReal___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13681   PyObject *resultobj = 0;
13682   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13683   std::vector<double >::difference_type arg2 ;
13684   void *argp1 = 0 ;
13685   int res1 = 0 ;
13686   ptrdiff_t val2 ;
13687   int ecode2 = 0 ;
13688   PyObject * obj0 = 0 ;
13689   PyObject * obj1 = 0 ;
13690
13691   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___delitem__",&obj0,&obj1)) SWIG_fail;
13692   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13693   if (!SWIG_IsOK(res1)) {
13694     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delitem__" "', argument " "1"" of type '" "std::vector<double > *""'");
13695   }
13696   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13697   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13698   if (!SWIG_IsOK(ecode2)) {
13699     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delitem__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13700   }
13701   arg2 = static_cast< std::vector<double >::difference_type >(val2);
13702   try {
13703     std_vector_Sl_double_Sg____delitem__(arg1,arg2);
13704   }
13705   catch(std::out_of_range &_e) {
13706     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13707   }
13708
13709   resultobj = SWIG_Py_Void();
13710   return resultobj;
13711 fail:
13712   return NULL;
13713 }
13714
13715
13716 SWIGINTERN PyObject *_wrap_VectorReal___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13717   PyObject *resultobj = 0;
13718   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13719   std::vector<double >::difference_type arg2 ;
13720   std::vector<double >::value_type *result = 0 ;
13721   void *argp1 = 0 ;
13722   int res1 = 0 ;
13723   ptrdiff_t val2 ;
13724   int ecode2 = 0 ;
13725   PyObject * obj0 = 0 ;
13726   PyObject * obj1 = 0 ;
13727
13728   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___getitem__",&obj0,&obj1)) SWIG_fail;
13729   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13730   if (!SWIG_IsOK(res1)) {
13731     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getitem__" "', argument " "1"" of type '" "std::vector<double > const *""'");
13732   }
13733   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13734   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13735   if (!SWIG_IsOK(ecode2)) {
13736     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getitem__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13737   }
13738   arg2 = static_cast< std::vector<double >::difference_type >(val2);
13739   try {
13740     {
13741       std::vector<double >::value_type const &_result_ref = std_vector_Sl_double_Sg____getitem__((std::vector<double > const *)arg1,arg2);
13742       result = (std::vector<double >::value_type *) &_result_ref;
13743     }
13744   }
13745   catch(std::out_of_range &_e) {
13746     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13747   }
13748
13749   resultobj = SWIG_From_double(static_cast< double >(*result));
13750   return resultobj;
13751 fail:
13752   return NULL;
13753 }
13754
13755
13756 SWIGINTERN PyObject *_wrap_VectorReal___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13757   PyObject *resultobj = 0;
13758   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13759   std::vector<double >::difference_type arg2 ;
13760   std::vector<double >::value_type *arg3 = 0 ;
13761   void *argp1 = 0 ;
13762   int res1 = 0 ;
13763   ptrdiff_t val2 ;
13764   int ecode2 = 0 ;
13765   std::vector<double >::value_type temp3 ;
13766   double val3 ;
13767   int ecode3 = 0 ;
13768   PyObject * obj0 = 0 ;
13769   PyObject * obj1 = 0 ;
13770   PyObject * obj2 = 0 ;
13771
13772   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
13773   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13774   if (!SWIG_IsOK(res1)) {
13775     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector<double > *""'");
13776   }
13777   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13778   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13779   if (!SWIG_IsOK(ecode2)) {
13780     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setitem__" "', argument " "2"" of type '" "std::vector<double >::difference_type""'");
13781   }
13782   arg2 = static_cast< std::vector<double >::difference_type >(val2);
13783   ecode3 = SWIG_AsVal_double(obj2, &val3);
13784   if (!SWIG_IsOK(ecode3)) {
13785     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
13786   }
13787   temp3 = static_cast< std::vector<double >::value_type >(val3);
13788   arg3 = &temp3;
13789   try {
13790     std_vector_Sl_double_Sg____setitem__(arg1,arg2,(double const &)*arg3);
13791   }
13792   catch(std::out_of_range &_e) {
13793     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13794   }
13795
13796   resultobj = SWIG_Py_Void();
13797   return resultobj;
13798 fail:
13799   return NULL;
13800 }
13801
13802
13803 SWIGINTERN PyObject *_wrap_VectorReal_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13804   PyObject *resultobj = 0;
13805   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13806   std::vector<double >::value_type *arg2 = 0 ;
13807   void *argp1 = 0 ;
13808   int res1 = 0 ;
13809   std::vector<double >::value_type temp2 ;
13810   double val2 ;
13811   int ecode2 = 0 ;
13812   PyObject * obj0 = 0 ;
13813   PyObject * obj1 = 0 ;
13814
13815   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_append",&obj0,&obj1)) SWIG_fail;
13816   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13817   if (!SWIG_IsOK(res1)) {
13818     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_append" "', argument " "1"" of type '" "std::vector<double > *""'");
13819   }
13820   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13821   ecode2 = SWIG_AsVal_double(obj1, &val2);
13822   if (!SWIG_IsOK(ecode2)) {
13823     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_append" "', argument " "2"" of type '" "std::vector<double >::value_type""'");
13824   }
13825   temp2 = static_cast< std::vector<double >::value_type >(val2);
13826   arg2 = &temp2;
13827   std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
13828   resultobj = SWIG_Py_Void();
13829   return resultobj;
13830 fail:
13831   return NULL;
13832 }
13833
13834
13835 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13836   PyObject *resultobj = 0;
13837   std::vector<double > *result = 0 ;
13838
13839   if (!PyArg_ParseTuple(args,(char *)":new_VectorReal")) SWIG_fail;
13840   result = (std::vector<double > *)new std::vector<double >();
13841   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW |  0 );
13842   return resultobj;
13843 fail:
13844   return NULL;
13845 }
13846
13847
13848 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13849   PyObject *resultobj = 0;
13850   std::vector<double > *arg1 = 0 ;
13851   std::vector<double > *result = 0 ;
13852   int res1 = SWIG_OLDOBJ ;
13853   PyObject * obj0 = 0 ;
13854
13855   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
13856   {
13857     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
13858     res1 = swig::asptr(obj0, &ptr);
13859     if (!SWIG_IsOK(res1)) {
13860       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double > const &""'");
13861     }
13862     if (!ptr) {
13863       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double > const &""'");
13864     }
13865     arg1 = ptr;
13866   }
13867   result = (std::vector<double > *)new std::vector<double >((std::vector<double > const &)*arg1);
13868   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW |  0 );
13869   if (SWIG_IsNewObj(res1)) delete arg1;
13870   return resultobj;
13871 fail:
13872   if (SWIG_IsNewObj(res1)) delete arg1;
13873   return NULL;
13874 }
13875
13876
13877 SWIGINTERN PyObject *_wrap_VectorReal_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13878   PyObject *resultobj = 0;
13879   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13880   bool result;
13881   void *argp1 = 0 ;
13882   int res1 = 0 ;
13883   PyObject * obj0 = 0 ;
13884
13885   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_empty",&obj0)) SWIG_fail;
13886   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13887   if (!SWIG_IsOK(res1)) {
13888     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_empty" "', argument " "1"" of type '" "std::vector<double > const *""'");
13889   }
13890   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13891   result = (bool)((std::vector<double > const *)arg1)->empty();
13892   resultobj = SWIG_From_bool(static_cast< bool >(result));
13893   return resultobj;
13894 fail:
13895   return NULL;
13896 }
13897
13898
13899 SWIGINTERN PyObject *_wrap_VectorReal_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13900   PyObject *resultobj = 0;
13901   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13902   std::vector<double >::size_type result;
13903   void *argp1 = 0 ;
13904   int res1 = 0 ;
13905   PyObject * obj0 = 0 ;
13906
13907   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_size",&obj0)) SWIG_fail;
13908   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13909   if (!SWIG_IsOK(res1)) {
13910     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_size" "', argument " "1"" of type '" "std::vector<double > const *""'");
13911   }
13912   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13913   result = ((std::vector<double > const *)arg1)->size();
13914   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
13915   return resultobj;
13916 fail:
13917   return NULL;
13918 }
13919
13920
13921 SWIGINTERN PyObject *_wrap_VectorReal_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13922   PyObject *resultobj = 0;
13923   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13924   void *argp1 = 0 ;
13925   int res1 = 0 ;
13926   PyObject * obj0 = 0 ;
13927
13928   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_clear",&obj0)) SWIG_fail;
13929   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13930   if (!SWIG_IsOK(res1)) {
13931     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_clear" "', argument " "1"" of type '" "std::vector<double > *""'");
13932   }
13933   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13934   (arg1)->clear();
13935   resultobj = SWIG_Py_Void();
13936   return resultobj;
13937 fail:
13938   return NULL;
13939 }
13940
13941
13942 SWIGINTERN PyObject *_wrap_VectorReal_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13943   PyObject *resultobj = 0;
13944   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13945   std::vector<double > *arg2 = 0 ;
13946   void *argp1 = 0 ;
13947   int res1 = 0 ;
13948   void *argp2 = 0 ;
13949   int res2 = 0 ;
13950   PyObject * obj0 = 0 ;
13951   PyObject * obj1 = 0 ;
13952
13953   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_swap",&obj0,&obj1)) SWIG_fail;
13954   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13955   if (!SWIG_IsOK(res1)) {
13956     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_swap" "', argument " "1"" of type '" "std::vector<double > *""'");
13957   }
13958   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13959   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t,  0 );
13960   if (!SWIG_IsOK(res2)) {
13961     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector<double > &""'");
13962   }
13963   if (!argp2) {
13964     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector<double > &""'");
13965   }
13966   arg2 = reinterpret_cast< std::vector<double > * >(argp2);
13967   (arg1)->swap(*arg2);
13968   resultobj = SWIG_Py_Void();
13969   return resultobj;
13970 fail:
13971   return NULL;
13972 }
13973
13974
13975 SWIGINTERN PyObject *_wrap_VectorReal_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13976   PyObject *resultobj = 0;
13977   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
13978   SwigValueWrapper<std::allocator<double > > result;
13979   void *argp1 = 0 ;
13980   int res1 = 0 ;
13981   PyObject * obj0 = 0 ;
13982
13983   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_get_allocator",&obj0)) SWIG_fail;
13984   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
13985   if (!SWIG_IsOK(res1)) {
13986     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_get_allocator" "', argument " "1"" of type '" "std::vector<double > const *""'");
13987   }
13988   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
13989   result = ((std::vector<double > const *)arg1)->get_allocator();
13990   resultobj = SWIG_NewPointerObj((new std::vector<double >::allocator_type(static_cast< const std::vector<double >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
13991   return resultobj;
13992 fail:
13993   return NULL;
13994 }
13995
13996
13997 SWIGINTERN PyObject *_wrap_VectorReal_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13998   PyObject *resultobj = 0;
13999   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14000   std::vector<double >::iterator result;
14001   void *argp1 = 0 ;
14002   int res1 = 0 ;
14003   PyObject * obj0 = 0 ;
14004
14005   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_begin",&obj0)) SWIG_fail;
14006   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14007   if (!SWIG_IsOK(res1)) {
14008     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_begin" "', argument " "1"" of type '" "std::vector<double > *""'");
14009   }
14010   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14011   result = (arg1)->begin();
14012   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
14013     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14014   return resultobj;
14015 fail:
14016   return NULL;
14017 }
14018
14019
14020 SWIGINTERN PyObject *_wrap_VectorReal_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14021   PyObject *resultobj = 0;
14022   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14023   std::vector<double >::const_iterator result;
14024   void *argp1 = 0 ;
14025   int res1 = 0 ;
14026   PyObject * obj0 = 0 ;
14027
14028   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_begin",&obj0)) SWIG_fail;
14029   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14030   if (!SWIG_IsOK(res1)) {
14031     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_begin" "', argument " "1"" of type '" "std::vector<double > const *""'");
14032   }
14033   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14034   result = ((std::vector<double > const *)arg1)->begin();
14035   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_iterator & >(result)),
14036     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14037   return resultobj;
14038 fail:
14039   return NULL;
14040 }
14041
14042
14043 SWIGINTERN PyObject *_wrap_VectorReal_begin(PyObject *self, PyObject *args) {
14044   int argc;
14045   PyObject *argv[2];
14046   int ii;
14047
14048   if (!PyTuple_Check(args)) SWIG_fail;
14049   argc = PyObject_Length(args);
14050   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
14051     argv[ii] = PyTuple_GET_ITEM(args,ii);
14052   }
14053   if (argc == 1) {
14054     int _v;
14055     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14056     _v = SWIG_CheckState(res);
14057     if (_v) {
14058       return _wrap_VectorReal_begin__SWIG_0(self, args);
14059     }
14060   }
14061   if (argc == 1) {
14062     int _v;
14063     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14064     _v = SWIG_CheckState(res);
14065     if (_v) {
14066       return _wrap_VectorReal_begin__SWIG_1(self, args);
14067     }
14068   }
14069
14070 fail:
14071   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
14072   return NULL;
14073 }
14074
14075
14076 SWIGINTERN PyObject *_wrap_VectorReal_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14077   PyObject *resultobj = 0;
14078   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14079   std::vector<double >::iterator result;
14080   void *argp1 = 0 ;
14081   int res1 = 0 ;
14082   PyObject * obj0 = 0 ;
14083
14084   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_end",&obj0)) SWIG_fail;
14085   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14086   if (!SWIG_IsOK(res1)) {
14087     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_end" "', argument " "1"" of type '" "std::vector<double > *""'");
14088   }
14089   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14090   result = (arg1)->end();
14091   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
14092     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14093   return resultobj;
14094 fail:
14095   return NULL;
14096 }
14097
14098
14099 SWIGINTERN PyObject *_wrap_VectorReal_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14100   PyObject *resultobj = 0;
14101   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14102   std::vector<double >::const_iterator result;
14103   void *argp1 = 0 ;
14104   int res1 = 0 ;
14105   PyObject * obj0 = 0 ;
14106
14107   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_end",&obj0)) SWIG_fail;
14108   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14109   if (!SWIG_IsOK(res1)) {
14110     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_end" "', argument " "1"" of type '" "std::vector<double > const *""'");
14111   }
14112   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14113   result = ((std::vector<double > const *)arg1)->end();
14114   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_iterator & >(result)),
14115     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14116   return resultobj;
14117 fail:
14118   return NULL;
14119 }
14120
14121
14122 SWIGINTERN PyObject *_wrap_VectorReal_end(PyObject *self, PyObject *args) {
14123   int argc;
14124   PyObject *argv[2];
14125   int ii;
14126
14127   if (!PyTuple_Check(args)) SWIG_fail;
14128   argc = PyObject_Length(args);
14129   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
14130     argv[ii] = PyTuple_GET_ITEM(args,ii);
14131   }
14132   if (argc == 1) {
14133     int _v;
14134     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14135     _v = SWIG_CheckState(res);
14136     if (_v) {
14137       return _wrap_VectorReal_end__SWIG_0(self, args);
14138     }
14139   }
14140   if (argc == 1) {
14141     int _v;
14142     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14143     _v = SWIG_CheckState(res);
14144     if (_v) {
14145       return _wrap_VectorReal_end__SWIG_1(self, args);
14146     }
14147   }
14148
14149 fail:
14150   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
14151   return NULL;
14152 }
14153
14154
14155 SWIGINTERN PyObject *_wrap_VectorReal_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14156   PyObject *resultobj = 0;
14157   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14158   std::vector<double >::reverse_iterator result;
14159   void *argp1 = 0 ;
14160   int res1 = 0 ;
14161   PyObject * obj0 = 0 ;
14162
14163   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rbegin",&obj0)) SWIG_fail;
14164   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14165   if (!SWIG_IsOK(res1)) {
14166     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rbegin" "', argument " "1"" of type '" "std::vector<double > *""'");
14167   }
14168   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14169   result = (arg1)->rbegin();
14170   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::reverse_iterator & >(result)),
14171     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14172   return resultobj;
14173 fail:
14174   return NULL;
14175 }
14176
14177
14178 SWIGINTERN PyObject *_wrap_VectorReal_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14179   PyObject *resultobj = 0;
14180   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14181   std::vector<double >::const_reverse_iterator result;
14182   void *argp1 = 0 ;
14183   int res1 = 0 ;
14184   PyObject * obj0 = 0 ;
14185
14186   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rbegin",&obj0)) SWIG_fail;
14187   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14188   if (!SWIG_IsOK(res1)) {
14189     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rbegin" "', argument " "1"" of type '" "std::vector<double > const *""'");
14190   }
14191   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14192   result = ((std::vector<double > const *)arg1)->rbegin();
14193   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_reverse_iterator & >(result)),
14194     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14195   return resultobj;
14196 fail:
14197   return NULL;
14198 }
14199
14200
14201 SWIGINTERN PyObject *_wrap_VectorReal_rbegin(PyObject *self, PyObject *args) {
14202   int argc;
14203   PyObject *argv[2];
14204   int ii;
14205
14206   if (!PyTuple_Check(args)) SWIG_fail;
14207   argc = PyObject_Length(args);
14208   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
14209     argv[ii] = PyTuple_GET_ITEM(args,ii);
14210   }
14211   if (argc == 1) {
14212     int _v;
14213     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14214     _v = SWIG_CheckState(res);
14215     if (_v) {
14216       return _wrap_VectorReal_rbegin__SWIG_0(self, args);
14217     }
14218   }
14219   if (argc == 1) {
14220     int _v;
14221     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14222     _v = SWIG_CheckState(res);
14223     if (_v) {
14224       return _wrap_VectorReal_rbegin__SWIG_1(self, args);
14225     }
14226   }
14227
14228 fail:
14229   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
14230   return NULL;
14231 }
14232
14233
14234 SWIGINTERN PyObject *_wrap_VectorReal_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14235   PyObject *resultobj = 0;
14236   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14237   std::vector<double >::reverse_iterator result;
14238   void *argp1 = 0 ;
14239   int res1 = 0 ;
14240   PyObject * obj0 = 0 ;
14241
14242   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rend",&obj0)) SWIG_fail;
14243   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14244   if (!SWIG_IsOK(res1)) {
14245     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rend" "', argument " "1"" of type '" "std::vector<double > *""'");
14246   }
14247   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14248   result = (arg1)->rend();
14249   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::reverse_iterator & >(result)),
14250     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14251   return resultobj;
14252 fail:
14253   return NULL;
14254 }
14255
14256
14257 SWIGINTERN PyObject *_wrap_VectorReal_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14258   PyObject *resultobj = 0;
14259   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14260   std::vector<double >::const_reverse_iterator result;
14261   void *argp1 = 0 ;
14262   int res1 = 0 ;
14263   PyObject * obj0 = 0 ;
14264
14265   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rend",&obj0)) SWIG_fail;
14266   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14267   if (!SWIG_IsOK(res1)) {
14268     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rend" "', argument " "1"" of type '" "std::vector<double > const *""'");
14269   }
14270   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14271   result = ((std::vector<double > const *)arg1)->rend();
14272   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::const_reverse_iterator & >(result)),
14273     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14274   return resultobj;
14275 fail:
14276   return NULL;
14277 }
14278
14279
14280 SWIGINTERN PyObject *_wrap_VectorReal_rend(PyObject *self, PyObject *args) {
14281   int argc;
14282   PyObject *argv[2];
14283   int ii;
14284
14285   if (!PyTuple_Check(args)) SWIG_fail;
14286   argc = PyObject_Length(args);
14287   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
14288     argv[ii] = PyTuple_GET_ITEM(args,ii);
14289   }
14290   if (argc == 1) {
14291     int _v;
14292     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14293     _v = SWIG_CheckState(res);
14294     if (_v) {
14295       return _wrap_VectorReal_rend__SWIG_0(self, args);
14296     }
14297   }
14298   if (argc == 1) {
14299     int _v;
14300     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14301     _v = SWIG_CheckState(res);
14302     if (_v) {
14303       return _wrap_VectorReal_rend__SWIG_1(self, args);
14304     }
14305   }
14306
14307 fail:
14308   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
14309   return NULL;
14310 }
14311
14312
14313 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14314   PyObject *resultobj = 0;
14315   std::vector<double >::size_type arg1 ;
14316   std::vector<double > *result = 0 ;
14317   size_t val1 ;
14318   int ecode1 = 0 ;
14319   PyObject * obj0 = 0 ;
14320
14321   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
14322   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
14323   if (!SWIG_IsOK(ecode1)) {
14324     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double >::size_type""'");
14325   }
14326   arg1 = static_cast< std::vector<double >::size_type >(val1);
14327   result = (std::vector<double > *)new std::vector<double >(arg1);
14328   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW |  0 );
14329   return resultobj;
14330 fail:
14331   return NULL;
14332 }
14333
14334
14335 SWIGINTERN PyObject *_wrap_VectorReal_pop_back(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
14342   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop_back",&obj0)) SWIG_fail;
14343   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14344   if (!SWIG_IsOK(res1)) {
14345     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop_back" "', argument " "1"" of type '" "std::vector<double > *""'");
14346   }
14347   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14348   (arg1)->pop_back();
14349   resultobj = SWIG_Py_Void();
14350   return resultobj;
14351 fail:
14352   return NULL;
14353 }
14354
14355
14356 SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14357   PyObject *resultobj = 0;
14358   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14359   std::vector<double >::size_type arg2 ;
14360   void *argp1 = 0 ;
14361   int res1 = 0 ;
14362   size_t val2 ;
14363   int ecode2 = 0 ;
14364   PyObject * obj0 = 0 ;
14365   PyObject * obj1 = 0 ;
14366
14367   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_resize",&obj0,&obj1)) SWIG_fail;
14368   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14369   if (!SWIG_IsOK(res1)) {
14370     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector<double > *""'");
14371   }
14372   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14373   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
14374   if (!SWIG_IsOK(ecode2)) {
14375     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
14376   }
14377   arg2 = static_cast< std::vector<double >::size_type >(val2);
14378   (arg1)->resize(arg2);
14379   resultobj = SWIG_Py_Void();
14380   return resultobj;
14381 fail:
14382   return NULL;
14383 }
14384
14385
14386 SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14387   PyObject *resultobj = 0;
14388   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14389   std::vector<double >::iterator arg2 ;
14390   std::vector<double >::iterator result;
14391   void *argp1 = 0 ;
14392   int res1 = 0 ;
14393   swig::PySwigIterator *iter2 = 0 ;
14394   int res2 ;
14395   PyObject * obj0 = 0 ;
14396   PyObject * obj1 = 0 ;
14397
14398   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_erase",&obj0,&obj1)) SWIG_fail;
14399   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14400   if (!SWIG_IsOK(res1)) {
14401     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector<double > *""'");
14402   }
14403   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14404   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
14405   if (!SWIG_IsOK(res2) || !iter2) {
14406     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14407   } else {
14408     swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
14409     if (iter_t) {
14410       arg2 = iter_t->get_current();
14411     } else {
14412       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14413     }
14414   }
14415   result = (arg1)->erase(arg2);
14416   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
14417     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14418   return resultobj;
14419 fail:
14420   return NULL;
14421 }
14422
14423
14424 SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14425   PyObject *resultobj = 0;
14426   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14427   std::vector<double >::iterator arg2 ;
14428   std::vector<double >::iterator arg3 ;
14429   std::vector<double >::iterator result;
14430   void *argp1 = 0 ;
14431   int res1 = 0 ;
14432   swig::PySwigIterator *iter2 = 0 ;
14433   int res2 ;
14434   swig::PySwigIterator *iter3 = 0 ;
14435   int res3 ;
14436   PyObject * obj0 = 0 ;
14437   PyObject * obj1 = 0 ;
14438   PyObject * obj2 = 0 ;
14439
14440   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_erase",&obj0,&obj1,&obj2)) SWIG_fail;
14441   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14442   if (!SWIG_IsOK(res1)) {
14443     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector<double > *""'");
14444   }
14445   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14446   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
14447   if (!SWIG_IsOK(res2) || !iter2) {
14448     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14449   } else {
14450     swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
14451     if (iter_t) {
14452       arg2 = iter_t->get_current();
14453     } else {
14454       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14455     }
14456   }
14457   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
14458   if (!SWIG_IsOK(res3) || !iter3) {
14459     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector<double >::iterator""'");
14460   } else {
14461     swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter3);
14462     if (iter_t) {
14463       arg3 = iter_t->get_current();
14464     } else {
14465       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector<double >::iterator""'");
14466     }
14467   }
14468   result = (arg1)->erase(arg2,arg3);
14469   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
14470     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14471   return resultobj;
14472 fail:
14473   return NULL;
14474 }
14475
14476
14477 SWIGINTERN PyObject *_wrap_VectorReal_erase(PyObject *self, PyObject *args) {
14478   int argc;
14479   PyObject *argv[4];
14480   int ii;
14481
14482   if (!PyTuple_Check(args)) SWIG_fail;
14483   argc = PyObject_Length(args);
14484   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
14485     argv[ii] = PyTuple_GET_ITEM(args,ii);
14486   }
14487   if (argc == 2) {
14488     int _v;
14489     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14490     _v = SWIG_CheckState(res);
14491     if (_v) {
14492       swig::PySwigIterator *iter = 0;
14493       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
14494       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
14495       if (_v) {
14496         return _wrap_VectorReal_erase__SWIG_0(self, args);
14497       }
14498     }
14499   }
14500   if (argc == 3) {
14501     int _v;
14502     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14503     _v = SWIG_CheckState(res);
14504     if (_v) {
14505       swig::PySwigIterator *iter = 0;
14506       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
14507       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
14508       if (_v) {
14509         swig::PySwigIterator *iter = 0;
14510         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
14511         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
14512         if (_v) {
14513           return _wrap_VectorReal_erase__SWIG_1(self, args);
14514         }
14515       }
14516     }
14517   }
14518
14519 fail:
14520   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<double >::iterator)\n    erase(std::vector<double >::iterator,std::vector<double >::iterator)\n");
14521   return NULL;
14522 }
14523
14524
14525 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14526   PyObject *resultobj = 0;
14527   std::vector<double >::size_type arg1 ;
14528   std::vector<double >::value_type *arg2 = 0 ;
14529   std::vector<double > *result = 0 ;
14530   size_t val1 ;
14531   int ecode1 = 0 ;
14532   std::vector<double >::value_type temp2 ;
14533   double val2 ;
14534   int ecode2 = 0 ;
14535   PyObject * obj0 = 0 ;
14536   PyObject * obj1 = 0 ;
14537
14538   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorReal",&obj0,&obj1)) SWIG_fail;
14539   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
14540   if (!SWIG_IsOK(ecode1)) {
14541     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector<double >::size_type""'");
14542   }
14543   arg1 = static_cast< std::vector<double >::size_type >(val1);
14544   ecode2 = SWIG_AsVal_double(obj1, &val2);
14545   if (!SWIG_IsOK(ecode2)) {
14546     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorReal" "', argument " "2"" of type '" "std::vector<double >::value_type""'");
14547   }
14548   temp2 = static_cast< std::vector<double >::value_type >(val2);
14549   arg2 = &temp2;
14550   result = (std::vector<double > *)new std::vector<double >(arg1,(std::vector<double >::value_type const &)*arg2);
14551   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_NEW |  0 );
14552   return resultobj;
14553 fail:
14554   return NULL;
14555 }
14556
14557
14558 SWIGINTERN PyObject *_wrap_new_VectorReal(PyObject *self, PyObject *args) {
14559   int argc;
14560   PyObject *argv[3];
14561   int ii;
14562
14563   if (!PyTuple_Check(args)) SWIG_fail;
14564   argc = PyObject_Length(args);
14565   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
14566     argv[ii] = PyTuple_GET_ITEM(args,ii);
14567   }
14568   if (argc == 0) {
14569     return _wrap_new_VectorReal__SWIG_0(self, args);
14570   }
14571   if (argc == 1) {
14572     int _v;
14573     {
14574       int res = SWIG_AsVal_size_t(argv[0], NULL);
14575       _v = SWIG_CheckState(res);
14576     }
14577     if (_v) {
14578       return _wrap_new_VectorReal__SWIG_2(self, args);
14579     }
14580   }
14581   if (argc == 1) {
14582     int _v;
14583     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14584     _v = SWIG_CheckState(res);
14585     if (_v) {
14586       return _wrap_new_VectorReal__SWIG_1(self, args);
14587     }
14588   }
14589   if (argc == 2) {
14590     int _v;
14591     {
14592       int res = SWIG_AsVal_size_t(argv[0], NULL);
14593       _v = SWIG_CheckState(res);
14594     }
14595     if (_v) {
14596       {
14597         int res = SWIG_AsVal_double(argv[1], NULL);
14598         _v = SWIG_CheckState(res);
14599       }
14600       if (_v) {
14601         return _wrap_new_VectorReal__SWIG_3(self, args);
14602       }
14603     }
14604   }
14605
14606 fail:
14607   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorReal'.\n  Possible C/C++ prototypes are:\n    std::vector<(double)>()\n    std::vector<(double)>(std::vector<double > const &)\n    std::vector<(double)>(std::vector<double >::size_type)\n    std::vector<(double)>(std::vector<double >::size_type,std::vector<double >::value_type const &)\n");
14608   return NULL;
14609 }
14610
14611
14612 SWIGINTERN PyObject *_wrap_VectorReal_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14613   PyObject *resultobj = 0;
14614   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14615   std::vector<double >::value_type *arg2 = 0 ;
14616   void *argp1 = 0 ;
14617   int res1 = 0 ;
14618   std::vector<double >::value_type temp2 ;
14619   double val2 ;
14620   int ecode2 = 0 ;
14621   PyObject * obj0 = 0 ;
14622   PyObject * obj1 = 0 ;
14623
14624   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_push_back",&obj0,&obj1)) SWIG_fail;
14625   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14626   if (!SWIG_IsOK(res1)) {
14627     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_push_back" "', argument " "1"" of type '" "std::vector<double > *""'");
14628   }
14629   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14630   ecode2 = SWIG_AsVal_double(obj1, &val2);
14631   if (!SWIG_IsOK(ecode2)) {
14632     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_push_back" "', argument " "2"" of type '" "std::vector<double >::value_type""'");
14633   }
14634   temp2 = static_cast< std::vector<double >::value_type >(val2);
14635   arg2 = &temp2;
14636   (arg1)->push_back((std::vector<double >::value_type const &)*arg2);
14637   resultobj = SWIG_Py_Void();
14638   return resultobj;
14639 fail:
14640   return NULL;
14641 }
14642
14643
14644 SWIGINTERN PyObject *_wrap_VectorReal_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14645   PyObject *resultobj = 0;
14646   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14647   std::vector<double >::value_type *result = 0 ;
14648   void *argp1 = 0 ;
14649   int res1 = 0 ;
14650   PyObject * obj0 = 0 ;
14651
14652   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_front",&obj0)) SWIG_fail;
14653   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14654   if (!SWIG_IsOK(res1)) {
14655     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_front" "', argument " "1"" of type '" "std::vector<double > const *""'");
14656   }
14657   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14658   {
14659     std::vector<double >::value_type const &_result_ref = ((std::vector<double > const *)arg1)->front();
14660     result = (std::vector<double >::value_type *) &_result_ref;
14661   }
14662   resultobj = SWIG_From_double(static_cast< double >(*result));
14663   return resultobj;
14664 fail:
14665   return NULL;
14666 }
14667
14668
14669 SWIGINTERN PyObject *_wrap_VectorReal_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14670   PyObject *resultobj = 0;
14671   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14672   std::vector<double >::value_type *result = 0 ;
14673   void *argp1 = 0 ;
14674   int res1 = 0 ;
14675   PyObject * obj0 = 0 ;
14676
14677   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_back",&obj0)) SWIG_fail;
14678   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14679   if (!SWIG_IsOK(res1)) {
14680     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_back" "', argument " "1"" of type '" "std::vector<double > const *""'");
14681   }
14682   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14683   {
14684     std::vector<double >::value_type const &_result_ref = ((std::vector<double > const *)arg1)->back();
14685     result = (std::vector<double >::value_type *) &_result_ref;
14686   }
14687   resultobj = SWIG_From_double(static_cast< double >(*result));
14688   return resultobj;
14689 fail:
14690   return NULL;
14691 }
14692
14693
14694 SWIGINTERN PyObject *_wrap_VectorReal_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14695   PyObject *resultobj = 0;
14696   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14697   std::vector<double >::size_type arg2 ;
14698   std::vector<double >::value_type *arg3 = 0 ;
14699   void *argp1 = 0 ;
14700   int res1 = 0 ;
14701   size_t val2 ;
14702   int ecode2 = 0 ;
14703   std::vector<double >::value_type temp3 ;
14704   double val3 ;
14705   int ecode3 = 0 ;
14706   PyObject * obj0 = 0 ;
14707   PyObject * obj1 = 0 ;
14708   PyObject * obj2 = 0 ;
14709
14710   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_assign",&obj0,&obj1,&obj2)) SWIG_fail;
14711   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14712   if (!SWIG_IsOK(res1)) {
14713     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_assign" "', argument " "1"" of type '" "std::vector<double > *""'");
14714   }
14715   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14716   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
14717   if (!SWIG_IsOK(ecode2)) {
14718     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_assign" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
14719   }
14720   arg2 = static_cast< std::vector<double >::size_type >(val2);
14721   ecode3 = SWIG_AsVal_double(obj2, &val3);
14722   if (!SWIG_IsOK(ecode3)) {
14723     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_assign" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
14724   }
14725   temp3 = static_cast< std::vector<double >::value_type >(val3);
14726   arg3 = &temp3;
14727   (arg1)->assign(arg2,(std::vector<double >::value_type const &)*arg3);
14728   resultobj = SWIG_Py_Void();
14729   return resultobj;
14730 fail:
14731   return NULL;
14732 }
14733
14734
14735 SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14736   PyObject *resultobj = 0;
14737   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14738   std::vector<double >::size_type arg2 ;
14739   std::vector<double >::value_type *arg3 = 0 ;
14740   void *argp1 = 0 ;
14741   int res1 = 0 ;
14742   size_t val2 ;
14743   int ecode2 = 0 ;
14744   std::vector<double >::value_type temp3 ;
14745   double val3 ;
14746   int ecode3 = 0 ;
14747   PyObject * obj0 = 0 ;
14748   PyObject * obj1 = 0 ;
14749   PyObject * obj2 = 0 ;
14750
14751   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_resize",&obj0,&obj1,&obj2)) SWIG_fail;
14752   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14753   if (!SWIG_IsOK(res1)) {
14754     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector<double > *""'");
14755   }
14756   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14757   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
14758   if (!SWIG_IsOK(ecode2)) {
14759     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
14760   }
14761   arg2 = static_cast< std::vector<double >::size_type >(val2);
14762   ecode3 = SWIG_AsVal_double(obj2, &val3);
14763   if (!SWIG_IsOK(ecode3)) {
14764     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_resize" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
14765   }
14766   temp3 = static_cast< std::vector<double >::value_type >(val3);
14767   arg3 = &temp3;
14768   (arg1)->resize(arg2,(std::vector<double >::value_type const &)*arg3);
14769   resultobj = SWIG_Py_Void();
14770   return resultobj;
14771 fail:
14772   return NULL;
14773 }
14774
14775
14776 SWIGINTERN PyObject *_wrap_VectorReal_resize(PyObject *self, PyObject *args) {
14777   int argc;
14778   PyObject *argv[4];
14779   int ii;
14780
14781   if (!PyTuple_Check(args)) SWIG_fail;
14782   argc = PyObject_Length(args);
14783   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
14784     argv[ii] = PyTuple_GET_ITEM(args,ii);
14785   }
14786   if (argc == 2) {
14787     int _v;
14788     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14789     _v = SWIG_CheckState(res);
14790     if (_v) {
14791       {
14792         int res = SWIG_AsVal_size_t(argv[1], NULL);
14793         _v = SWIG_CheckState(res);
14794       }
14795       if (_v) {
14796         return _wrap_VectorReal_resize__SWIG_0(self, args);
14797       }
14798     }
14799   }
14800   if (argc == 3) {
14801     int _v;
14802     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14803     _v = SWIG_CheckState(res);
14804     if (_v) {
14805       {
14806         int res = SWIG_AsVal_size_t(argv[1], NULL);
14807         _v = SWIG_CheckState(res);
14808       }
14809       if (_v) {
14810         {
14811           int res = SWIG_AsVal_double(argv[2], NULL);
14812           _v = SWIG_CheckState(res);
14813         }
14814         if (_v) {
14815           return _wrap_VectorReal_resize__SWIG_1(self, args);
14816         }
14817       }
14818     }
14819   }
14820
14821 fail:
14822   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<double >::size_type)\n    resize(std::vector<double >::size_type,std::vector<double >::value_type const &)\n");
14823   return NULL;
14824 }
14825
14826
14827 SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14828   PyObject *resultobj = 0;
14829   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14830   std::vector<double >::iterator arg2 ;
14831   std::vector<double >::value_type *arg3 = 0 ;
14832   std::vector<double >::iterator result;
14833   void *argp1 = 0 ;
14834   int res1 = 0 ;
14835   swig::PySwigIterator *iter2 = 0 ;
14836   int res2 ;
14837   std::vector<double >::value_type temp3 ;
14838   double val3 ;
14839   int ecode3 = 0 ;
14840   PyObject * obj0 = 0 ;
14841   PyObject * obj1 = 0 ;
14842   PyObject * obj2 = 0 ;
14843
14844   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_insert",&obj0,&obj1,&obj2)) SWIG_fail;
14845   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14846   if (!SWIG_IsOK(res1)) {
14847     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector<double > *""'");
14848   }
14849   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14850   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
14851   if (!SWIG_IsOK(res2) || !iter2) {
14852     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14853   } else {
14854     swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
14855     if (iter_t) {
14856       arg2 = iter_t->get_current();
14857     } else {
14858       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14859     }
14860   }
14861   ecode3 = SWIG_AsVal_double(obj2, &val3);
14862   if (!SWIG_IsOK(ecode3)) {
14863     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector<double >::value_type""'");
14864   }
14865   temp3 = static_cast< std::vector<double >::value_type >(val3);
14866   arg3 = &temp3;
14867   result = (arg1)->insert(arg2,(std::vector<double >::value_type const &)*arg3);
14868   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<double >::iterator & >(result)),
14869     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
14870   return resultobj;
14871 fail:
14872   return NULL;
14873 }
14874
14875
14876 SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14877   PyObject *resultobj = 0;
14878   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14879   std::vector<double >::iterator arg2 ;
14880   std::vector<double >::size_type arg3 ;
14881   std::vector<double >::value_type *arg4 = 0 ;
14882   void *argp1 = 0 ;
14883   int res1 = 0 ;
14884   swig::PySwigIterator *iter2 = 0 ;
14885   int res2 ;
14886   size_t val3 ;
14887   int ecode3 = 0 ;
14888   std::vector<double >::value_type temp4 ;
14889   double val4 ;
14890   int ecode4 = 0 ;
14891   PyObject * obj0 = 0 ;
14892   PyObject * obj1 = 0 ;
14893   PyObject * obj2 = 0 ;
14894   PyObject * obj3 = 0 ;
14895
14896   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14897   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
14898   if (!SWIG_IsOK(res1)) {
14899     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector<double > *""'");
14900   }
14901   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
14902   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
14903   if (!SWIG_IsOK(res2) || !iter2) {
14904     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14905   } else {
14906     swig::PySwigIterator_T<std::vector<double >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter2);
14907     if (iter_t) {
14908       arg2 = iter_t->get_current();
14909     } else {
14910       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector<double >::iterator""'");
14911     }
14912   }
14913   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14914   if (!SWIG_IsOK(ecode3)) {
14915     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector<double >::size_type""'");
14916   }
14917   arg3 = static_cast< std::vector<double >::size_type >(val3);
14918   ecode4 = SWIG_AsVal_double(obj3, &val4);
14919   if (!SWIG_IsOK(ecode4)) {
14920     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorReal_insert" "', argument " "4"" of type '" "std::vector<double >::value_type""'");
14921   }
14922   temp4 = static_cast< std::vector<double >::value_type >(val4);
14923   arg4 = &temp4;
14924   (arg1)->insert(arg2,arg3,(std::vector<double >::value_type const &)*arg4);
14925   resultobj = SWIG_Py_Void();
14926   return resultobj;
14927 fail:
14928   return NULL;
14929 }
14930
14931
14932 SWIGINTERN PyObject *_wrap_VectorReal_insert(PyObject *self, PyObject *args) {
14933   int argc;
14934   PyObject *argv[5];
14935   int ii;
14936
14937   if (!PyTuple_Check(args)) SWIG_fail;
14938   argc = PyObject_Length(args);
14939   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
14940     argv[ii] = PyTuple_GET_ITEM(args,ii);
14941   }
14942   if (argc == 3) {
14943     int _v;
14944     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14945     _v = SWIG_CheckState(res);
14946     if (_v) {
14947       swig::PySwigIterator *iter = 0;
14948       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
14949       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
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_insert__SWIG_0(self, args);
14957         }
14958       }
14959     }
14960   }
14961   if (argc == 4) {
14962     int _v;
14963     int res = swig::asptr(argv[0], (std::vector<double,std::allocator<double > >**)(0));
14964     _v = SWIG_CheckState(res);
14965     if (_v) {
14966       swig::PySwigIterator *iter = 0;
14967       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
14968       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<double >::iterator > *>(iter) != 0));
14969       if (_v) {
14970         {
14971           int res = SWIG_AsVal_size_t(argv[2], NULL);
14972           _v = SWIG_CheckState(res);
14973         }
14974         if (_v) {
14975           {
14976             int res = SWIG_AsVal_double(argv[3], NULL);
14977             _v = SWIG_CheckState(res);
14978           }
14979           if (_v) {
14980             return _wrap_VectorReal_insert__SWIG_1(self, args);
14981           }
14982         }
14983       }
14984     }
14985   }
14986
14987 fail:
14988   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorReal_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<double >::iterator,std::vector<double >::value_type const &)\n    insert(std::vector<double >::iterator,std::vector<double >::size_type,std::vector<double >::value_type const &)\n");
14989   return NULL;
14990 }
14991
14992
14993 SWIGINTERN PyObject *_wrap_VectorReal_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14994   PyObject *resultobj = 0;
14995   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
14996   std::vector<double >::size_type arg2 ;
14997   void *argp1 = 0 ;
14998   int res1 = 0 ;
14999   size_t val2 ;
15000   int ecode2 = 0 ;
15001   PyObject * obj0 = 0 ;
15002   PyObject * obj1 = 0 ;
15003
15004   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_reserve",&obj0,&obj1)) SWIG_fail;
15005   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
15006   if (!SWIG_IsOK(res1)) {
15007     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_reserve" "', argument " "1"" of type '" "std::vector<double > *""'");
15008   }
15009   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
15010   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15011   if (!SWIG_IsOK(ecode2)) {
15012     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_reserve" "', argument " "2"" of type '" "std::vector<double >::size_type""'");
15013   }
15014   arg2 = static_cast< std::vector<double >::size_type >(val2);
15015   (arg1)->reserve(arg2);
15016   resultobj = SWIG_Py_Void();
15017   return resultobj;
15018 fail:
15019   return NULL;
15020 }
15021
15022
15023 SWIGINTERN PyObject *_wrap_VectorReal_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15024   PyObject *resultobj = 0;
15025   std::vector<double > *arg1 = (std::vector<double > *) 0 ;
15026   std::vector<double >::size_type result;
15027   void *argp1 = 0 ;
15028   int res1 = 0 ;
15029   PyObject * obj0 = 0 ;
15030
15031   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_capacity",&obj0)) SWIG_fail;
15032   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, 0 |  0 );
15033   if (!SWIG_IsOK(res1)) {
15034     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_capacity" "', argument " "1"" of type '" "std::vector<double > const *""'");
15035   }
15036   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
15037   result = ((std::vector<double > const *)arg1)->capacity();
15038   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
15039   return resultobj;
15040 fail:
15041   return NULL;
15042 }
15043
15044
15045 SWIGINTERN PyObject *_wrap_delete_VectorReal(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
15052   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorReal",&obj0)) SWIG_fail;
15053   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_POINTER_DISOWN |  0 );
15054   if (!SWIG_IsOK(res1)) {
15055     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorReal" "', argument " "1"" of type '" "std::vector<double > *""'");
15056   }
15057   arg1 = reinterpret_cast< std::vector<double > * >(argp1);
15058   delete arg1;
15059
15060   resultobj = SWIG_Py_Void();
15061   return resultobj;
15062 fail:
15063   return NULL;
15064 }
15065
15066
15067 SWIGINTERN PyObject *VectorReal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15068   PyObject *obj;
15069   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
15070   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t, SWIG_NewClientData(obj));
15071   return SWIG_Py_Void();
15072 }
15073
15074 SWIGINTERN PyObject *_wrap_VectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15075   PyObject *resultobj = 0;
15076   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15077   PyObject **arg2 = (PyObject **) 0 ;
15078   swig::PySwigIterator *result = 0 ;
15079   void *argp1 = 0 ;
15080   int res1 = 0 ;
15081   PyObject * obj0 = 0 ;
15082
15083   arg2 = &obj0;
15084   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_iterator",&obj0)) SWIG_fail;
15085   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15086   if (!SWIG_IsOK(res1)) {
15087     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_iterator" "', argument " "1"" of type '" "std::vector<int > *""'");
15088   }
15089   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15090   result = (swig::PySwigIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
15091   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
15092   return resultobj;
15093 fail:
15094   return NULL;
15095 }
15096
15097
15098 SWIGINTERN PyObject *_wrap_VectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15099   PyObject *resultobj = 0;
15100   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15101   bool result;
15102   void *argp1 = 0 ;
15103   int res1 = 0 ;
15104   PyObject * obj0 = 0 ;
15105
15106   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___nonzero__",&obj0)) SWIG_fail;
15107   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15108   if (!SWIG_IsOK(res1)) {
15109     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___nonzero__" "', argument " "1"" of type '" "std::vector<int > const *""'");
15110   }
15111   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15112   result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector<int > const *)arg1);
15113   resultobj = SWIG_From_bool(static_cast< bool >(result));
15114   return resultobj;
15115 fail:
15116   return NULL;
15117 }
15118
15119
15120 SWIGINTERN PyObject *_wrap_VectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15121   PyObject *resultobj = 0;
15122   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15123   std::vector<int >::size_type result;
15124   void *argp1 = 0 ;
15125   int res1 = 0 ;
15126   PyObject * obj0 = 0 ;
15127
15128   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___len__",&obj0)) SWIG_fail;
15129   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15130   if (!SWIG_IsOK(res1)) {
15131     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___len__" "', argument " "1"" of type '" "std::vector<int > const *""'");
15132   }
15133   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15134   result = std_vector_Sl_int_Sg____len__((std::vector<int > const *)arg1);
15135   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
15136   return resultobj;
15137 fail:
15138   return NULL;
15139 }
15140
15141
15142 SWIGINTERN PyObject *_wrap_VectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15143   PyObject *resultobj = 0;
15144   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15145   std::vector<int >::value_type result;
15146   void *argp1 = 0 ;
15147   int res1 = 0 ;
15148   PyObject * obj0 = 0 ;
15149
15150   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop",&obj0)) SWIG_fail;
15151   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15152   if (!SWIG_IsOK(res1)) {
15153     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop" "', argument " "1"" of type '" "std::vector<int > *""'");
15154   }
15155   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15156   try {
15157     result = (std::vector<int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
15158   }
15159   catch(std::out_of_range &_e) {
15160     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15161   }
15162
15163   resultobj = SWIG_From_int(static_cast< int >(result));
15164   return resultobj;
15165 fail:
15166   return NULL;
15167 }
15168
15169
15170 SWIGINTERN PyObject *_wrap_VectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15171   PyObject *resultobj = 0;
15172   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15173   std::vector<int >::difference_type arg2 ;
15174   std::vector<int >::difference_type arg3 ;
15175   std::vector<int,std::allocator<int > > *result = 0 ;
15176   void *argp1 = 0 ;
15177   int res1 = 0 ;
15178   ptrdiff_t val2 ;
15179   int ecode2 = 0 ;
15180   ptrdiff_t val3 ;
15181   int ecode3 = 0 ;
15182   PyObject * obj0 = 0 ;
15183   PyObject * obj1 = 0 ;
15184   PyObject * obj2 = 0 ;
15185
15186   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
15187   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15188   if (!SWIG_IsOK(res1)) {
15189     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getslice__" "', argument " "1"" of type '" "std::vector<int > *""'");
15190   }
15191   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15192   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15193   if (!SWIG_IsOK(ecode2)) {
15194     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15195   }
15196   arg2 = static_cast< std::vector<int >::difference_type >(val2);
15197   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
15198   if (!SWIG_IsOK(ecode3)) {
15199     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___getslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
15200   }
15201   arg3 = static_cast< std::vector<int >::difference_type >(val3);
15202   try {
15203     result = (std::vector<int,std::allocator<int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
15204   }
15205   catch(std::out_of_range &_e) {
15206     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15207   }
15208
15209   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_OWN |  0 );
15210   return resultobj;
15211 fail:
15212   return NULL;
15213 }
15214
15215
15216 SWIGINTERN PyObject *_wrap_VectorInt___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15217   PyObject *resultobj = 0;
15218   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15219   std::vector<int >::difference_type arg2 ;
15220   std::vector<int >::difference_type arg3 ;
15221   std::vector<int,std::allocator<int > > *arg4 = 0 ;
15222   void *argp1 = 0 ;
15223   int res1 = 0 ;
15224   ptrdiff_t val2 ;
15225   int ecode2 = 0 ;
15226   ptrdiff_t val3 ;
15227   int ecode3 = 0 ;
15228   int res4 = SWIG_OLDOBJ ;
15229   PyObject * obj0 = 0 ;
15230   PyObject * obj1 = 0 ;
15231   PyObject * obj2 = 0 ;
15232   PyObject * obj3 = 0 ;
15233
15234   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15235   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15236   if (!SWIG_IsOK(res1)) {
15237     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector<int > *""'");
15238   }
15239   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15240   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15241   if (!SWIG_IsOK(ecode2)) {
15242     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15243   }
15244   arg2 = static_cast< std::vector<int >::difference_type >(val2);
15245   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
15246   if (!SWIG_IsOK(ecode3)) {
15247     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
15248   }
15249   arg3 = static_cast< std::vector<int >::difference_type >(val3);
15250   {
15251     std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
15252     res4 = swig::asptr(obj3, &ptr);
15253     if (!SWIG_IsOK(res4)) {
15254       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector<int,std::allocator<int > > const &""'");
15255     }
15256     if (!ptr) {
15257       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector<int,std::allocator<int > > const &""'");
15258     }
15259     arg4 = ptr;
15260   }
15261   try {
15262     std_vector_Sl_int_Sg____setslice__(arg1,arg2,arg3,(std::vector<int,std::allocator<int > > const &)*arg4);
15263   }
15264   catch(std::out_of_range &_e) {
15265     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15266   }
15267   catch(std::invalid_argument &_e) {
15268     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
15269   }
15270
15271   resultobj = SWIG_Py_Void();
15272   if (SWIG_IsNewObj(res4)) delete arg4;
15273   return resultobj;
15274 fail:
15275   if (SWIG_IsNewObj(res4)) delete arg4;
15276   return NULL;
15277 }
15278
15279
15280 SWIGINTERN PyObject *_wrap_VectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15281   PyObject *resultobj = 0;
15282   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15283   std::vector<int >::difference_type arg2 ;
15284   std::vector<int >::difference_type arg3 ;
15285   void *argp1 = 0 ;
15286   int res1 = 0 ;
15287   ptrdiff_t val2 ;
15288   int ecode2 = 0 ;
15289   ptrdiff_t val3 ;
15290   int ecode3 = 0 ;
15291   PyObject * obj0 = 0 ;
15292   PyObject * obj1 = 0 ;
15293   PyObject * obj2 = 0 ;
15294
15295   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
15296   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15297   if (!SWIG_IsOK(res1)) {
15298     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delslice__" "', argument " "1"" of type '" "std::vector<int > *""'");
15299   }
15300   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15301   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15302   if (!SWIG_IsOK(ecode2)) {
15303     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15304   }
15305   arg2 = static_cast< std::vector<int >::difference_type >(val2);
15306   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
15307   if (!SWIG_IsOK(ecode3)) {
15308     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___delslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
15309   }
15310   arg3 = static_cast< std::vector<int >::difference_type >(val3);
15311   try {
15312     std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
15313   }
15314   catch(std::out_of_range &_e) {
15315     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15316   }
15317
15318   resultobj = SWIG_Py_Void();
15319   return resultobj;
15320 fail:
15321   return NULL;
15322 }
15323
15324
15325 SWIGINTERN PyObject *_wrap_VectorInt___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15326   PyObject *resultobj = 0;
15327   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15328   std::vector<int >::difference_type arg2 ;
15329   void *argp1 = 0 ;
15330   int res1 = 0 ;
15331   ptrdiff_t val2 ;
15332   int ecode2 = 0 ;
15333   PyObject * obj0 = 0 ;
15334   PyObject * obj1 = 0 ;
15335
15336   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
15337   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15338   if (!SWIG_IsOK(res1)) {
15339     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector<int > *""'");
15340   }
15341   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15342   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15343   if (!SWIG_IsOK(ecode2)) {
15344     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15345   }
15346   arg2 = static_cast< std::vector<int >::difference_type >(val2);
15347   try {
15348     std_vector_Sl_int_Sg____delitem__(arg1,arg2);
15349   }
15350   catch(std::out_of_range &_e) {
15351     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15352   }
15353
15354   resultobj = SWIG_Py_Void();
15355   return resultobj;
15356 fail:
15357   return NULL;
15358 }
15359
15360
15361 SWIGINTERN PyObject *_wrap_VectorInt___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15362   PyObject *resultobj = 0;
15363   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15364   std::vector<int >::difference_type arg2 ;
15365   std::vector<int >::value_type *result = 0 ;
15366   void *argp1 = 0 ;
15367   int res1 = 0 ;
15368   ptrdiff_t val2 ;
15369   int ecode2 = 0 ;
15370   PyObject * obj0 = 0 ;
15371   PyObject * obj1 = 0 ;
15372
15373   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
15374   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15375   if (!SWIG_IsOK(res1)) {
15376     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector<int > const *""'");
15377   }
15378   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15379   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15380   if (!SWIG_IsOK(ecode2)) {
15381     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15382   }
15383   arg2 = static_cast< std::vector<int >::difference_type >(val2);
15384   try {
15385     {
15386       std::vector<int >::value_type const &_result_ref = std_vector_Sl_int_Sg____getitem__((std::vector<int > const *)arg1,arg2);
15387       result = (std::vector<int >::value_type *) &_result_ref;
15388     }
15389   }
15390   catch(std::out_of_range &_e) {
15391     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15392   }
15393
15394   resultobj = SWIG_From_int(static_cast< int >(*result));
15395   return resultobj;
15396 fail:
15397   return NULL;
15398 }
15399
15400
15401 SWIGINTERN PyObject *_wrap_VectorInt___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15402   PyObject *resultobj = 0;
15403   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15404   std::vector<int >::difference_type arg2 ;
15405   std::vector<int >::value_type *arg3 = 0 ;
15406   void *argp1 = 0 ;
15407   int res1 = 0 ;
15408   ptrdiff_t val2 ;
15409   int ecode2 = 0 ;
15410   std::vector<int >::value_type temp3 ;
15411   int val3 ;
15412   int ecode3 = 0 ;
15413   PyObject * obj0 = 0 ;
15414   PyObject * obj1 = 0 ;
15415   PyObject * obj2 = 0 ;
15416
15417   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
15418   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15419   if (!SWIG_IsOK(res1)) {
15420     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector<int > *""'");
15421   }
15422   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15423   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15424   if (!SWIG_IsOK(ecode2)) {
15425     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
15426   }
15427   arg2 = static_cast< std::vector<int >::difference_type >(val2);
15428   ecode3 = SWIG_AsVal_int(obj2, &val3);
15429   if (!SWIG_IsOK(ecode3)) {
15430     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
15431   }
15432   temp3 = static_cast< std::vector<int >::value_type >(val3);
15433   arg3 = &temp3;
15434   try {
15435     std_vector_Sl_int_Sg____setitem__(arg1,arg2,(int const &)*arg3);
15436   }
15437   catch(std::out_of_range &_e) {
15438     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15439   }
15440
15441   resultobj = SWIG_Py_Void();
15442   return resultobj;
15443 fail:
15444   return NULL;
15445 }
15446
15447
15448 SWIGINTERN PyObject *_wrap_VectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15449   PyObject *resultobj = 0;
15450   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15451   std::vector<int >::value_type *arg2 = 0 ;
15452   void *argp1 = 0 ;
15453   int res1 = 0 ;
15454   std::vector<int >::value_type temp2 ;
15455   int val2 ;
15456   int ecode2 = 0 ;
15457   PyObject * obj0 = 0 ;
15458   PyObject * obj1 = 0 ;
15459
15460   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_append",&obj0,&obj1)) SWIG_fail;
15461   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15462   if (!SWIG_IsOK(res1)) {
15463     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_append" "', argument " "1"" of type '" "std::vector<int > *""'");
15464   }
15465   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15466   ecode2 = SWIG_AsVal_int(obj1, &val2);
15467   if (!SWIG_IsOK(ecode2)) {
15468     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_append" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
15469   }
15470   temp2 = static_cast< std::vector<int >::value_type >(val2);
15471   arg2 = &temp2;
15472   std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
15473   resultobj = SWIG_Py_Void();
15474   return resultobj;
15475 fail:
15476   return NULL;
15477 }
15478
15479
15480 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15481   PyObject *resultobj = 0;
15482   std::vector<int > *result = 0 ;
15483
15484   if (!PyArg_ParseTuple(args,(char *)":new_VectorInt")) SWIG_fail;
15485   result = (std::vector<int > *)new std::vector<int >();
15486   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
15487   return resultobj;
15488 fail:
15489   return NULL;
15490 }
15491
15492
15493 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15494   PyObject *resultobj = 0;
15495   std::vector<int > *arg1 = 0 ;
15496   std::vector<int > *result = 0 ;
15497   int res1 = SWIG_OLDOBJ ;
15498   PyObject * obj0 = 0 ;
15499
15500   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
15501   {
15502     std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
15503     res1 = swig::asptr(obj0, &ptr);
15504     if (!SWIG_IsOK(res1)) {
15505       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int > const &""'");
15506     }
15507     if (!ptr) {
15508       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int > const &""'");
15509     }
15510     arg1 = ptr;
15511   }
15512   result = (std::vector<int > *)new std::vector<int >((std::vector<int > const &)*arg1);
15513   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
15514   if (SWIG_IsNewObj(res1)) delete arg1;
15515   return resultobj;
15516 fail:
15517   if (SWIG_IsNewObj(res1)) delete arg1;
15518   return NULL;
15519 }
15520
15521
15522 SWIGINTERN PyObject *_wrap_VectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15523   PyObject *resultobj = 0;
15524   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15525   bool result;
15526   void *argp1 = 0 ;
15527   int res1 = 0 ;
15528   PyObject * obj0 = 0 ;
15529
15530   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_empty",&obj0)) SWIG_fail;
15531   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15532   if (!SWIG_IsOK(res1)) {
15533     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_empty" "', argument " "1"" of type '" "std::vector<int > const *""'");
15534   }
15535   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15536   result = (bool)((std::vector<int > const *)arg1)->empty();
15537   resultobj = SWIG_From_bool(static_cast< bool >(result));
15538   return resultobj;
15539 fail:
15540   return NULL;
15541 }
15542
15543
15544 SWIGINTERN PyObject *_wrap_VectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15545   PyObject *resultobj = 0;
15546   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15547   std::vector<int >::size_type result;
15548   void *argp1 = 0 ;
15549   int res1 = 0 ;
15550   PyObject * obj0 = 0 ;
15551
15552   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_size",&obj0)) SWIG_fail;
15553   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15554   if (!SWIG_IsOK(res1)) {
15555     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_size" "', argument " "1"" of type '" "std::vector<int > const *""'");
15556   }
15557   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15558   result = ((std::vector<int > const *)arg1)->size();
15559   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
15560   return resultobj;
15561 fail:
15562   return NULL;
15563 }
15564
15565
15566 SWIGINTERN PyObject *_wrap_VectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15567   PyObject *resultobj = 0;
15568   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15569   void *argp1 = 0 ;
15570   int res1 = 0 ;
15571   PyObject * obj0 = 0 ;
15572
15573   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_clear",&obj0)) SWIG_fail;
15574   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15575   if (!SWIG_IsOK(res1)) {
15576     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_clear" "', argument " "1"" of type '" "std::vector<int > *""'");
15577   }
15578   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15579   (arg1)->clear();
15580   resultobj = SWIG_Py_Void();
15581   return resultobj;
15582 fail:
15583   return NULL;
15584 }
15585
15586
15587 SWIGINTERN PyObject *_wrap_VectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15588   PyObject *resultobj = 0;
15589   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15590   std::vector<int > *arg2 = 0 ;
15591   void *argp1 = 0 ;
15592   int res1 = 0 ;
15593   void *argp2 = 0 ;
15594   int res2 = 0 ;
15595   PyObject * obj0 = 0 ;
15596   PyObject * obj1 = 0 ;
15597
15598   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_swap",&obj0,&obj1)) SWIG_fail;
15599   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15600   if (!SWIG_IsOK(res1)) {
15601     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_swap" "', argument " "1"" of type '" "std::vector<int > *""'");
15602   }
15603   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15604   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t,  0 );
15605   if (!SWIG_IsOK(res2)) {
15606     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector<int > &""'");
15607   }
15608   if (!argp2) {
15609     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector<int > &""'");
15610   }
15611   arg2 = reinterpret_cast< std::vector<int > * >(argp2);
15612   (arg1)->swap(*arg2);
15613   resultobj = SWIG_Py_Void();
15614   return resultobj;
15615 fail:
15616   return NULL;
15617 }
15618
15619
15620 SWIGINTERN PyObject *_wrap_VectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15621   PyObject *resultobj = 0;
15622   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15623   SwigValueWrapper<std::allocator<int > > result;
15624   void *argp1 = 0 ;
15625   int res1 = 0 ;
15626   PyObject * obj0 = 0 ;
15627
15628   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_get_allocator",&obj0)) SWIG_fail;
15629   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15630   if (!SWIG_IsOK(res1)) {
15631     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_get_allocator" "', argument " "1"" of type '" "std::vector<int > const *""'");
15632   }
15633   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15634   result = ((std::vector<int > const *)arg1)->get_allocator();
15635   resultobj = SWIG_NewPointerObj((new std::vector<int >::allocator_type(static_cast< const std::vector<int >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
15636   return resultobj;
15637 fail:
15638   return NULL;
15639 }
15640
15641
15642 SWIGINTERN PyObject *_wrap_VectorInt_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15643   PyObject *resultobj = 0;
15644   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15645   std::vector<int >::iterator result;
15646   void *argp1 = 0 ;
15647   int res1 = 0 ;
15648   PyObject * obj0 = 0 ;
15649
15650   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail;
15651   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15652   if (!SWIG_IsOK(res1)) {
15653     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector<int > *""'");
15654   }
15655   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15656   result = (arg1)->begin();
15657   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
15658     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15659   return resultobj;
15660 fail:
15661   return NULL;
15662 }
15663
15664
15665 SWIGINTERN PyObject *_wrap_VectorInt_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15666   PyObject *resultobj = 0;
15667   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15668   std::vector<int >::const_iterator result;
15669   void *argp1 = 0 ;
15670   int res1 = 0 ;
15671   PyObject * obj0 = 0 ;
15672
15673   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail;
15674   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15675   if (!SWIG_IsOK(res1)) {
15676     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector<int > const *""'");
15677   }
15678   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15679   result = ((std::vector<int > const *)arg1)->begin();
15680   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_iterator & >(result)),
15681     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15682   return resultobj;
15683 fail:
15684   return NULL;
15685 }
15686
15687
15688 SWIGINTERN PyObject *_wrap_VectorInt_begin(PyObject *self, PyObject *args) {
15689   int argc;
15690   PyObject *argv[2];
15691   int ii;
15692
15693   if (!PyTuple_Check(args)) SWIG_fail;
15694   argc = PyObject_Length(args);
15695   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
15696     argv[ii] = PyTuple_GET_ITEM(args,ii);
15697   }
15698   if (argc == 1) {
15699     int _v;
15700     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15701     _v = SWIG_CheckState(res);
15702     if (_v) {
15703       return _wrap_VectorInt_begin__SWIG_0(self, args);
15704     }
15705   }
15706   if (argc == 1) {
15707     int _v;
15708     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15709     _v = SWIG_CheckState(res);
15710     if (_v) {
15711       return _wrap_VectorInt_begin__SWIG_1(self, args);
15712     }
15713   }
15714
15715 fail:
15716   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
15717   return NULL;
15718 }
15719
15720
15721 SWIGINTERN PyObject *_wrap_VectorInt_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15722   PyObject *resultobj = 0;
15723   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15724   std::vector<int >::iterator result;
15725   void *argp1 = 0 ;
15726   int res1 = 0 ;
15727   PyObject * obj0 = 0 ;
15728
15729   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail;
15730   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15731   if (!SWIG_IsOK(res1)) {
15732     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector<int > *""'");
15733   }
15734   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15735   result = (arg1)->end();
15736   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
15737     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15738   return resultobj;
15739 fail:
15740   return NULL;
15741 }
15742
15743
15744 SWIGINTERN PyObject *_wrap_VectorInt_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15745   PyObject *resultobj = 0;
15746   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15747   std::vector<int >::const_iterator result;
15748   void *argp1 = 0 ;
15749   int res1 = 0 ;
15750   PyObject * obj0 = 0 ;
15751
15752   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail;
15753   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15754   if (!SWIG_IsOK(res1)) {
15755     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector<int > const *""'");
15756   }
15757   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15758   result = ((std::vector<int > const *)arg1)->end();
15759   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_iterator & >(result)),
15760     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15761   return resultobj;
15762 fail:
15763   return NULL;
15764 }
15765
15766
15767 SWIGINTERN PyObject *_wrap_VectorInt_end(PyObject *self, PyObject *args) {
15768   int argc;
15769   PyObject *argv[2];
15770   int ii;
15771
15772   if (!PyTuple_Check(args)) SWIG_fail;
15773   argc = PyObject_Length(args);
15774   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
15775     argv[ii] = PyTuple_GET_ITEM(args,ii);
15776   }
15777   if (argc == 1) {
15778     int _v;
15779     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15780     _v = SWIG_CheckState(res);
15781     if (_v) {
15782       return _wrap_VectorInt_end__SWIG_0(self, args);
15783     }
15784   }
15785   if (argc == 1) {
15786     int _v;
15787     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15788     _v = SWIG_CheckState(res);
15789     if (_v) {
15790       return _wrap_VectorInt_end__SWIG_1(self, args);
15791     }
15792   }
15793
15794 fail:
15795   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
15796   return NULL;
15797 }
15798
15799
15800 SWIGINTERN PyObject *_wrap_VectorInt_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15801   PyObject *resultobj = 0;
15802   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15803   std::vector<int >::reverse_iterator result;
15804   void *argp1 = 0 ;
15805   int res1 = 0 ;
15806   PyObject * obj0 = 0 ;
15807
15808   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail;
15809   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15810   if (!SWIG_IsOK(res1)) {
15811     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector<int > *""'");
15812   }
15813   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15814   result = (arg1)->rbegin();
15815   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::reverse_iterator & >(result)),
15816     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15817   return resultobj;
15818 fail:
15819   return NULL;
15820 }
15821
15822
15823 SWIGINTERN PyObject *_wrap_VectorInt_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15824   PyObject *resultobj = 0;
15825   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15826   std::vector<int >::const_reverse_iterator result;
15827   void *argp1 = 0 ;
15828   int res1 = 0 ;
15829   PyObject * obj0 = 0 ;
15830
15831   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail;
15832   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15833   if (!SWIG_IsOK(res1)) {
15834     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector<int > const *""'");
15835   }
15836   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15837   result = ((std::vector<int > const *)arg1)->rbegin();
15838   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_reverse_iterator & >(result)),
15839     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15840   return resultobj;
15841 fail:
15842   return NULL;
15843 }
15844
15845
15846 SWIGINTERN PyObject *_wrap_VectorInt_rbegin(PyObject *self, PyObject *args) {
15847   int argc;
15848   PyObject *argv[2];
15849   int ii;
15850
15851   if (!PyTuple_Check(args)) SWIG_fail;
15852   argc = PyObject_Length(args);
15853   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
15854     argv[ii] = PyTuple_GET_ITEM(args,ii);
15855   }
15856   if (argc == 1) {
15857     int _v;
15858     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15859     _v = SWIG_CheckState(res);
15860     if (_v) {
15861       return _wrap_VectorInt_rbegin__SWIG_0(self, args);
15862     }
15863   }
15864   if (argc == 1) {
15865     int _v;
15866     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15867     _v = SWIG_CheckState(res);
15868     if (_v) {
15869       return _wrap_VectorInt_rbegin__SWIG_1(self, args);
15870     }
15871   }
15872
15873 fail:
15874   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
15875   return NULL;
15876 }
15877
15878
15879 SWIGINTERN PyObject *_wrap_VectorInt_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15880   PyObject *resultobj = 0;
15881   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15882   std::vector<int >::reverse_iterator result;
15883   void *argp1 = 0 ;
15884   int res1 = 0 ;
15885   PyObject * obj0 = 0 ;
15886
15887   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail;
15888   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15889   if (!SWIG_IsOK(res1)) {
15890     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector<int > *""'");
15891   }
15892   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15893   result = (arg1)->rend();
15894   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::reverse_iterator & >(result)),
15895     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15896   return resultobj;
15897 fail:
15898   return NULL;
15899 }
15900
15901
15902 SWIGINTERN PyObject *_wrap_VectorInt_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15903   PyObject *resultobj = 0;
15904   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15905   std::vector<int >::const_reverse_iterator result;
15906   void *argp1 = 0 ;
15907   int res1 = 0 ;
15908   PyObject * obj0 = 0 ;
15909
15910   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail;
15911   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15912   if (!SWIG_IsOK(res1)) {
15913     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector<int > const *""'");
15914   }
15915   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15916   result = ((std::vector<int > const *)arg1)->rend();
15917   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_reverse_iterator & >(result)),
15918     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
15919   return resultobj;
15920 fail:
15921   return NULL;
15922 }
15923
15924
15925 SWIGINTERN PyObject *_wrap_VectorInt_rend(PyObject *self, PyObject *args) {
15926   int argc;
15927   PyObject *argv[2];
15928   int ii;
15929
15930   if (!PyTuple_Check(args)) SWIG_fail;
15931   argc = PyObject_Length(args);
15932   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
15933     argv[ii] = PyTuple_GET_ITEM(args,ii);
15934   }
15935   if (argc == 1) {
15936     int _v;
15937     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15938     _v = SWIG_CheckState(res);
15939     if (_v) {
15940       return _wrap_VectorInt_rend__SWIG_0(self, args);
15941     }
15942   }
15943   if (argc == 1) {
15944     int _v;
15945     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
15946     _v = SWIG_CheckState(res);
15947     if (_v) {
15948       return _wrap_VectorInt_rend__SWIG_1(self, args);
15949     }
15950   }
15951
15952 fail:
15953   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
15954   return NULL;
15955 }
15956
15957
15958 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15959   PyObject *resultobj = 0;
15960   std::vector<int >::size_type arg1 ;
15961   std::vector<int > *result = 0 ;
15962   size_t val1 ;
15963   int ecode1 = 0 ;
15964   PyObject * obj0 = 0 ;
15965
15966   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
15967   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
15968   if (!SWIG_IsOK(ecode1)) {
15969     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int >::size_type""'");
15970   }
15971   arg1 = static_cast< std::vector<int >::size_type >(val1);
15972   result = (std::vector<int > *)new std::vector<int >(arg1);
15973   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
15974   return resultobj;
15975 fail:
15976   return NULL;
15977 }
15978
15979
15980 SWIGINTERN PyObject *_wrap_VectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15981   PyObject *resultobj = 0;
15982   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
15983   void *argp1 = 0 ;
15984   int res1 = 0 ;
15985   PyObject * obj0 = 0 ;
15986
15987   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop_back",&obj0)) SWIG_fail;
15988   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
15989   if (!SWIG_IsOK(res1)) {
15990     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop_back" "', argument " "1"" of type '" "std::vector<int > *""'");
15991   }
15992   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
15993   (arg1)->pop_back();
15994   resultobj = SWIG_Py_Void();
15995   return resultobj;
15996 fail:
15997   return NULL;
15998 }
15999
16000
16001 SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16002   PyObject *resultobj = 0;
16003   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16004   std::vector<int >::size_type arg2 ;
16005   void *argp1 = 0 ;
16006   int res1 = 0 ;
16007   size_t val2 ;
16008   int ecode2 = 0 ;
16009   PyObject * obj0 = 0 ;
16010   PyObject * obj1 = 0 ;
16011
16012   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_resize",&obj0,&obj1)) SWIG_fail;
16013   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16014   if (!SWIG_IsOK(res1)) {
16015     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector<int > *""'");
16016   }
16017   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16018   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16019   if (!SWIG_IsOK(ecode2)) {
16020     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
16021   }
16022   arg2 = static_cast< std::vector<int >::size_type >(val2);
16023   (arg1)->resize(arg2);
16024   resultobj = SWIG_Py_Void();
16025   return resultobj;
16026 fail:
16027   return NULL;
16028 }
16029
16030
16031 SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16032   PyObject *resultobj = 0;
16033   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16034   std::vector<int >::iterator arg2 ;
16035   std::vector<int >::iterator result;
16036   void *argp1 = 0 ;
16037   int res1 = 0 ;
16038   swig::PySwigIterator *iter2 = 0 ;
16039   int res2 ;
16040   PyObject * obj0 = 0 ;
16041   PyObject * obj1 = 0 ;
16042
16043   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_erase",&obj0,&obj1)) SWIG_fail;
16044   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16045   if (!SWIG_IsOK(res1)) {
16046     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector<int > *""'");
16047   }
16048   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16049   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
16050   if (!SWIG_IsOK(res2) || !iter2) {
16051     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16052   } else {
16053     swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
16054     if (iter_t) {
16055       arg2 = iter_t->get_current();
16056     } else {
16057       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16058     }
16059   }
16060   result = (arg1)->erase(arg2);
16061   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
16062     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
16063   return resultobj;
16064 fail:
16065   return NULL;
16066 }
16067
16068
16069 SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16070   PyObject *resultobj = 0;
16071   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16072   std::vector<int >::iterator arg2 ;
16073   std::vector<int >::iterator arg3 ;
16074   std::vector<int >::iterator result;
16075   void *argp1 = 0 ;
16076   int res1 = 0 ;
16077   swig::PySwigIterator *iter2 = 0 ;
16078   int res2 ;
16079   swig::PySwigIterator *iter3 = 0 ;
16080   int res3 ;
16081   PyObject * obj0 = 0 ;
16082   PyObject * obj1 = 0 ;
16083   PyObject * obj2 = 0 ;
16084
16085   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
16086   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16087   if (!SWIG_IsOK(res1)) {
16088     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector<int > *""'");
16089   }
16090   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16091   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
16092   if (!SWIG_IsOK(res2) || !iter2) {
16093     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16094   } else {
16095     swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
16096     if (iter_t) {
16097       arg2 = iter_t->get_current();
16098     } else {
16099       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16100     }
16101   }
16102   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
16103   if (!SWIG_IsOK(res3) || !iter3) {
16104     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector<int >::iterator""'");
16105   } else {
16106     swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter3);
16107     if (iter_t) {
16108       arg3 = iter_t->get_current();
16109     } else {
16110       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector<int >::iterator""'");
16111     }
16112   }
16113   result = (arg1)->erase(arg2,arg3);
16114   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
16115     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
16116   return resultobj;
16117 fail:
16118   return NULL;
16119 }
16120
16121
16122 SWIGINTERN PyObject *_wrap_VectorInt_erase(PyObject *self, PyObject *args) {
16123   int argc;
16124   PyObject *argv[4];
16125   int ii;
16126
16127   if (!PyTuple_Check(args)) SWIG_fail;
16128   argc = PyObject_Length(args);
16129   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
16130     argv[ii] = PyTuple_GET_ITEM(args,ii);
16131   }
16132   if (argc == 2) {
16133     int _v;
16134     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16135     _v = SWIG_CheckState(res);
16136     if (_v) {
16137       swig::PySwigIterator *iter = 0;
16138       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
16139       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
16140       if (_v) {
16141         return _wrap_VectorInt_erase__SWIG_0(self, args);
16142       }
16143     }
16144   }
16145   if (argc == 3) {
16146     int _v;
16147     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16148     _v = SWIG_CheckState(res);
16149     if (_v) {
16150       swig::PySwigIterator *iter = 0;
16151       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
16152       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
16153       if (_v) {
16154         swig::PySwigIterator *iter = 0;
16155         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
16156         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
16157         if (_v) {
16158           return _wrap_VectorInt_erase__SWIG_1(self, args);
16159         }
16160       }
16161     }
16162   }
16163
16164 fail:
16165   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<int >::iterator)\n    erase(std::vector<int >::iterator,std::vector<int >::iterator)\n");
16166   return NULL;
16167 }
16168
16169
16170 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16171   PyObject *resultobj = 0;
16172   std::vector<int >::size_type arg1 ;
16173   std::vector<int >::value_type *arg2 = 0 ;
16174   std::vector<int > *result = 0 ;
16175   size_t val1 ;
16176   int ecode1 = 0 ;
16177   std::vector<int >::value_type temp2 ;
16178   int val2 ;
16179   int ecode2 = 0 ;
16180   PyObject * obj0 = 0 ;
16181   PyObject * obj1 = 0 ;
16182
16183   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorInt",&obj0,&obj1)) SWIG_fail;
16184   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
16185   if (!SWIG_IsOK(ecode1)) {
16186     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector<int >::size_type""'");
16187   }
16188   arg1 = static_cast< std::vector<int >::size_type >(val1);
16189   ecode2 = SWIG_AsVal_int(obj1, &val2);
16190   if (!SWIG_IsOK(ecode2)) {
16191     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorInt" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
16192   }
16193   temp2 = static_cast< std::vector<int >::value_type >(val2);
16194   arg2 = &temp2;
16195   result = (std::vector<int > *)new std::vector<int >(arg1,(std::vector<int >::value_type const &)*arg2);
16196   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
16197   return resultobj;
16198 fail:
16199   return NULL;
16200 }
16201
16202
16203 SWIGINTERN PyObject *_wrap_new_VectorInt(PyObject *self, PyObject *args) {
16204   int argc;
16205   PyObject *argv[3];
16206   int ii;
16207
16208   if (!PyTuple_Check(args)) SWIG_fail;
16209   argc = PyObject_Length(args);
16210   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
16211     argv[ii] = PyTuple_GET_ITEM(args,ii);
16212   }
16213   if (argc == 0) {
16214     return _wrap_new_VectorInt__SWIG_0(self, args);
16215   }
16216   if (argc == 1) {
16217     int _v;
16218     {
16219       int res = SWIG_AsVal_size_t(argv[0], NULL);
16220       _v = SWIG_CheckState(res);
16221     }
16222     if (_v) {
16223       return _wrap_new_VectorInt__SWIG_2(self, args);
16224     }
16225   }
16226   if (argc == 1) {
16227     int _v;
16228     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16229     _v = SWIG_CheckState(res);
16230     if (_v) {
16231       return _wrap_new_VectorInt__SWIG_1(self, args);
16232     }
16233   }
16234   if (argc == 2) {
16235     int _v;
16236     {
16237       int res = SWIG_AsVal_size_t(argv[0], NULL);
16238       _v = SWIG_CheckState(res);
16239     }
16240     if (_v) {
16241       {
16242         int res = SWIG_AsVal_int(argv[1], NULL);
16243         _v = SWIG_CheckState(res);
16244       }
16245       if (_v) {
16246         return _wrap_new_VectorInt__SWIG_3(self, args);
16247       }
16248     }
16249   }
16250
16251 fail:
16252   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_VectorInt'.\n  Possible C/C++ prototypes are:\n    std::vector<(int)>()\n    std::vector<(int)>(std::vector<int > const &)\n    std::vector<(int)>(std::vector<int >::size_type)\n    std::vector<(int)>(std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
16253   return NULL;
16254 }
16255
16256
16257 SWIGINTERN PyObject *_wrap_VectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16258   PyObject *resultobj = 0;
16259   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16260   std::vector<int >::value_type *arg2 = 0 ;
16261   void *argp1 = 0 ;
16262   int res1 = 0 ;
16263   std::vector<int >::value_type temp2 ;
16264   int val2 ;
16265   int ecode2 = 0 ;
16266   PyObject * obj0 = 0 ;
16267   PyObject * obj1 = 0 ;
16268
16269   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_push_back",&obj0,&obj1)) SWIG_fail;
16270   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16271   if (!SWIG_IsOK(res1)) {
16272     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_push_back" "', argument " "1"" of type '" "std::vector<int > *""'");
16273   }
16274   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16275   ecode2 = SWIG_AsVal_int(obj1, &val2);
16276   if (!SWIG_IsOK(ecode2)) {
16277     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_push_back" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
16278   }
16279   temp2 = static_cast< std::vector<int >::value_type >(val2);
16280   arg2 = &temp2;
16281   (arg1)->push_back((std::vector<int >::value_type const &)*arg2);
16282   resultobj = SWIG_Py_Void();
16283   return resultobj;
16284 fail:
16285   return NULL;
16286 }
16287
16288
16289 SWIGINTERN PyObject *_wrap_VectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16290   PyObject *resultobj = 0;
16291   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16292   std::vector<int >::value_type *result = 0 ;
16293   void *argp1 = 0 ;
16294   int res1 = 0 ;
16295   PyObject * obj0 = 0 ;
16296
16297   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_front",&obj0)) SWIG_fail;
16298   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16299   if (!SWIG_IsOK(res1)) {
16300     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_front" "', argument " "1"" of type '" "std::vector<int > const *""'");
16301   }
16302   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16303   {
16304     std::vector<int >::value_type const &_result_ref = ((std::vector<int > const *)arg1)->front();
16305     result = (std::vector<int >::value_type *) &_result_ref;
16306   }
16307   resultobj = SWIG_From_int(static_cast< int >(*result));
16308   return resultobj;
16309 fail:
16310   return NULL;
16311 }
16312
16313
16314 SWIGINTERN PyObject *_wrap_VectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16315   PyObject *resultobj = 0;
16316   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16317   std::vector<int >::value_type *result = 0 ;
16318   void *argp1 = 0 ;
16319   int res1 = 0 ;
16320   PyObject * obj0 = 0 ;
16321
16322   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_back",&obj0)) SWIG_fail;
16323   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16324   if (!SWIG_IsOK(res1)) {
16325     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_back" "', argument " "1"" of type '" "std::vector<int > const *""'");
16326   }
16327   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16328   {
16329     std::vector<int >::value_type const &_result_ref = ((std::vector<int > const *)arg1)->back();
16330     result = (std::vector<int >::value_type *) &_result_ref;
16331   }
16332   resultobj = SWIG_From_int(static_cast< int >(*result));
16333   return resultobj;
16334 fail:
16335   return NULL;
16336 }
16337
16338
16339 SWIGINTERN PyObject *_wrap_VectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16340   PyObject *resultobj = 0;
16341   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16342   std::vector<int >::size_type arg2 ;
16343   std::vector<int >::value_type *arg3 = 0 ;
16344   void *argp1 = 0 ;
16345   int res1 = 0 ;
16346   size_t val2 ;
16347   int ecode2 = 0 ;
16348   std::vector<int >::value_type temp3 ;
16349   int val3 ;
16350   int ecode3 = 0 ;
16351   PyObject * obj0 = 0 ;
16352   PyObject * obj1 = 0 ;
16353   PyObject * obj2 = 0 ;
16354
16355   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail;
16356   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16357   if (!SWIG_IsOK(res1)) {
16358     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_assign" "', argument " "1"" of type '" "std::vector<int > *""'");
16359   }
16360   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16361   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16362   if (!SWIG_IsOK(ecode2)) {
16363     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_assign" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
16364   }
16365   arg2 = static_cast< std::vector<int >::size_type >(val2);
16366   ecode3 = SWIG_AsVal_int(obj2, &val3);
16367   if (!SWIG_IsOK(ecode3)) {
16368     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_assign" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
16369   }
16370   temp3 = static_cast< std::vector<int >::value_type >(val3);
16371   arg3 = &temp3;
16372   (arg1)->assign(arg2,(std::vector<int >::value_type const &)*arg3);
16373   resultobj = SWIG_Py_Void();
16374   return resultobj;
16375 fail:
16376   return NULL;
16377 }
16378
16379
16380 SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16381   PyObject *resultobj = 0;
16382   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16383   std::vector<int >::size_type arg2 ;
16384   std::vector<int >::value_type *arg3 = 0 ;
16385   void *argp1 = 0 ;
16386   int res1 = 0 ;
16387   size_t val2 ;
16388   int ecode2 = 0 ;
16389   std::vector<int >::value_type temp3 ;
16390   int val3 ;
16391   int ecode3 = 0 ;
16392   PyObject * obj0 = 0 ;
16393   PyObject * obj1 = 0 ;
16394   PyObject * obj2 = 0 ;
16395
16396   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail;
16397   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16398   if (!SWIG_IsOK(res1)) {
16399     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector<int > *""'");
16400   }
16401   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16402   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16403   if (!SWIG_IsOK(ecode2)) {
16404     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
16405   }
16406   arg2 = static_cast< std::vector<int >::size_type >(val2);
16407   ecode3 = SWIG_AsVal_int(obj2, &val3);
16408   if (!SWIG_IsOK(ecode3)) {
16409     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_resize" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
16410   }
16411   temp3 = static_cast< std::vector<int >::value_type >(val3);
16412   arg3 = &temp3;
16413   (arg1)->resize(arg2,(std::vector<int >::value_type const &)*arg3);
16414   resultobj = SWIG_Py_Void();
16415   return resultobj;
16416 fail:
16417   return NULL;
16418 }
16419
16420
16421 SWIGINTERN PyObject *_wrap_VectorInt_resize(PyObject *self, PyObject *args) {
16422   int argc;
16423   PyObject *argv[4];
16424   int ii;
16425
16426   if (!PyTuple_Check(args)) SWIG_fail;
16427   argc = PyObject_Length(args);
16428   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
16429     argv[ii] = PyTuple_GET_ITEM(args,ii);
16430   }
16431   if (argc == 2) {
16432     int _v;
16433     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16434     _v = SWIG_CheckState(res);
16435     if (_v) {
16436       {
16437         int res = SWIG_AsVal_size_t(argv[1], NULL);
16438         _v = SWIG_CheckState(res);
16439       }
16440       if (_v) {
16441         return _wrap_VectorInt_resize__SWIG_0(self, args);
16442       }
16443     }
16444   }
16445   if (argc == 3) {
16446     int _v;
16447     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16448     _v = SWIG_CheckState(res);
16449     if (_v) {
16450       {
16451         int res = SWIG_AsVal_size_t(argv[1], NULL);
16452         _v = SWIG_CheckState(res);
16453       }
16454       if (_v) {
16455         {
16456           int res = SWIG_AsVal_int(argv[2], NULL);
16457           _v = SWIG_CheckState(res);
16458         }
16459         if (_v) {
16460           return _wrap_VectorInt_resize__SWIG_1(self, args);
16461         }
16462       }
16463     }
16464   }
16465
16466 fail:
16467   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<int >::size_type)\n    resize(std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
16468   return NULL;
16469 }
16470
16471
16472 SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16473   PyObject *resultobj = 0;
16474   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16475   std::vector<int >::iterator arg2 ;
16476   std::vector<int >::value_type *arg3 = 0 ;
16477   std::vector<int >::iterator result;
16478   void *argp1 = 0 ;
16479   int res1 = 0 ;
16480   swig::PySwigIterator *iter2 = 0 ;
16481   int res2 ;
16482   std::vector<int >::value_type temp3 ;
16483   int val3 ;
16484   int ecode3 = 0 ;
16485   PyObject * obj0 = 0 ;
16486   PyObject * obj1 = 0 ;
16487   PyObject * obj2 = 0 ;
16488
16489   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail;
16490   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16491   if (!SWIG_IsOK(res1)) {
16492     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector<int > *""'");
16493   }
16494   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16495   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
16496   if (!SWIG_IsOK(res2) || !iter2) {
16497     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16498   } else {
16499     swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
16500     if (iter_t) {
16501       arg2 = iter_t->get_current();
16502     } else {
16503       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16504     }
16505   }
16506   ecode3 = SWIG_AsVal_int(obj2, &val3);
16507   if (!SWIG_IsOK(ecode3)) {
16508     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
16509   }
16510   temp3 = static_cast< std::vector<int >::value_type >(val3);
16511   arg3 = &temp3;
16512   result = (arg1)->insert(arg2,(std::vector<int >::value_type const &)*arg3);
16513   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
16514     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
16515   return resultobj;
16516 fail:
16517   return NULL;
16518 }
16519
16520
16521 SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16522   PyObject *resultobj = 0;
16523   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16524   std::vector<int >::iterator arg2 ;
16525   std::vector<int >::size_type arg3 ;
16526   std::vector<int >::value_type *arg4 = 0 ;
16527   void *argp1 = 0 ;
16528   int res1 = 0 ;
16529   swig::PySwigIterator *iter2 = 0 ;
16530   int res2 ;
16531   size_t val3 ;
16532   int ecode3 = 0 ;
16533   std::vector<int >::value_type temp4 ;
16534   int val4 ;
16535   int ecode4 = 0 ;
16536   PyObject * obj0 = 0 ;
16537   PyObject * obj1 = 0 ;
16538   PyObject * obj2 = 0 ;
16539   PyObject * obj3 = 0 ;
16540
16541   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16542   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16543   if (!SWIG_IsOK(res1)) {
16544     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector<int > *""'");
16545   }
16546   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16547   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
16548   if (!SWIG_IsOK(res2) || !iter2) {
16549     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16550   } else {
16551     swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
16552     if (iter_t) {
16553       arg2 = iter_t->get_current();
16554     } else {
16555       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
16556     }
16557   }
16558   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16559   if (!SWIG_IsOK(ecode3)) {
16560     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector<int >::size_type""'");
16561   }
16562   arg3 = static_cast< std::vector<int >::size_type >(val3);
16563   ecode4 = SWIG_AsVal_int(obj3, &val4);
16564   if (!SWIG_IsOK(ecode4)) {
16565     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorInt_insert" "', argument " "4"" of type '" "std::vector<int >::value_type""'");
16566   }
16567   temp4 = static_cast< std::vector<int >::value_type >(val4);
16568   arg4 = &temp4;
16569   (arg1)->insert(arg2,arg3,(std::vector<int >::value_type const &)*arg4);
16570   resultobj = SWIG_Py_Void();
16571   return resultobj;
16572 fail:
16573   return NULL;
16574 }
16575
16576
16577 SWIGINTERN PyObject *_wrap_VectorInt_insert(PyObject *self, PyObject *args) {
16578   int argc;
16579   PyObject *argv[5];
16580   int ii;
16581
16582   if (!PyTuple_Check(args)) SWIG_fail;
16583   argc = PyObject_Length(args);
16584   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
16585     argv[ii] = PyTuple_GET_ITEM(args,ii);
16586   }
16587   if (argc == 3) {
16588     int _v;
16589     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16590     _v = SWIG_CheckState(res);
16591     if (_v) {
16592       swig::PySwigIterator *iter = 0;
16593       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
16594       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
16595       if (_v) {
16596         {
16597           int res = SWIG_AsVal_int(argv[2], NULL);
16598           _v = SWIG_CheckState(res);
16599         }
16600         if (_v) {
16601           return _wrap_VectorInt_insert__SWIG_0(self, args);
16602         }
16603       }
16604     }
16605   }
16606   if (argc == 4) {
16607     int _v;
16608     int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
16609     _v = SWIG_CheckState(res);
16610     if (_v) {
16611       swig::PySwigIterator *iter = 0;
16612       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
16613       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
16614       if (_v) {
16615         {
16616           int res = SWIG_AsVal_size_t(argv[2], NULL);
16617           _v = SWIG_CheckState(res);
16618         }
16619         if (_v) {
16620           {
16621             int res = SWIG_AsVal_int(argv[3], NULL);
16622             _v = SWIG_CheckState(res);
16623           }
16624           if (_v) {
16625             return _wrap_VectorInt_insert__SWIG_1(self, args);
16626           }
16627         }
16628       }
16629     }
16630   }
16631
16632 fail:
16633   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'VectorInt_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<int >::iterator,std::vector<int >::value_type const &)\n    insert(std::vector<int >::iterator,std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
16634   return NULL;
16635 }
16636
16637
16638 SWIGINTERN PyObject *_wrap_VectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16639   PyObject *resultobj = 0;
16640   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16641   std::vector<int >::size_type arg2 ;
16642   void *argp1 = 0 ;
16643   int res1 = 0 ;
16644   size_t val2 ;
16645   int ecode2 = 0 ;
16646   PyObject * obj0 = 0 ;
16647   PyObject * obj1 = 0 ;
16648
16649   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_reserve",&obj0,&obj1)) SWIG_fail;
16650   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16651   if (!SWIG_IsOK(res1)) {
16652     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_reserve" "', argument " "1"" of type '" "std::vector<int > *""'");
16653   }
16654   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16655   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16656   if (!SWIG_IsOK(ecode2)) {
16657     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_reserve" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
16658   }
16659   arg2 = static_cast< std::vector<int >::size_type >(val2);
16660   (arg1)->reserve(arg2);
16661   resultobj = SWIG_Py_Void();
16662   return resultobj;
16663 fail:
16664   return NULL;
16665 }
16666
16667
16668 SWIGINTERN PyObject *_wrap_VectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16669   PyObject *resultobj = 0;
16670   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16671   std::vector<int >::size_type result;
16672   void *argp1 = 0 ;
16673   int res1 = 0 ;
16674   PyObject * obj0 = 0 ;
16675
16676   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_capacity",&obj0)) SWIG_fail;
16677   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
16678   if (!SWIG_IsOK(res1)) {
16679     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_capacity" "', argument " "1"" of type '" "std::vector<int > const *""'");
16680   }
16681   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16682   result = ((std::vector<int > const *)arg1)->capacity();
16683   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16684   return resultobj;
16685 fail:
16686   return NULL;
16687 }
16688
16689
16690 SWIGINTERN PyObject *_wrap_delete_VectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16691   PyObject *resultobj = 0;
16692   std::vector<int > *arg1 = (std::vector<int > *) 0 ;
16693   void *argp1 = 0 ;
16694   int res1 = 0 ;
16695   PyObject * obj0 = 0 ;
16696
16697   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorInt",&obj0)) SWIG_fail;
16698   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_DISOWN |  0 );
16699   if (!SWIG_IsOK(res1)) {
16700     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInt" "', argument " "1"" of type '" "std::vector<int > *""'");
16701   }
16702   arg1 = reinterpret_cast< std::vector<int > * >(argp1);
16703   delete arg1;
16704
16705   resultobj = SWIG_Py_Void();
16706   return resultobj;
16707 fail:
16708   return NULL;
16709 }
16710
16711
16712 SWIGINTERN PyObject *VectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16713   PyObject *obj;
16714   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
16715   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_NewClientData(obj));
16716   return SWIG_Py_Void();
16717 }
16718
16719 SWIGINTERN int ABR_TYPES_set(PyObject *) {
16720   SWIG_Error(SWIG_AttributeError,"Variable ABR_TYPES is read-only.");
16721   return 1;
16722 }
16723
16724
16725 SWIGINTERN PyObject *ABR_TYPES_get(void) {
16726   PyObject *pyobj = 0;
16727
16728   pyobj = SWIG_FromCharPtr(Hex::ABR_TYPES);
16729   return pyobj;
16730 }
16731
16732
16733 SWIGINTERN PyObject *_wrap_get_temp_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16734   PyObject *resultobj = 0;
16735   cpchar arg1 = (cpchar) 0 ;
16736   pchar arg2 = (pchar) 0 ;
16737   pchar result;
16738   int res1 ;
16739   char *buf1 = 0 ;
16740   int alloc1 = 0 ;
16741   int res2 ;
16742   char *buf2 = 0 ;
16743   int alloc2 = 0 ;
16744   PyObject * obj0 = 0 ;
16745   PyObject * obj1 = 0 ;
16746
16747   if (!PyArg_ParseTuple(args,(char *)"OO:get_temp_name",&obj0,&obj1)) SWIG_fail;
16748   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
16749   if (!SWIG_IsOK(res1)) {
16750     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_temp_name" "', argument " "1"" of type '" "cpchar""'");
16751   }
16752   arg1 = reinterpret_cast< cpchar >(buf1);
16753   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
16754   if (!SWIG_IsOK(res2)) {
16755     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_temp_name" "', argument " "2"" of type '" "pchar""'");
16756   }
16757   arg2 = reinterpret_cast< pchar >(buf2);
16758   result = (pchar)Hex::get_temp_name((char const *)arg1,arg2);
16759   resultobj = SWIG_FromCharPtr((const char *)result);
16760   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16761   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16762   return resultobj;
16763 fail:
16764   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16765   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16766   return NULL;
16767 }
16768
16769
16770 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16771   PyObject *resultobj = 0;
16772   cpchar arg1 = (cpchar) 0 ;
16773   cpchar arg2 = (cpchar) 0 ;
16774   cpchar arg3 = (cpchar) 0 ;
16775   int res1 ;
16776   char *buf1 = 0 ;
16777   int alloc1 = 0 ;
16778   int res2 ;
16779   char *buf2 = 0 ;
16780   int alloc2 = 0 ;
16781   int res3 ;
16782   char *buf3 = 0 ;
16783   int alloc3 = 0 ;
16784   PyObject * obj0 = 0 ;
16785   PyObject * obj1 = 0 ;
16786   PyObject * obj2 = 0 ;
16787
16788   if (!PyArg_ParseTuple(args,(char *)"OOO:fatal_error",&obj0,&obj1,&obj2)) SWIG_fail;
16789   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
16790   if (!SWIG_IsOK(res1)) {
16791     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
16792   }
16793   arg1 = reinterpret_cast< cpchar >(buf1);
16794   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
16795   if (!SWIG_IsOK(res2)) {
16796     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fatal_error" "', argument " "2"" of type '" "cpchar""'");
16797   }
16798   arg2 = reinterpret_cast< cpchar >(buf2);
16799   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
16800   if (!SWIG_IsOK(res3)) {
16801     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fatal_error" "', argument " "3"" of type '" "cpchar""'");
16802   }
16803   arg3 = reinterpret_cast< cpchar >(buf3);
16804   Hex::fatal_error((char const *)arg1,(char const *)arg2,(char const *)arg3);
16805   resultobj = SWIG_Py_Void();
16806   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16807   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16808   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16809   return resultobj;
16810 fail:
16811   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16812   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16813   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16814   return NULL;
16815 }
16816
16817
16818 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16819   PyObject *resultobj = 0;
16820   cpchar arg1 = (cpchar) 0 ;
16821   cpchar arg2 = (cpchar) 0 ;
16822   int res1 ;
16823   char *buf1 = 0 ;
16824   int alloc1 = 0 ;
16825   int res2 ;
16826   char *buf2 = 0 ;
16827   int alloc2 = 0 ;
16828   PyObject * obj0 = 0 ;
16829   PyObject * obj1 = 0 ;
16830
16831   if (!PyArg_ParseTuple(args,(char *)"OO:fatal_error",&obj0,&obj1)) SWIG_fail;
16832   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
16833   if (!SWIG_IsOK(res1)) {
16834     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
16835   }
16836   arg1 = reinterpret_cast< cpchar >(buf1);
16837   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
16838   if (!SWIG_IsOK(res2)) {
16839     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fatal_error" "', argument " "2"" of type '" "cpchar""'");
16840   }
16841   arg2 = reinterpret_cast< cpchar >(buf2);
16842   Hex::fatal_error((char const *)arg1,(char const *)arg2);
16843   resultobj = SWIG_Py_Void();
16844   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16845   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16846   return resultobj;
16847 fail:
16848   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16849   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16850   return NULL;
16851 }
16852
16853
16854 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16855   PyObject *resultobj = 0;
16856   cpchar arg1 = (cpchar) 0 ;
16857   int res1 ;
16858   char *buf1 = 0 ;
16859   int alloc1 = 0 ;
16860   PyObject * obj0 = 0 ;
16861
16862   if (!PyArg_ParseTuple(args,(char *)"O:fatal_error",&obj0)) SWIG_fail;
16863   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
16864   if (!SWIG_IsOK(res1)) {
16865     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
16866   }
16867   arg1 = reinterpret_cast< cpchar >(buf1);
16868   Hex::fatal_error((char const *)arg1);
16869   resultobj = SWIG_Py_Void();
16870   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16871   return resultobj;
16872 fail:
16873   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16874   return NULL;
16875 }
16876
16877
16878 SWIGINTERN PyObject *_wrap_fatal_error(PyObject *self, PyObject *args) {
16879   int argc;
16880   PyObject *argv[4];
16881   int ii;
16882
16883   if (!PyTuple_Check(args)) SWIG_fail;
16884   argc = PyObject_Length(args);
16885   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
16886     argv[ii] = PyTuple_GET_ITEM(args,ii);
16887   }
16888   if (argc == 1) {
16889     int _v;
16890     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
16891     _v = SWIG_CheckState(res);
16892     if (_v) {
16893       return _wrap_fatal_error__SWIG_2(self, args);
16894     }
16895   }
16896   if (argc == 2) {
16897     int _v;
16898     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
16899     _v = SWIG_CheckState(res);
16900     if (_v) {
16901       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16902       _v = SWIG_CheckState(res);
16903       if (_v) {
16904         return _wrap_fatal_error__SWIG_1(self, args);
16905       }
16906     }
16907   }
16908   if (argc == 3) {
16909     int _v;
16910     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
16911     _v = SWIG_CheckState(res);
16912     if (_v) {
16913       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
16914       _v = SWIG_CheckState(res);
16915       if (_v) {
16916         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
16917         _v = SWIG_CheckState(res);
16918         if (_v) {
16919           return _wrap_fatal_error__SWIG_0(self, args);
16920         }
16921       }
16922     }
16923   }
16924
16925 fail:
16926   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'fatal_error'.\n  Possible C/C++ prototypes are:\n    Hex::fatal_error(cpchar,cpchar,cpchar)\n    Hex::fatal_error(cpchar,cpchar)\n    Hex::fatal_error(cpchar)\n");
16927   return NULL;
16928 }
16929
16930
16931 SWIGINTERN PyObject *_wrap_prod_scalaire(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16932   PyObject *resultobj = 0;
16933   double *arg1 ;
16934   double *arg2 ;
16935   double result;
16936   void *argp1 = 0 ;
16937   int res1 = 0 ;
16938   void *argp2 = 0 ;
16939   int res2 = 0 ;
16940   PyObject * obj0 = 0 ;
16941   PyObject * obj1 = 0 ;
16942
16943   if (!PyArg_ParseTuple(args,(char *)"OO:prod_scalaire",&obj0,&obj1)) SWIG_fail;
16944   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
16945   if (!SWIG_IsOK(res1)) {
16946     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_scalaire" "', argument " "1"" of type '" "double []""'");
16947   }
16948   arg1 = reinterpret_cast< double * >(argp1);
16949   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
16950   if (!SWIG_IsOK(res2)) {
16951     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_scalaire" "', argument " "2"" of type '" "double []""'");
16952   }
16953   arg2 = reinterpret_cast< double * >(argp2);
16954   result = (double)Hex::prod_scalaire(arg1,arg2);
16955   resultobj = SWIG_From_double(static_cast< double >(result));
16956   return resultobj;
16957 fail:
16958   return NULL;
16959 }
16960
16961
16962 SWIGINTERN PyObject *_wrap_prod_vectoriel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16963   PyObject *resultobj = 0;
16964   double *arg1 ;
16965   double *arg2 ;
16966   double *arg3 ;
16967   double *result = 0 ;
16968   void *argp1 = 0 ;
16969   int res1 = 0 ;
16970   void *argp2 = 0 ;
16971   int res2 = 0 ;
16972   void *argp3 = 0 ;
16973   int res3 = 0 ;
16974   PyObject * obj0 = 0 ;
16975   PyObject * obj1 = 0 ;
16976   PyObject * obj2 = 0 ;
16977
16978   if (!PyArg_ParseTuple(args,(char *)"OOO:prod_vectoriel",&obj0,&obj1,&obj2)) SWIG_fail;
16979   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
16980   if (!SWIG_IsOK(res1)) {
16981     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_vectoriel" "', argument " "1"" of type '" "double []""'");
16982   }
16983   arg1 = reinterpret_cast< double * >(argp1);
16984   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
16985   if (!SWIG_IsOK(res2)) {
16986     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_vectoriel" "', argument " "2"" of type '" "double []""'");
16987   }
16988   arg2 = reinterpret_cast< double * >(argp2);
16989   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
16990   if (!SWIG_IsOK(res3)) {
16991     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "prod_vectoriel" "', argument " "3"" of type '" "double []""'");
16992   }
16993   arg3 = reinterpret_cast< double * >(argp3);
16994   result = (double *)Hex::prod_vectoriel(arg1,arg2,arg3);
16995   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
16996   return resultobj;
16997 fail:
16998   return NULL;
16999 }
17000
17001
17002 SWIGINTERN PyObject *_wrap_prod_mixte(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17003   PyObject *resultobj = 0;
17004   double *arg1 ;
17005   double *arg2 ;
17006   double *arg3 ;
17007   double result;
17008   void *argp1 = 0 ;
17009   int res1 = 0 ;
17010   void *argp2 = 0 ;
17011   int res2 = 0 ;
17012   void *argp3 = 0 ;
17013   int res3 = 0 ;
17014   PyObject * obj0 = 0 ;
17015   PyObject * obj1 = 0 ;
17016   PyObject * obj2 = 0 ;
17017
17018   if (!PyArg_ParseTuple(args,(char *)"OOO:prod_mixte",&obj0,&obj1,&obj2)) SWIG_fail;
17019   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17020   if (!SWIG_IsOK(res1)) {
17021     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_mixte" "', argument " "1"" of type '" "double []""'");
17022   }
17023   arg1 = reinterpret_cast< double * >(argp1);
17024   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
17025   if (!SWIG_IsOK(res2)) {
17026     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_mixte" "', argument " "2"" of type '" "double []""'");
17027   }
17028   arg2 = reinterpret_cast< double * >(argp2);
17029   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
17030   if (!SWIG_IsOK(res3)) {
17031     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "prod_mixte" "', argument " "3"" of type '" "double []""'");
17032   }
17033   arg3 = reinterpret_cast< double * >(argp3);
17034   result = (double)Hex::prod_mixte(arg1,arg2,arg3);
17035   resultobj = SWIG_From_double(static_cast< double >(result));
17036   return resultobj;
17037 fail:
17038   return NULL;
17039 }
17040
17041
17042 SWIGINTERN PyObject *_wrap_deg2radians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17043   PyObject *resultobj = 0;
17044   double arg1 ;
17045   double result;
17046   double val1 ;
17047   int ecode1 = 0 ;
17048   PyObject * obj0 = 0 ;
17049
17050   if (!PyArg_ParseTuple(args,(char *)"O:deg2radians",&obj0)) SWIG_fail;
17051   ecode1 = SWIG_AsVal_double(obj0, &val1);
17052   if (!SWIG_IsOK(ecode1)) {
17053     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "deg2radians" "', argument " "1"" of type '" "double""'");
17054   }
17055   arg1 = static_cast< double >(val1);
17056   result = (double)Hex::deg2radians(arg1);
17057   resultobj = SWIG_From_double(static_cast< double >(result));
17058   return resultobj;
17059 fail:
17060   return NULL;
17061 }
17062
17063
17064 SWIGINTERN PyObject *_wrap_rad2degres(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17065   PyObject *resultobj = 0;
17066   double arg1 ;
17067   double result;
17068   double val1 ;
17069   int ecode1 = 0 ;
17070   PyObject * obj0 = 0 ;
17071
17072   if (!PyArg_ParseTuple(args,(char *)"O:rad2degres",&obj0)) SWIG_fail;
17073   ecode1 = SWIG_AsVal_double(obj0, &val1);
17074   if (!SWIG_IsOK(ecode1)) {
17075     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "rad2degres" "', argument " "1"" of type '" "double""'");
17076   }
17077   arg1 = static_cast< double >(val1);
17078   result = (double)Hex::rad2degres(arg1);
17079   resultobj = SWIG_From_double(static_cast< double >(result));
17080   return resultobj;
17081 fail:
17082   return NULL;
17083 }
17084
17085
17086 SWIGINTERN PyObject *_wrap_calc_norme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17087   PyObject *resultobj = 0;
17088   double *arg1 ;
17089   double result;
17090   void *argp1 = 0 ;
17091   int res1 = 0 ;
17092   PyObject * obj0 = 0 ;
17093
17094   if (!PyArg_ParseTuple(args,(char *)"O:calc_norme",&obj0)) SWIG_fail;
17095   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17096   if (!SWIG_IsOK(res1)) {
17097     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_norme" "', argument " "1"" of type '" "double []""'");
17098   }
17099   arg1 = reinterpret_cast< double * >(argp1);
17100   result = (double)Hex::calc_norme(arg1);
17101   resultobj = SWIG_From_double(static_cast< double >(result));
17102   return resultobj;
17103 fail:
17104   return NULL;
17105 }
17106
17107
17108 SWIGINTERN PyObject *_wrap_calc_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17109   PyObject *resultobj = 0;
17110   double *arg1 ;
17111   double *arg2 ;
17112   double result;
17113   void *argp1 = 0 ;
17114   int res1 = 0 ;
17115   void *argp2 = 0 ;
17116   int res2 = 0 ;
17117   PyObject * obj0 = 0 ;
17118   PyObject * obj1 = 0 ;
17119
17120   if (!PyArg_ParseTuple(args,(char *)"OO:calc_distance",&obj0,&obj1)) SWIG_fail;
17121   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17122   if (!SWIG_IsOK(res1)) {
17123     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_distance" "', argument " "1"" of type '" "double []""'");
17124   }
17125   arg1 = reinterpret_cast< double * >(argp1);
17126   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
17127   if (!SWIG_IsOK(res2)) {
17128     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_distance" "', argument " "2"" of type '" "double []""'");
17129   }
17130   arg2 = reinterpret_cast< double * >(argp2);
17131   result = (double)Hex::calc_distance(arg1,arg2);
17132   resultobj = SWIG_From_double(static_cast< double >(result));
17133   return resultobj;
17134 fail:
17135   return NULL;
17136 }
17137
17138
17139 SWIGINTERN PyObject *_wrap_calc_d2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17140   PyObject *resultobj = 0;
17141   double *arg1 ;
17142   double *arg2 ;
17143   double result;
17144   void *argp1 = 0 ;
17145   int res1 = 0 ;
17146   void *argp2 = 0 ;
17147   int res2 = 0 ;
17148   PyObject * obj0 = 0 ;
17149   PyObject * obj1 = 0 ;
17150
17151   if (!PyArg_ParseTuple(args,(char *)"OO:calc_d2",&obj0,&obj1)) SWIG_fail;
17152   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17153   if (!SWIG_IsOK(res1)) {
17154     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_d2" "', argument " "1"" of type '" "double []""'");
17155   }
17156   arg1 = reinterpret_cast< double * >(argp1);
17157   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
17158   if (!SWIG_IsOK(res2)) {
17159     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_d2" "', argument " "2"" of type '" "double []""'");
17160   }
17161   arg2 = reinterpret_cast< double * >(argp2);
17162   result = (double)Hex::calc_d2(arg1,arg2);
17163   resultobj = SWIG_From_double(static_cast< double >(result));
17164   return resultobj;
17165 fail:
17166   return NULL;
17167 }
17168
17169
17170 SWIGINTERN PyObject *_wrap_calc_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17171   PyObject *resultobj = 0;
17172   double *arg1 ;
17173   double *arg2 ;
17174   double *arg3 ;
17175   void *argp1 = 0 ;
17176   int res1 = 0 ;
17177   void *argp2 = 0 ;
17178   int res2 = 0 ;
17179   void *argp3 = 0 ;
17180   int res3 = 0 ;
17181   PyObject * obj0 = 0 ;
17182   PyObject * obj1 = 0 ;
17183   PyObject * obj2 = 0 ;
17184
17185   if (!PyArg_ParseTuple(args,(char *)"OOO:calc_vecteur",&obj0,&obj1,&obj2)) SWIG_fail;
17186   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17187   if (!SWIG_IsOK(res1)) {
17188     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_vecteur" "', argument " "1"" of type '" "double []""'");
17189   }
17190   arg1 = reinterpret_cast< double * >(argp1);
17191   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
17192   if (!SWIG_IsOK(res2)) {
17193     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_vecteur" "', argument " "2"" of type '" "double []""'");
17194   }
17195   arg2 = reinterpret_cast< double * >(argp2);
17196   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
17197   if (!SWIG_IsOK(res3)) {
17198     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "calc_vecteur" "', argument " "3"" of type '" "double []""'");
17199   }
17200   arg3 = reinterpret_cast< double * >(argp3);
17201   Hex::calc_vecteur(arg1,arg2,arg3);
17202   resultobj = SWIG_Py_Void();
17203   return resultobj;
17204 fail:
17205   return NULL;
17206 }
17207
17208
17209 SWIGINTERN PyObject *_wrap_copy_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17210   PyObject *resultobj = 0;
17211   double *arg1 ;
17212   double *arg2 ;
17213   void *argp1 = 0 ;
17214   int res1 = 0 ;
17215   void *argp2 = 0 ;
17216   int res2 = 0 ;
17217   PyObject * obj0 = 0 ;
17218   PyObject * obj1 = 0 ;
17219
17220   if (!PyArg_ParseTuple(args,(char *)"OO:copy_vecteur",&obj0,&obj1)) SWIG_fail;
17221   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17222   if (!SWIG_IsOK(res1)) {
17223     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_vecteur" "', argument " "1"" of type '" "double []""'");
17224   }
17225   arg1 = reinterpret_cast< double * >(argp1);
17226   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
17227   if (!SWIG_IsOK(res2)) {
17228     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copy_vecteur" "', argument " "2"" of type '" "double []""'");
17229   }
17230   arg2 = reinterpret_cast< double * >(argp2);
17231   Hex::copy_vecteur(arg1,arg2);
17232   resultobj = SWIG_Py_Void();
17233   return resultobj;
17234 fail:
17235   return NULL;
17236 }
17237
17238
17239 SWIGINTERN PyObject *_wrap_calc_milieu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17240   PyObject *resultobj = 0;
17241   double *arg1 ;
17242   double *arg2 ;
17243   double *arg3 ;
17244   void *argp1 = 0 ;
17245   int res1 = 0 ;
17246   void *argp2 = 0 ;
17247   int res2 = 0 ;
17248   void *argp3 = 0 ;
17249   int res3 = 0 ;
17250   PyObject * obj0 = 0 ;
17251   PyObject * obj1 = 0 ;
17252   PyObject * obj2 = 0 ;
17253
17254   if (!PyArg_ParseTuple(args,(char *)"OOO:calc_milieu",&obj0,&obj1,&obj2)) SWIG_fail;
17255   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17256   if (!SWIG_IsOK(res1)) {
17257     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_milieu" "', argument " "1"" of type '" "double []""'");
17258   }
17259   arg1 = reinterpret_cast< double * >(argp1);
17260   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
17261   if (!SWIG_IsOK(res2)) {
17262     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_milieu" "', argument " "2"" of type '" "double []""'");
17263   }
17264   arg2 = reinterpret_cast< double * >(argp2);
17265   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
17266   if (!SWIG_IsOK(res3)) {
17267     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "calc_milieu" "', argument " "3"" of type '" "double []""'");
17268   }
17269   arg3 = reinterpret_cast< double * >(argp3);
17270   Hex::calc_milieu(arg1,arg2,arg3);
17271   resultobj = SWIG_Py_Void();
17272   return resultobj;
17273 fail:
17274   return NULL;
17275 }
17276
17277
17278 SWIGINTERN PyObject *_wrap_normer_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17279   PyObject *resultobj = 0;
17280   double *arg1 ;
17281   int result;
17282   void *argp1 = 0 ;
17283   int res1 = 0 ;
17284   PyObject * obj0 = 0 ;
17285
17286   if (!PyArg_ParseTuple(args,(char *)"O:normer_vecteur",&obj0)) SWIG_fail;
17287   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17288   if (!SWIG_IsOK(res1)) {
17289     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "normer_vecteur" "', argument " "1"" of type '" "double []""'");
17290   }
17291   arg1 = reinterpret_cast< double * >(argp1);
17292   result = (int)Hex::normer_vecteur(arg1);
17293   resultobj = SWIG_From_int(static_cast< int >(result));
17294   return resultobj;
17295 fail:
17296   return NULL;
17297 }
17298
17299
17300 SWIGINTERN PyObject *_wrap_carre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17301   PyObject *resultobj = 0;
17302   double arg1 ;
17303   double result;
17304   double val1 ;
17305   int ecode1 = 0 ;
17306   PyObject * obj0 = 0 ;
17307
17308   if (!PyArg_ParseTuple(args,(char *)"O:carre",&obj0)) SWIG_fail;
17309   ecode1 = SWIG_AsVal_double(obj0, &val1);
17310   if (!SWIG_IsOK(ecode1)) {
17311     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "carre" "', argument " "1"" of type '" "double""'");
17312   }
17313   arg1 = static_cast< double >(val1);
17314   result = (double)Hex::carre(arg1);
17315   resultobj = SWIG_From_double(static_cast< double >(result));
17316   return resultobj;
17317 fail:
17318   return NULL;
17319 }
17320
17321
17322 SWIGINTERN PyObject *_wrap_same_coords__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17323   PyObject *resultobj = 0;
17324   double *arg1 = (double *) 0 ;
17325   double *arg2 = (double *) 0 ;
17326   double arg3 ;
17327   bool result;
17328   void *argp1 = 0 ;
17329   int res1 = 0 ;
17330   void *argp2 = 0 ;
17331   int res2 = 0 ;
17332   double val3 ;
17333   int ecode3 = 0 ;
17334   PyObject * obj0 = 0 ;
17335   PyObject * obj1 = 0 ;
17336   PyObject * obj2 = 0 ;
17337
17338   if (!PyArg_ParseTuple(args,(char *)"OOO:same_coords",&obj0,&obj1,&obj2)) SWIG_fail;
17339   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17340   if (!SWIG_IsOK(res1)) {
17341     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "same_coords" "', argument " "1"" of type '" "double *""'");
17342   }
17343   arg1 = reinterpret_cast< double * >(argp1);
17344   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
17345   if (!SWIG_IsOK(res2)) {
17346     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "same_coords" "', argument " "2"" of type '" "double *""'");
17347   }
17348   arg2 = reinterpret_cast< double * >(argp2);
17349   ecode3 = SWIG_AsVal_double(obj2, &val3);
17350   if (!SWIG_IsOK(ecode3)) {
17351     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "same_coords" "', argument " "3"" of type '" "double""'");
17352   }
17353   arg3 = static_cast< double >(val3);
17354   result = (bool)Hex::same_coords(arg1,arg2,arg3);
17355   resultobj = SWIG_From_bool(static_cast< bool >(result));
17356   return resultobj;
17357 fail:
17358   return NULL;
17359 }
17360
17361
17362 SWIGINTERN PyObject *_wrap_same_coords__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17363   PyObject *resultobj = 0;
17364   double *arg1 = (double *) 0 ;
17365   double *arg2 = (double *) 0 ;
17366   bool result;
17367   void *argp1 = 0 ;
17368   int res1 = 0 ;
17369   void *argp2 = 0 ;
17370   int res2 = 0 ;
17371   PyObject * obj0 = 0 ;
17372   PyObject * obj1 = 0 ;
17373
17374   if (!PyArg_ParseTuple(args,(char *)"OO:same_coords",&obj0,&obj1)) SWIG_fail;
17375   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17376   if (!SWIG_IsOK(res1)) {
17377     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "same_coords" "', argument " "1"" of type '" "double *""'");
17378   }
17379   arg1 = reinterpret_cast< double * >(argp1);
17380   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
17381   if (!SWIG_IsOK(res2)) {
17382     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "same_coords" "', argument " "2"" of type '" "double *""'");
17383   }
17384   arg2 = reinterpret_cast< double * >(argp2);
17385   result = (bool)Hex::same_coords(arg1,arg2);
17386   resultobj = SWIG_From_bool(static_cast< bool >(result));
17387   return resultobj;
17388 fail:
17389   return NULL;
17390 }
17391
17392
17393 SWIGINTERN PyObject *_wrap_same_coords(PyObject *self, PyObject *args) {
17394   int argc;
17395   PyObject *argv[4];
17396   int ii;
17397
17398   if (!PyTuple_Check(args)) SWIG_fail;
17399   argc = PyObject_Length(args);
17400   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17401     argv[ii] = PyTuple_GET_ITEM(args,ii);
17402   }
17403   if (argc == 2) {
17404     int _v;
17405     void *vptr = 0;
17406     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
17407     _v = SWIG_CheckState(res);
17408     if (_v) {
17409       void *vptr = 0;
17410       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
17411       _v = SWIG_CheckState(res);
17412       if (_v) {
17413         return _wrap_same_coords__SWIG_1(self, args);
17414       }
17415     }
17416   }
17417   if (argc == 3) {
17418     int _v;
17419     void *vptr = 0;
17420     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
17421     _v = SWIG_CheckState(res);
17422     if (_v) {
17423       void *vptr = 0;
17424       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
17425       _v = SWIG_CheckState(res);
17426       if (_v) {
17427         {
17428           int res = SWIG_AsVal_double(argv[2], NULL);
17429           _v = SWIG_CheckState(res);
17430         }
17431         if (_v) {
17432           return _wrap_same_coords__SWIG_0(self, args);
17433         }
17434       }
17435     }
17436   }
17437
17438 fail:
17439   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'same_coords'.\n  Possible C/C++ prototypes are:\n    Hex::same_coords(double *,double *,double)\n    Hex::same_coords(double *,double *)\n");
17440   return NULL;
17441 }
17442
17443
17444 SWIGINTERN PyObject *_wrap_requals__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17445   PyObject *resultobj = 0;
17446   double arg1 ;
17447   double arg2 ;
17448   bool result;
17449   double val1 ;
17450   int ecode1 = 0 ;
17451   double val2 ;
17452   int ecode2 = 0 ;
17453   PyObject * obj0 = 0 ;
17454   PyObject * obj1 = 0 ;
17455
17456   if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
17457   ecode1 = SWIG_AsVal_double(obj0, &val1);
17458   if (!SWIG_IsOK(ecode1)) {
17459     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "requals" "', argument " "1"" of type '" "double""'");
17460   }
17461   arg1 = static_cast< double >(val1);
17462   ecode2 = SWIG_AsVal_double(obj1, &val2);
17463   if (!SWIG_IsOK(ecode2)) {
17464     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "requals" "', argument " "2"" of type '" "double""'");
17465   }
17466   arg2 = static_cast< double >(val2);
17467   result = (bool)Hex::requals(arg1,arg2);
17468   resultobj = SWIG_From_bool(static_cast< bool >(result));
17469   return resultobj;
17470 fail:
17471   return NULL;
17472 }
17473
17474
17475 SWIGINTERN PyObject *_wrap_requals__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17476   PyObject *resultobj = 0;
17477   double *arg1 = (double *) 0 ;
17478   double *arg2 = (double *) 0 ;
17479   bool result;
17480   void *argp1 = 0 ;
17481   int res1 = 0 ;
17482   void *argp2 = 0 ;
17483   int res2 = 0 ;
17484   PyObject * obj0 = 0 ;
17485   PyObject * obj1 = 0 ;
17486
17487   if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
17488   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
17489   if (!SWIG_IsOK(res1)) {
17490     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "requals" "', argument " "1"" of type '" "double const *""'");
17491   }
17492   arg1 = reinterpret_cast< double * >(argp1);
17493   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
17494   if (!SWIG_IsOK(res2)) {
17495     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "requals" "', argument " "2"" of type '" "double const *""'");
17496   }
17497   arg2 = reinterpret_cast< double * >(argp2);
17498   result = (bool)Hex::requals((double const *)arg1,(double const *)arg2);
17499   resultobj = SWIG_From_bool(static_cast< bool >(result));
17500   return resultobj;
17501 fail:
17502   return NULL;
17503 }
17504
17505
17506 SWIGINTERN PyObject *_wrap_requals(PyObject *self, PyObject *args) {
17507   int argc;
17508   PyObject *argv[3];
17509   int ii;
17510
17511   if (!PyTuple_Check(args)) SWIG_fail;
17512   argc = PyObject_Length(args);
17513   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
17514     argv[ii] = PyTuple_GET_ITEM(args,ii);
17515   }
17516   if (argc == 2) {
17517     int _v;
17518     void *vptr = 0;
17519     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
17520     _v = SWIG_CheckState(res);
17521     if (_v) {
17522       void *vptr = 0;
17523       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
17524       _v = SWIG_CheckState(res);
17525       if (_v) {
17526         return _wrap_requals__SWIG_1(self, args);
17527       }
17528     }
17529   }
17530   if (argc == 2) {
17531     int _v;
17532     {
17533       int res = SWIG_AsVal_double(argv[0], NULL);
17534       _v = SWIG_CheckState(res);
17535     }
17536     if (_v) {
17537       {
17538         int res = SWIG_AsVal_double(argv[1], NULL);
17539         _v = SWIG_CheckState(res);
17540       }
17541       if (_v) {
17542         return _wrap_requals__SWIG_0(self, args);
17543       }
17544     }
17545   }
17546
17547 fail:
17548   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'requals'.\n  Possible C/C++ prototypes are:\n    Hex::requals(double const,double const)\n    Hex::requals(double const *,double const *)\n");
17549   return NULL;
17550 }
17551
17552
17553 SWIGINTERN PyObject *_wrap_on_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17554   PyObject *resultobj = 0;
17555   bool result;
17556
17557   if (!PyArg_ParseTuple(args,(char *)":on_debug")) SWIG_fail;
17558   result = (bool)Hex::on_debug();
17559   resultobj = SWIG_From_bool(static_cast< bool >(result));
17560   return resultobj;
17561 fail:
17562   return NULL;
17563 }
17564
17565
17566 SWIGINTERN PyObject *_wrap_in_test(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17567   PyObject *resultobj = 0;
17568   bool result;
17569
17570   if (!PyArg_ParseTuple(args,(char *)":in_test")) SWIG_fail;
17571   result = (bool)Hex::in_test();
17572   resultobj = SWIG_From_bool(static_cast< bool >(result));
17573   return resultobj;
17574 fail:
17575   return NULL;
17576 }
17577
17578
17579 SWIGINTERN PyObject *_wrap_niv_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17580   PyObject *resultobj = 0;
17581   int result;
17582
17583   if (!PyArg_ParseTuple(args,(char *)":niv_debug")) SWIG_fail;
17584   result = (int)Hex::niv_debug();
17585   resultobj = SWIG_From_int(static_cast< int >(result));
17586   return resultobj;
17587 fail:
17588   return NULL;
17589 }
17590
17591
17592 SWIGINTERN PyObject *_wrap_set_minus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17593   PyObject *resultobj = 0;
17594   string *arg1 = 0 ;
17595   void *argp1 = 0 ;
17596   int res1 = 0 ;
17597   PyObject * obj0 = 0 ;
17598
17599   if (!PyArg_ParseTuple(args,(char *)"O:set_minus",&obj0)) SWIG_fail;
17600   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_string,  0 );
17601   if (!SWIG_IsOK(res1)) {
17602     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_minus" "', argument " "1"" of type '" "string &""'");
17603   }
17604   if (!argp1) {
17605     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_minus" "', argument " "1"" of type '" "string &""'");
17606   }
17607   arg1 = reinterpret_cast< string * >(argp1);
17608   Hex::set_minus(*arg1);
17609   resultobj = SWIG_Py_Void();
17610   return resultobj;
17611 fail:
17612   return NULL;
17613 }
17614
17615
17616 SWIGINTERN PyObject *_wrap_special_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17617   PyObject *resultobj = 0;
17618   bool result;
17619
17620   if (!PyArg_ParseTuple(args,(char *)":special_option")) SWIG_fail;
17621   result = (bool)Hex::special_option();
17622   resultobj = SWIG_From_bool(static_cast< bool >(result));
17623   return resultobj;
17624 fail:
17625   return NULL;
17626 }
17627
17628
17629 SWIGINTERN PyObject *_wrap_set_special_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17630   PyObject *resultobj = 0;
17631   bool arg1 ;
17632   bool val1 ;
17633   int ecode1 = 0 ;
17634   PyObject * obj0 = 0 ;
17635
17636   if (!PyArg_ParseTuple(args,(char *)"O:set_special_option",&obj0)) SWIG_fail;
17637   ecode1 = SWIG_AsVal_bool(obj0, &val1);
17638   if (!SWIG_IsOK(ecode1)) {
17639     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_special_option" "', argument " "1"" of type '" "bool""'");
17640   }
17641   arg1 = static_cast< bool >(val1);
17642   Hex::set_special_option(arg1);
17643   resultobj = SWIG_Py_Void();
17644   return resultobj;
17645 fail:
17646   return NULL;
17647 }
17648
17649
17650 SWIGINTERN PyObject *_wrap_sizeof_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17651   PyObject *resultobj = 0;
17652   cpchar arg1 = (cpchar) 0 ;
17653   int result;
17654   int res1 ;
17655   char *buf1 = 0 ;
17656   int alloc1 = 0 ;
17657   PyObject * obj0 = 0 ;
17658
17659   if (!PyArg_ParseTuple(args,(char *)"O:sizeof_file",&obj0)) SWIG_fail;
17660   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
17661   if (!SWIG_IsOK(res1)) {
17662     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sizeof_file" "', argument " "1"" of type '" "cpchar""'");
17663   }
17664   arg1 = reinterpret_cast< cpchar >(buf1);
17665   result = (int)Hex::sizeof_file((char const *)arg1);
17666   resultobj = SWIG_From_int(static_cast< int >(result));
17667   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17668   return resultobj;
17669 fail:
17670   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17671   return NULL;
17672 }
17673
17674
17675 SWIGINTERN PyObject *_wrap_read_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17676   PyObject *resultobj = 0;
17677   cpchar arg1 = (cpchar) 0 ;
17678   int *arg2 = 0 ;
17679   char *result = 0 ;
17680   int res1 ;
17681   char *buf1 = 0 ;
17682   int alloc1 = 0 ;
17683   void *argp2 = 0 ;
17684   int res2 = 0 ;
17685   PyObject * obj0 = 0 ;
17686   PyObject * obj1 = 0 ;
17687
17688   if (!PyArg_ParseTuple(args,(char *)"OO:read_file",&obj0,&obj1)) SWIG_fail;
17689   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
17690   if (!SWIG_IsOK(res1)) {
17691     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read_file" "', argument " "1"" of type '" "cpchar""'");
17692   }
17693   arg1 = reinterpret_cast< cpchar >(buf1);
17694   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
17695   if (!SWIG_IsOK(res2)) {
17696     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "read_file" "', argument " "2"" of type '" "int &""'");
17697   }
17698   if (!argp2) {
17699     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "read_file" "', argument " "2"" of type '" "int &""'");
17700   }
17701   arg2 = reinterpret_cast< int * >(argp2);
17702   result = (char *)Hex::read_file((char const *)arg1,*arg2);
17703   resultobj = SWIG_FromCharPtr((const char *)result);
17704   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17705   return resultobj;
17706 fail:
17707   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17708   return NULL;
17709 }
17710
17711
17712 SWIGINTERN PyObject *_wrap_get_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17713   PyObject *resultobj = 0;
17714   string *arg1 = 0 ;
17715   cpchar result;
17716   void *argp1 = 0 ;
17717   int res1 = 0 ;
17718   PyObject * obj0 = 0 ;
17719
17720   if (!PyArg_ParseTuple(args,(char *)"O:get_time",&obj0)) SWIG_fail;
17721   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_string,  0 );
17722   if (!SWIG_IsOK(res1)) {
17723     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_time" "', argument " "1"" of type '" "string &""'");
17724   }
17725   if (!argp1) {
17726     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get_time" "', argument " "1"" of type '" "string &""'");
17727   }
17728   arg1 = reinterpret_cast< string * >(argp1);
17729   result = (cpchar)Hex::get_time(*arg1);
17730   resultobj = SWIG_FromCharPtr((const char *)result);
17731   return resultobj;
17732 fail:
17733   return NULL;
17734 }
17735
17736
17737 SWIGINTERN PyObject *_wrap_make_basename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17738   PyObject *resultobj = 0;
17739   cpchar arg1 = (cpchar) 0 ;
17740   string *arg2 = 0 ;
17741   int result;
17742   int res1 ;
17743   char *buf1 = 0 ;
17744   int alloc1 = 0 ;
17745   void *argp2 = 0 ;
17746   int res2 = 0 ;
17747   PyObject * obj0 = 0 ;
17748   PyObject * obj1 = 0 ;
17749
17750   if (!PyArg_ParseTuple(args,(char *)"OO:make_basename",&obj0,&obj1)) SWIG_fail;
17751   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
17752   if (!SWIG_IsOK(res1)) {
17753     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_basename" "', argument " "1"" of type '" "cpchar""'");
17754   }
17755   arg1 = reinterpret_cast< cpchar >(buf1);
17756   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string,  0 );
17757   if (!SWIG_IsOK(res2)) {
17758     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_basename" "', argument " "2"" of type '" "string &""'");
17759   }
17760   if (!argp2) {
17761     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_basename" "', argument " "2"" of type '" "string &""'");
17762   }
17763   arg2 = reinterpret_cast< string * >(argp2);
17764   result = (int)Hex::make_basename((char const *)arg1,*arg2);
17765   resultobj = SWIG_From_int(static_cast< int >(result));
17766   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17767   return resultobj;
17768 fail:
17769   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17770   return NULL;
17771 }
17772
17773
17774 SWIGINTERN int Epsil_set(PyObject *) {
17775   SWIG_Error(SWIG_AttributeError,"Variable Epsil is read-only.");
17776   return 1;
17777 }
17778
17779
17780 SWIGINTERN PyObject *Epsil_get(void) {
17781   PyObject *pyobj = 0;
17782
17783   pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil));
17784   return pyobj;
17785 }
17786
17787
17788 SWIGINTERN int UnEpsil_set(PyObject *) {
17789   SWIG_Error(SWIG_AttributeError,"Variable UnEpsil is read-only.");
17790   return 1;
17791 }
17792
17793
17794 SWIGINTERN PyObject *UnEpsil_get(void) {
17795   PyObject *pyobj = 0;
17796
17797   pyobj = SWIG_From_double(static_cast< double >(Hex::UnEpsil));
17798   return pyobj;
17799 }
17800
17801
17802 SWIGINTERN int Epsil2_set(PyObject *) {
17803   SWIG_Error(SWIG_AttributeError,"Variable Epsil2 is read-only.");
17804   return 1;
17805 }
17806
17807
17808 SWIGINTERN PyObject *Epsil2_get(void) {
17809   PyObject *pyobj = 0;
17810
17811   pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil2));
17812   return pyobj;
17813 }
17814
17815
17816 SWIGINTERN PyObject *_wrap_EltBase_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17817   PyObject *resultobj = 0;
17818   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17819   int result;
17820   void *argp1 = 0 ;
17821   int res1 = 0 ;
17822   PyObject * obj0 = 0 ;
17823
17824   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countHexa",&obj0)) SWIG_fail;
17825   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
17826   if (!SWIG_IsOK(res1)) {
17827     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countHexa" "', argument " "1"" of type '" "Hex::EltBase *""'");
17828   }
17829   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17830   result = (int)(arg1)->countHexa();
17831   resultobj = SWIG_From_int(static_cast< int >(result));
17832   return resultobj;
17833 fail:
17834   return NULL;
17835 }
17836
17837
17838 SWIGINTERN PyObject *_wrap_EltBase_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17839   PyObject *resultobj = 0;
17840   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17841   int result;
17842   void *argp1 = 0 ;
17843   int res1 = 0 ;
17844   PyObject * obj0 = 0 ;
17845
17846   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countQuad",&obj0)) SWIG_fail;
17847   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
17848   if (!SWIG_IsOK(res1)) {
17849     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countQuad" "', argument " "1"" of type '" "Hex::EltBase *""'");
17850   }
17851   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17852   result = (int)(arg1)->countQuad();
17853   resultobj = SWIG_From_int(static_cast< int >(result));
17854   return resultobj;
17855 fail:
17856   return NULL;
17857 }
17858
17859
17860 SWIGINTERN PyObject *_wrap_EltBase_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17861   PyObject *resultobj = 0;
17862   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17863   int result;
17864   void *argp1 = 0 ;
17865   int res1 = 0 ;
17866   PyObject * obj0 = 0 ;
17867
17868   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countEdge",&obj0)) SWIG_fail;
17869   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
17870   if (!SWIG_IsOK(res1)) {
17871     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countEdge" "', argument " "1"" of type '" "Hex::EltBase *""'");
17872   }
17873   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17874   result = (int)(arg1)->countEdge();
17875   resultobj = SWIG_From_int(static_cast< int >(result));
17876   return resultobj;
17877 fail:
17878   return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_EltBase_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17883   PyObject *resultobj = 0;
17884   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17885   int result;
17886   void *argp1 = 0 ;
17887   int res1 = 0 ;
17888   PyObject * obj0 = 0 ;
17889
17890   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countVertex",&obj0)) SWIG_fail;
17891   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
17892   if (!SWIG_IsOK(res1)) {
17893     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countVertex" "', argument " "1"" of type '" "Hex::EltBase *""'");
17894   }
17895   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17896   result = (int)(arg1)->countVertex();
17897   resultobj = SWIG_From_int(static_cast< int >(result));
17898   return resultobj;
17899 fail:
17900   return NULL;
17901 }
17902
17903
17904 SWIGINTERN PyObject *_wrap_EltBase_setError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17905   PyObject *resultobj = 0;
17906   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17907   int arg2 ;
17908   void *argp1 = 0 ;
17909   int res1 = 0 ;
17910   int val2 ;
17911   int ecode2 = 0 ;
17912   PyObject * obj0 = 0 ;
17913   PyObject * obj1 = 0 ;
17914
17915   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setError",&obj0,&obj1)) SWIG_fail;
17916   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
17917   if (!SWIG_IsOK(res1)) {
17918     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setError" "', argument " "1"" of type '" "Hex::EltBase *""'");
17919   }
17920   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17921   ecode2 = SWIG_AsVal_int(obj1, &val2);
17922   if (!SWIG_IsOK(ecode2)) {
17923     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setError" "', argument " "2"" of type '" "int""'");
17924   }
17925   arg2 = static_cast< int >(val2);
17926   (arg1)->setError(arg2);
17927   resultobj = SWIG_Py_Void();
17928   return resultobj;
17929 fail:
17930   return NULL;
17931 }
17932
17933
17934 SWIGINTERN PyObject *_wrap_EltBase_setError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17935   PyObject *resultobj = 0;
17936   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17937   void *argp1 = 0 ;
17938   int res1 = 0 ;
17939   PyObject * obj0 = 0 ;
17940
17941   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_setError",&obj0)) SWIG_fail;
17942   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
17943   if (!SWIG_IsOK(res1)) {
17944     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setError" "', argument " "1"" of type '" "Hex::EltBase *""'");
17945   }
17946   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
17947   (arg1)->setError();
17948   resultobj = SWIG_Py_Void();
17949   return resultobj;
17950 fail:
17951   return NULL;
17952 }
17953
17954
17955 SWIGINTERN PyObject *_wrap_EltBase_setError(PyObject *self, PyObject *args) {
17956   int argc;
17957   PyObject *argv[3];
17958   int ii;
17959
17960   if (!PyTuple_Check(args)) SWIG_fail;
17961   argc = PyObject_Length(args);
17962   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
17963     argv[ii] = PyTuple_GET_ITEM(args,ii);
17964   }
17965   if (argc == 1) {
17966     int _v;
17967     void *vptr = 0;
17968     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
17969     _v = SWIG_CheckState(res);
17970     if (_v) {
17971       return _wrap_EltBase_setError__SWIG_1(self, args);
17972     }
17973   }
17974   if (argc == 2) {
17975     int _v;
17976     void *vptr = 0;
17977     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
17978     _v = SWIG_CheckState(res);
17979     if (_v) {
17980       {
17981         int res = SWIG_AsVal_int(argv[1], NULL);
17982         _v = SWIG_CheckState(res);
17983       }
17984       if (_v) {
17985         return _wrap_EltBase_setError__SWIG_0(self, args);
17986       }
17987     }
17988   }
17989
17990 fail:
17991   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_setError'.\n  Possible C/C++ prototypes are:\n    setError(int)\n    setError()\n");
17992   return NULL;
17993 }
17994
17995
17996 SWIGINTERN PyObject *_wrap_EltBase_getError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17997   PyObject *resultobj = 0;
17998   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
17999   int result;
18000   void *argp1 = 0 ;
18001   int res1 = 0 ;
18002   PyObject * obj0 = 0 ;
18003
18004   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getError",&obj0)) SWIG_fail;
18005   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18006   if (!SWIG_IsOK(res1)) {
18007     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getError" "', argument " "1"" of type '" "Hex::EltBase *""'");
18008   }
18009   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18010   result = (int)(arg1)->getError();
18011   resultobj = SWIG_From_int(static_cast< int >(result));
18012   return resultobj;
18013 fail:
18014   return NULL;
18015 }
18016
18017
18018 SWIGINTERN PyObject *_wrap_EltBase_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18019   PyObject *resultobj = 0;
18020   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18021   bool result;
18022   void *argp1 = 0 ;
18023   int res1 = 0 ;
18024   PyObject * obj0 = 0 ;
18025
18026   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isValid",&obj0)) SWIG_fail;
18027   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18028   if (!SWIG_IsOK(res1)) {
18029     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isValid" "', argument " "1"" of type '" "Hex::EltBase *""'");
18030   }
18031   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18032   result = (bool)(arg1)->isValid();
18033   resultobj = SWIG_From_bool(static_cast< bool >(result));
18034   return resultobj;
18035 fail:
18036   return NULL;
18037 }
18038
18039
18040 SWIGINTERN PyObject *_wrap_EltBase_isBad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18041   PyObject *resultobj = 0;
18042   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18043   bool result;
18044   void *argp1 = 0 ;
18045   int res1 = 0 ;
18046   PyObject * obj0 = 0 ;
18047
18048   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isBad",&obj0)) SWIG_fail;
18049   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18050   if (!SWIG_IsOK(res1)) {
18051     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isBad" "', argument " "1"" of type '" "Hex::EltBase *""'");
18052   }
18053   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18054   result = (bool)(arg1)->isBad();
18055   resultobj = SWIG_From_bool(static_cast< bool >(result));
18056   return resultobj;
18057 fail:
18058   return NULL;
18059 }
18060
18061
18062 SWIGINTERN PyObject *_wrap_EltBase_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18063   PyObject *resultobj = 0;
18064   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18065   void *argp1 = 0 ;
18066   int res1 = 0 ;
18067   PyObject * obj0 = 0 ;
18068
18069   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_duplicate",&obj0)) SWIG_fail;
18070   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18071   if (!SWIG_IsOK(res1)) {
18072     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_duplicate" "', argument " "1"" of type '" "Hex::EltBase *""'");
18073   }
18074   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18075   (arg1)->duplicate();
18076   resultobj = SWIG_Py_Void();
18077   return resultobj;
18078 fail:
18079   return NULL;
18080 }
18081
18082
18083 SWIGINTERN PyObject *_wrap_EltBase_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18084   PyObject *resultobj = 0;
18085   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18086   void *argp1 = 0 ;
18087   int res1 = 0 ;
18088   PyObject * obj0 = 0 ;
18089
18090   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_clearAssociation",&obj0)) SWIG_fail;
18091   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18092   if (!SWIG_IsOK(res1)) {
18093     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_clearAssociation" "', argument " "1"" of type '" "Hex::EltBase *""'");
18094   }
18095   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18096   (arg1)->clearAssociation();
18097   resultobj = SWIG_Py_Void();
18098   return resultobj;
18099 fail:
18100   return NULL;
18101 }
18102
18103
18104 SWIGINTERN PyObject *_wrap_EltBase_replaceEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18105   PyObject *resultobj = 0;
18106   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18107   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
18108   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
18109   void *argp1 = 0 ;
18110   int res1 = 0 ;
18111   void *argp2 = 0 ;
18112   int res2 = 0 ;
18113   void *argp3 = 0 ;
18114   int res3 = 0 ;
18115   PyObject * obj0 = 0 ;
18116   PyObject * obj1 = 0 ;
18117   PyObject * obj2 = 0 ;
18118
18119   if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_replaceEdge",&obj0,&obj1,&obj2)) SWIG_fail;
18120   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18121   if (!SWIG_IsOK(res1)) {
18122     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_replaceEdge" "', argument " "1"" of type '" "Hex::EltBase *""'");
18123   }
18124   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18125   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
18126   if (!SWIG_IsOK(res2)) {
18127     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_replaceEdge" "', argument " "2"" of type '" "Hex::Edge *""'");
18128   }
18129   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
18130   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
18131   if (!SWIG_IsOK(res3)) {
18132     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_replaceEdge" "', argument " "3"" of type '" "Hex::Edge *""'");
18133   }
18134   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
18135   (arg1)->replaceEdge(arg2,arg3);
18136   resultobj = SWIG_Py_Void();
18137   return resultobj;
18138 fail:
18139   return NULL;
18140 }
18141
18142
18143 SWIGINTERN PyObject *_wrap_EltBase_replaceVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18144   PyObject *resultobj = 0;
18145   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18146   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
18147   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
18148   void *argp1 = 0 ;
18149   int res1 = 0 ;
18150   void *argp2 = 0 ;
18151   int res2 = 0 ;
18152   void *argp3 = 0 ;
18153   int res3 = 0 ;
18154   PyObject * obj0 = 0 ;
18155   PyObject * obj1 = 0 ;
18156   PyObject * obj2 = 0 ;
18157
18158   if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_replaceVertex",&obj0,&obj1,&obj2)) SWIG_fail;
18159   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18160   if (!SWIG_IsOK(res1)) {
18161     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_replaceVertex" "', argument " "1"" of type '" "Hex::EltBase *""'");
18162   }
18163   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18164   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
18165   if (!SWIG_IsOK(res2)) {
18166     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_replaceVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
18167   }
18168   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
18169   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
18170   if (!SWIG_IsOK(res3)) {
18171     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_replaceVertex" "', argument " "3"" of type '" "Hex::Vertex *""'");
18172   }
18173   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
18174   (arg1)->replaceVertex(arg2,arg3);
18175   resultobj = SWIG_Py_Void();
18176   return resultobj;
18177 fail:
18178   return NULL;
18179 }
18180
18181
18182 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18183   PyObject *resultobj = 0;
18184   Hex::Document *arg1 = (Hex::Document *) 0 ;
18185   Hex::EnumElt arg2 ;
18186   Hex::EltBase *result = 0 ;
18187   void *argp1 = 0 ;
18188   int res1 = 0 ;
18189   int val2 ;
18190   int ecode2 = 0 ;
18191   PyObject * obj0 = 0 ;
18192   PyObject * obj1 = 0 ;
18193
18194   if (!PyArg_ParseTuple(args,(char *)"OO:new_EltBase",&obj0,&obj1)) SWIG_fail;
18195   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
18196   if (!SWIG_IsOK(res1)) {
18197     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::Document *""'");
18198   }
18199   arg1 = reinterpret_cast< Hex::Document * >(argp1);
18200   ecode2 = SWIG_AsVal_int(obj1, &val2);
18201   if (!SWIG_IsOK(ecode2)) {
18202     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EltBase" "', argument " "2"" of type '" "Hex::EnumElt""'");
18203   }
18204   arg2 = static_cast< Hex::EnumElt >(val2);
18205   result = (Hex::EltBase *)new Hex::EltBase(arg1,arg2);
18206   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
18207   return resultobj;
18208 fail:
18209   return NULL;
18210 }
18211
18212
18213 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18214   PyObject *resultobj = 0;
18215   Hex::Document *arg1 = (Hex::Document *) 0 ;
18216   Hex::EltBase *result = 0 ;
18217   void *argp1 = 0 ;
18218   int res1 = 0 ;
18219   PyObject * obj0 = 0 ;
18220
18221   if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
18222   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
18223   if (!SWIG_IsOK(res1)) {
18224     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::Document *""'");
18225   }
18226   arg1 = reinterpret_cast< Hex::Document * >(argp1);
18227   result = (Hex::EltBase *)new Hex::EltBase(arg1);
18228   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
18229   return resultobj;
18230 fail:
18231   return NULL;
18232 }
18233
18234
18235 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18236   PyObject *resultobj = 0;
18237   Hex::EnumElt arg1 ;
18238   Hex::EltBase *result = 0 ;
18239   int val1 ;
18240   int ecode1 = 0 ;
18241   PyObject * obj0 = 0 ;
18242
18243   if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
18244   ecode1 = SWIG_AsVal_int(obj0, &val1);
18245   if (!SWIG_IsOK(ecode1)) {
18246     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::EnumElt""'");
18247   }
18248   arg1 = static_cast< Hex::EnumElt >(val1);
18249   result = (Hex::EltBase *)new Hex::EltBase(arg1);
18250   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
18251   return resultobj;
18252 fail:
18253   return NULL;
18254 }
18255
18256
18257 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18258   PyObject *resultobj = 0;
18259   Hex::EltBase *result = 0 ;
18260
18261   if (!PyArg_ParseTuple(args,(char *)":new_EltBase")) SWIG_fail;
18262   result = (Hex::EltBase *)new Hex::EltBase();
18263   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
18264   return resultobj;
18265 fail:
18266   return NULL;
18267 }
18268
18269
18270 SWIGINTERN PyObject *_wrap_new_EltBase(PyObject *self, PyObject *args) {
18271   int argc;
18272   PyObject *argv[3];
18273   int ii;
18274
18275   if (!PyTuple_Check(args)) SWIG_fail;
18276   argc = PyObject_Length(args);
18277   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
18278     argv[ii] = PyTuple_GET_ITEM(args,ii);
18279   }
18280   if (argc == 0) {
18281     return _wrap_new_EltBase__SWIG_3(self, args);
18282   }
18283   if (argc == 1) {
18284     int _v;
18285     void *vptr = 0;
18286     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
18287     _v = SWIG_CheckState(res);
18288     if (_v) {
18289       return _wrap_new_EltBase__SWIG_1(self, args);
18290     }
18291   }
18292   if (argc == 1) {
18293     int _v;
18294     {
18295       int res = SWIG_AsVal_int(argv[0], NULL);
18296       _v = SWIG_CheckState(res);
18297     }
18298     if (_v) {
18299       return _wrap_new_EltBase__SWIG_2(self, args);
18300     }
18301   }
18302   if (argc == 2) {
18303     int _v;
18304     void *vptr = 0;
18305     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
18306     _v = SWIG_CheckState(res);
18307     if (_v) {
18308       {
18309         int res = SWIG_AsVal_int(argv[1], NULL);
18310         _v = SWIG_CheckState(res);
18311       }
18312       if (_v) {
18313         return _wrap_new_EltBase__SWIG_0(self, args);
18314       }
18315     }
18316   }
18317
18318 fail:
18319   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EltBase'.\n  Possible C/C++ prototypes are:\n    Hex::EltBase(Hex::Document *,Hex::EnumElt)\n    Hex::EltBase(Hex::Document *)\n    Hex::EltBase(Hex::EnumElt)\n    Hex::EltBase()\n");
18320   return NULL;
18321 }
18322
18323
18324 SWIGINTERN PyObject *_wrap_delete_EltBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18325   PyObject *resultobj = 0;
18326   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18327   void *argp1 = 0 ;
18328   int res1 = 0 ;
18329   PyObject * obj0 = 0 ;
18330
18331   if (!PyArg_ParseTuple(args,(char *)"O:delete_EltBase",&obj0)) SWIG_fail;
18332   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_DISOWN |  0 );
18333   if (!SWIG_IsOK(res1)) {
18334     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EltBase" "', argument " "1"" of type '" "Hex::EltBase *""'");
18335   }
18336   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18337   delete arg1;
18338
18339   resultobj = SWIG_Py_Void();
18340   return resultobj;
18341 fail:
18342   return NULL;
18343 }
18344
18345
18346 SWIGINTERN PyObject *_wrap_EltBase_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18347   PyObject *resultobj = 0;
18348   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18349   void *argp1 = 0 ;
18350   int res1 = 0 ;
18351   PyObject * obj0 = 0 ;
18352
18353   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_remove",&obj0)) SWIG_fail;
18354   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18355   if (!SWIG_IsOK(res1)) {
18356     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_remove" "', argument " "1"" of type '" "Hex::EltBase *""'");
18357   }
18358   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18359   (arg1)->remove();
18360   resultobj = SWIG_Py_Void();
18361   return resultobj;
18362 fail:
18363   return NULL;
18364 }
18365
18366
18367 SWIGINTERN PyObject *_wrap_EltBase_suppress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18368   PyObject *resultobj = 0;
18369   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18370   void *argp1 = 0 ;
18371   int res1 = 0 ;
18372   PyObject * obj0 = 0 ;
18373
18374   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_suppress",&obj0)) SWIG_fail;
18375   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18376   if (!SWIG_IsOK(res1)) {
18377     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_suppress" "', argument " "1"" of type '" "Hex::EltBase *""'");
18378   }
18379   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18380   (arg1)->suppress();
18381   resultobj = SWIG_Py_Void();
18382   return resultobj;
18383 fail:
18384   return NULL;
18385 }
18386
18387
18388 SWIGINTERN PyObject *_wrap_EltBase_dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18389   PyObject *resultobj = 0;
18390   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18391   void *argp1 = 0 ;
18392   int res1 = 0 ;
18393   PyObject * obj0 = 0 ;
18394
18395   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dump",&obj0)) SWIG_fail;
18396   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18397   if (!SWIG_IsOK(res1)) {
18398     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dump" "', argument " "1"" of type '" "Hex::EltBase *""'");
18399   }
18400   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18401   (arg1)->dump();
18402   resultobj = SWIG_Py_Void();
18403   return resultobj;
18404 fail:
18405   return NULL;
18406 }
18407
18408
18409 SWIGINTERN PyObject *_wrap_EltBase_saveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18410   PyObject *resultobj = 0;
18411   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18412   Hex::XmlWriter *arg2 = (Hex::XmlWriter *) 0 ;
18413   void *argp1 = 0 ;
18414   int res1 = 0 ;
18415   void *argp2 = 0 ;
18416   int res2 = 0 ;
18417   PyObject * obj0 = 0 ;
18418   PyObject * obj1 = 0 ;
18419
18420   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_saveXml",&obj0,&obj1)) SWIG_fail;
18421   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18422   if (!SWIG_IsOK(res1)) {
18423     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_saveXml" "', argument " "1"" of type '" "Hex::EltBase *""'");
18424   }
18425   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18426   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__XmlWriter, 0 |  0 );
18427   if (!SWIG_IsOK(res2)) {
18428     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_saveXml" "', argument " "2"" of type '" "Hex::XmlWriter *""'");
18429   }
18430   arg2 = reinterpret_cast< Hex::XmlWriter * >(argp2);
18431   (arg1)->saveXml(arg2);
18432   resultobj = SWIG_Py_Void();
18433   return resultobj;
18434 fail:
18435   return NULL;
18436 }
18437
18438
18439 SWIGINTERN PyObject *_wrap_EltBase_majReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18440   PyObject *resultobj = 0;
18441   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18442   void *argp1 = 0 ;
18443   int res1 = 0 ;
18444   PyObject * obj0 = 0 ;
18445
18446   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_majReferences",&obj0)) SWIG_fail;
18447   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18448   if (!SWIG_IsOK(res1)) {
18449     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_majReferences" "', argument " "1"" of type '" "Hex::EltBase *""'");
18450   }
18451   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18452   (arg1)->majReferences();
18453   resultobj = SWIG_Py_Void();
18454   return resultobj;
18455 fail:
18456   return NULL;
18457 }
18458
18459
18460 SWIGINTERN PyObject *_wrap_EltBase_makeVarName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18461   PyObject *resultobj = 0;
18462   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18463   char *arg2 = (char *) 0 ;
18464   char *result = 0 ;
18465   void *argp1 = 0 ;
18466   int res1 = 0 ;
18467   int res2 ;
18468   char *buf2 = 0 ;
18469   int alloc2 = 0 ;
18470   PyObject * obj0 = 0 ;
18471   PyObject * obj1 = 0 ;
18472
18473   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_makeVarName",&obj0,&obj1)) SWIG_fail;
18474   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18475   if (!SWIG_IsOK(res1)) {
18476     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_makeVarName" "', argument " "1"" of type '" "Hex::EltBase *""'");
18477   }
18478   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18479   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
18480   if (!SWIG_IsOK(res2)) {
18481     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_makeVarName" "', argument " "2"" of type '" "char *""'");
18482   }
18483   arg2 = reinterpret_cast< char * >(buf2);
18484   result = (char *)(arg1)->makeVarName(arg2);
18485   resultobj = SWIG_FromCharPtr((const char *)result);
18486   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18487   return resultobj;
18488 fail:
18489   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18490   return NULL;
18491 }
18492
18493
18494 SWIGINTERN PyObject *_wrap_EltBase_makeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18495   PyObject *resultobj = 0;
18496   int arg1 ;
18497   int arg2 ;
18498   char *arg3 = (char *) 0 ;
18499   char *result = 0 ;
18500   int val1 ;
18501   int ecode1 = 0 ;
18502   int val2 ;
18503   int ecode2 = 0 ;
18504   int res3 ;
18505   char *buf3 = 0 ;
18506   int alloc3 = 0 ;
18507   PyObject * obj0 = 0 ;
18508   PyObject * obj1 = 0 ;
18509   PyObject * obj2 = 0 ;
18510
18511   if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_makeName",&obj0,&obj1,&obj2)) SWIG_fail;
18512   ecode1 = SWIG_AsVal_int(obj0, &val1);
18513   if (!SWIG_IsOK(ecode1)) {
18514     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EltBase_makeName" "', argument " "1"" of type '" "int""'");
18515   }
18516   arg1 = static_cast< int >(val1);
18517   ecode2 = SWIG_AsVal_int(obj1, &val2);
18518   if (!SWIG_IsOK(ecode2)) {
18519     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_makeName" "', argument " "2"" of type '" "int""'");
18520   }
18521   arg2 = static_cast< int >(val2);
18522   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
18523   if (!SWIG_IsOK(res3)) {
18524     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_makeName" "', argument " "3"" of type '" "char *""'");
18525   }
18526   arg3 = reinterpret_cast< char * >(buf3);
18527   result = (char *)Hex::EltBase::makeName(arg1,arg2,arg3);
18528   resultobj = SWIG_FromCharPtr((const char *)result);
18529   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18530   return resultobj;
18531 fail:
18532   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18533   return NULL;
18534 }
18535
18536
18537 SWIGINTERN PyObject *_wrap_EltBase_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18538   PyObject *resultobj = 0;
18539   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18540   Hex::EltBase *result = 0 ;
18541   void *argp1 = 0 ;
18542   int res1 = 0 ;
18543   PyObject * obj0 = 0 ;
18544
18545   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_next",&obj0)) SWIG_fail;
18546   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18547   if (!SWIG_IsOK(res1)) {
18548     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_next" "', argument " "1"" of type '" "Hex::EltBase *""'");
18549   }
18550   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18551   result = (Hex::EltBase *)(arg1)->next();
18552   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18553   return resultobj;
18554 fail:
18555   return NULL;
18556 }
18557
18558
18559 SWIGINTERN PyObject *_wrap_EltBase_setNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18560   PyObject *resultobj = 0;
18561   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18562   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
18563   void *argp1 = 0 ;
18564   int res1 = 0 ;
18565   void *argp2 = 0 ;
18566   int res2 = 0 ;
18567   PyObject * obj0 = 0 ;
18568   PyObject * obj1 = 0 ;
18569
18570   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setNext",&obj0,&obj1)) SWIG_fail;
18571   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18572   if (!SWIG_IsOK(res1)) {
18573     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setNext" "', argument " "1"" of type '" "Hex::EltBase *""'");
18574   }
18575   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18576   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18577   if (!SWIG_IsOK(res2)) {
18578     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setNext" "', argument " "2"" of type '" "Hex::EltBase *""'");
18579   }
18580   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
18581   (arg1)->setNext(arg2);
18582   resultobj = SWIG_Py_Void();
18583   return resultobj;
18584 fail:
18585   return NULL;
18586 }
18587
18588
18589 SWIGINTERN PyObject *_wrap_EltBase_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18590   PyObject *resultobj = 0;
18591   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18592   int result;
18593   void *argp1 = 0 ;
18594   int res1 = 0 ;
18595   PyObject * obj0 = 0 ;
18596
18597   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getId",&obj0)) SWIG_fail;
18598   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18599   if (!SWIG_IsOK(res1)) {
18600     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getId" "', argument " "1"" of type '" "Hex::EltBase *""'");
18601   }
18602   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18603   result = (int)(arg1)->getId();
18604   resultobj = SWIG_From_int(static_cast< int >(result));
18605   return resultobj;
18606 fail:
18607   return NULL;
18608 }
18609
18610
18611 SWIGINTERN PyObject *_wrap_EltBase_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18612   PyObject *resultobj = 0;
18613   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18614   int arg2 ;
18615   void *argp1 = 0 ;
18616   int res1 = 0 ;
18617   int val2 ;
18618   int ecode2 = 0 ;
18619   PyObject * obj0 = 0 ;
18620   PyObject * obj1 = 0 ;
18621
18622   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setId",&obj0,&obj1)) SWIG_fail;
18623   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18624   if (!SWIG_IsOK(res1)) {
18625     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setId" "', argument " "1"" of type '" "Hex::EltBase *""'");
18626   }
18627   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18628   ecode2 = SWIG_AsVal_int(obj1, &val2);
18629   if (!SWIG_IsOK(ecode2)) {
18630     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setId" "', argument " "2"" of type '" "int""'");
18631   }
18632   arg2 = static_cast< int >(val2);
18633   (arg1)->setId(arg2);
18634   resultobj = SWIG_Py_Void();
18635   return resultobj;
18636 fail:
18637   return NULL;
18638 }
18639
18640
18641 SWIGINTERN PyObject *_wrap_EltBase_dad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18642   PyObject *resultobj = 0;
18643   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18644   Hex::Document *result = 0 ;
18645   void *argp1 = 0 ;
18646   int res1 = 0 ;
18647   PyObject * obj0 = 0 ;
18648
18649   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dad",&obj0)) SWIG_fail;
18650   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18651   if (!SWIG_IsOK(res1)) {
18652     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dad" "', argument " "1"" of type '" "Hex::EltBase *""'");
18653   }
18654   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18655   result = (Hex::Document *)(arg1)->dad();
18656   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
18657   return resultobj;
18658 fail:
18659   return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_EltBase_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664   PyObject *resultobj = 0;
18665   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18666   Hex::EnumElt result;
18667   void *argp1 = 0 ;
18668   int res1 = 0 ;
18669   PyObject * obj0 = 0 ;
18670
18671   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getType",&obj0)) SWIG_fail;
18672   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18673   if (!SWIG_IsOK(res1)) {
18674     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getType" "', argument " "1"" of type '" "Hex::EltBase *""'");
18675   }
18676   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18677   result = (Hex::EnumElt)(arg1)->getType();
18678   resultobj = SWIG_From_int(static_cast< int >(result));
18679   return resultobj;
18680 fail:
18681   return NULL;
18682 }
18683
18684
18685 SWIGINTERN PyObject *_wrap_EltBase_isHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18686   PyObject *resultobj = 0;
18687   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18688   bool result;
18689   void *argp1 = 0 ;
18690   int res1 = 0 ;
18691   PyObject * obj0 = 0 ;
18692
18693   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isHere",&obj0)) SWIG_fail;
18694   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18695   if (!SWIG_IsOK(res1)) {
18696     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isHere" "', argument " "1"" of type '" "Hex::EltBase *""'");
18697   }
18698   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18699   result = (bool)(arg1)->isHere();
18700   resultobj = SWIG_From_bool(static_cast< bool >(result));
18701   return resultobj;
18702 fail:
18703   return NULL;
18704 }
18705
18706
18707 SWIGINTERN PyObject *_wrap_EltBase_isDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18708   PyObject *resultobj = 0;
18709   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18710   bool result;
18711   void *argp1 = 0 ;
18712   int res1 = 0 ;
18713   PyObject * obj0 = 0 ;
18714
18715   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isDeleted",&obj0)) SWIG_fail;
18716   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18717   if (!SWIG_IsOK(res1)) {
18718     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isDeleted" "', argument " "1"" of type '" "Hex::EltBase *""'");
18719   }
18720   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18721   result = (bool)(arg1)->isDeleted();
18722   resultobj = SWIG_From_bool(static_cast< bool >(result));
18723   return resultobj;
18724 fail:
18725   return NULL;
18726 }
18727
18728
18729 SWIGINTERN PyObject *_wrap_EltBase_razReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18730   PyObject *resultobj = 0;
18731   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18732   void *argp1 = 0 ;
18733   int res1 = 0 ;
18734   PyObject * obj0 = 0 ;
18735
18736   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_razReferences",&obj0)) SWIG_fail;
18737   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18738   if (!SWIG_IsOK(res1)) {
18739     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_razReferences" "', argument " "1"" of type '" "Hex::EltBase *""'");
18740   }
18741   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18742   (arg1)->razReferences();
18743   resultobj = SWIG_Py_Void();
18744   return resultobj;
18745 fail:
18746   return NULL;
18747 }
18748
18749
18750 SWIGINTERN PyObject *_wrap_EltBase_addParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18751   PyObject *resultobj = 0;
18752   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18753   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
18754   void *argp1 = 0 ;
18755   int res1 = 0 ;
18756   void *argp2 = 0 ;
18757   int res2 = 0 ;
18758   PyObject * obj0 = 0 ;
18759   PyObject * obj1 = 0 ;
18760
18761   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_addParent",&obj0,&obj1)) SWIG_fail;
18762   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18763   if (!SWIG_IsOK(res1)) {
18764     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_addParent" "', argument " "1"" of type '" "Hex::EltBase *""'");
18765   }
18766   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18767   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18768   if (!SWIG_IsOK(res2)) {
18769     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_addParent" "', argument " "2"" of type '" "Hex::EltBase *""'");
18770   }
18771   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
18772   (arg1)->addParent(arg2);
18773   resultobj = SWIG_Py_Void();
18774   return resultobj;
18775 fail:
18776   return NULL;
18777 }
18778
18779
18780 SWIGINTERN PyObject *_wrap_EltBase_getNbrParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18781   PyObject *resultobj = 0;
18782   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18783   int result;
18784   void *argp1 = 0 ;
18785   int res1 = 0 ;
18786   PyObject * obj0 = 0 ;
18787
18788   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNbrParents",&obj0)) SWIG_fail;
18789   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18790   if (!SWIG_IsOK(res1)) {
18791     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getNbrParents" "', argument " "1"" of type '" "Hex::EltBase *""'");
18792   }
18793   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18794   result = (int)(arg1)->getNbrParents();
18795   resultobj = SWIG_From_int(static_cast< int >(result));
18796   return resultobj;
18797 fail:
18798   return NULL;
18799 }
18800
18801
18802 SWIGINTERN PyObject *_wrap_EltBase_hasParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18803   PyObject *resultobj = 0;
18804   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18805   bool result;
18806   void *argp1 = 0 ;
18807   int res1 = 0 ;
18808   PyObject * obj0 = 0 ;
18809
18810   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_hasParents",&obj0)) SWIG_fail;
18811   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18812   if (!SWIG_IsOK(res1)) {
18813     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_hasParents" "', argument " "1"" of type '" "Hex::EltBase *""'");
18814   }
18815   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18816   result = (bool)(arg1)->hasParents();
18817   resultobj = SWIG_From_bool(static_cast< bool >(result));
18818   return resultobj;
18819 fail:
18820   return NULL;
18821 }
18822
18823
18824 SWIGINTERN PyObject *_wrap_EltBase_getFather(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18825   PyObject *resultobj = 0;
18826   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18827   int arg2 ;
18828   Hex::EltBase *result = 0 ;
18829   void *argp1 = 0 ;
18830   int res1 = 0 ;
18831   int val2 ;
18832   int ecode2 = 0 ;
18833   PyObject * obj0 = 0 ;
18834   PyObject * obj1 = 0 ;
18835
18836   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getFather",&obj0,&obj1)) SWIG_fail;
18837   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18838   if (!SWIG_IsOK(res1)) {
18839     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getFather" "', argument " "1"" of type '" "Hex::EltBase *""'");
18840   }
18841   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18842   ecode2 = SWIG_AsVal_int(obj1, &val2);
18843   if (!SWIG_IsOK(ecode2)) {
18844     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_getFather" "', argument " "2"" of type '" "int""'");
18845   }
18846   arg2 = static_cast< int >(val2);
18847   result = (Hex::EltBase *)(arg1)->getFather(arg2);
18848   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18849   return resultobj;
18850 fail:
18851   return NULL;
18852 }
18853
18854
18855 SWIGINTERN PyObject *_wrap_EltBase_getMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18856   PyObject *resultobj = 0;
18857   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18858   int result;
18859   void *argp1 = 0 ;
18860   int res1 = 0 ;
18861   PyObject * obj0 = 0 ;
18862
18863   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getMark",&obj0)) SWIG_fail;
18864   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18865   if (!SWIG_IsOK(res1)) {
18866     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getMark" "', argument " "1"" of type '" "Hex::EltBase *""'");
18867   }
18868   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18869   result = (int)(arg1)->getMark();
18870   resultobj = SWIG_From_int(static_cast< int >(result));
18871   return resultobj;
18872 fail:
18873   return NULL;
18874 }
18875
18876
18877 SWIGINTERN PyObject *_wrap_EltBase_setMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18878   PyObject *resultobj = 0;
18879   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18880   int arg2 ;
18881   void *argp1 = 0 ;
18882   int res1 = 0 ;
18883   int val2 ;
18884   int ecode2 = 0 ;
18885   PyObject * obj0 = 0 ;
18886   PyObject * obj1 = 0 ;
18887
18888   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setMark",&obj0,&obj1)) SWIG_fail;
18889   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18890   if (!SWIG_IsOK(res1)) {
18891     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setMark" "', argument " "1"" of type '" "Hex::EltBase *""'");
18892   }
18893   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18894   ecode2 = SWIG_AsVal_int(obj1, &val2);
18895   if (!SWIG_IsOK(ecode2)) {
18896     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setMark" "', argument " "2"" of type '" "int""'");
18897   }
18898   arg2 = static_cast< int >(val2);
18899   (arg1)->setMark(arg2);
18900   resultobj = SWIG_Py_Void();
18901   return resultobj;
18902 fail:
18903   return NULL;
18904 }
18905
18906
18907 SWIGINTERN PyObject *_wrap_EltBase_getName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18908   PyObject *resultobj = 0;
18909   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18910   pchar arg2 = (pchar) 0 ;
18911   char *result = 0 ;
18912   void *argp1 = 0 ;
18913   int res1 = 0 ;
18914   int res2 ;
18915   char *buf2 = 0 ;
18916   int alloc2 = 0 ;
18917   PyObject * obj0 = 0 ;
18918   PyObject * obj1 = 0 ;
18919
18920   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getName",&obj0,&obj1)) 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_getName" "', argument " "1"" of type '" "Hex::EltBase *""'");
18924   }
18925   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18926   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
18927   if (!SWIG_IsOK(res2)) {
18928     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_getName" "', argument " "2"" of type '" "pchar""'");
18929   }
18930   arg2 = reinterpret_cast< pchar >(buf2);
18931   result = (char *)(arg1)->getName(arg2);
18932   resultobj = SWIG_FromCharPtr((const char *)result);
18933   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18934   return resultobj;
18935 fail:
18936   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18937   return NULL;
18938 }
18939
18940
18941 SWIGINTERN PyObject *_wrap_EltBase_printName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18942   PyObject *resultobj = 0;
18943   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18944   cpchar arg2 = (cpchar) 0 ;
18945   void *argp1 = 0 ;
18946   int res1 = 0 ;
18947   int res2 ;
18948   char *buf2 = 0 ;
18949   int alloc2 = 0 ;
18950   PyObject * obj0 = 0 ;
18951   PyObject * obj1 = 0 ;
18952
18953   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_printName",&obj0,&obj1)) SWIG_fail;
18954   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18955   if (!SWIG_IsOK(res1)) {
18956     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_printName" "', argument " "1"" of type '" "Hex::EltBase *""'");
18957   }
18958   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18959   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
18960   if (!SWIG_IsOK(res2)) {
18961     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_printName" "', argument " "2"" of type '" "cpchar""'");
18962   }
18963   arg2 = reinterpret_cast< cpchar >(buf2);
18964   (arg1)->printName(arg2);
18965   resultobj = SWIG_Py_Void();
18966   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18967   return resultobj;
18968 fail:
18969   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18970   return NULL;
18971 }
18972
18973
18974 SWIGINTERN PyObject *_wrap_EltBase_printName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18975   PyObject *resultobj = 0;
18976   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
18977   void *argp1 = 0 ;
18978   int res1 = 0 ;
18979   PyObject * obj0 = 0 ;
18980
18981   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_printName",&obj0)) SWIG_fail;
18982   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
18983   if (!SWIG_IsOK(res1)) {
18984     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_printName" "', argument " "1"" of type '" "Hex::EltBase *""'");
18985   }
18986   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
18987   (arg1)->printName();
18988   resultobj = SWIG_Py_Void();
18989   return resultobj;
18990 fail:
18991   return NULL;
18992 }
18993
18994
18995 SWIGINTERN PyObject *_wrap_EltBase_printName(PyObject *self, PyObject *args) {
18996   int argc;
18997   PyObject *argv[3];
18998   int ii;
18999
19000   if (!PyTuple_Check(args)) SWIG_fail;
19001   argc = PyObject_Length(args);
19002   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
19003     argv[ii] = PyTuple_GET_ITEM(args,ii);
19004   }
19005   if (argc == 1) {
19006     int _v;
19007     void *vptr = 0;
19008     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19009     _v = SWIG_CheckState(res);
19010     if (_v) {
19011       return _wrap_EltBase_printName__SWIG_1(self, args);
19012     }
19013   }
19014   if (argc == 2) {
19015     int _v;
19016     void *vptr = 0;
19017     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19018     _v = SWIG_CheckState(res);
19019     if (_v) {
19020       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19021       _v = SWIG_CheckState(res);
19022       if (_v) {
19023         return _wrap_EltBase_printName__SWIG_0(self, args);
19024       }
19025     }
19026   }
19027
19028 fail:
19029   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_printName'.\n  Possible C/C++ prototypes are:\n    printName(cpchar)\n    printName()\n");
19030   return NULL;
19031 }
19032
19033
19034 SWIGINTERN PyObject *_wrap_EltBase_dumpRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19035   PyObject *resultobj = 0;
19036   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19037   void *argp1 = 0 ;
19038   int res1 = 0 ;
19039   PyObject * obj0 = 0 ;
19040
19041   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dumpRef",&obj0)) SWIG_fail;
19042   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19043   if (!SWIG_IsOK(res1)) {
19044     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dumpRef" "', argument " "1"" of type '" "Hex::EltBase *""'");
19045   }
19046   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19047   (arg1)->dumpRef();
19048   resultobj = SWIG_Py_Void();
19049   return resultobj;
19050 fail:
19051   return NULL;
19052 }
19053
19054
19055 SWIGINTERN PyObject *_wrap_EltBase_getName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19056   PyObject *resultobj = 0;
19057   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19058   cpchar result;
19059   void *argp1 = 0 ;
19060   int res1 = 0 ;
19061   PyObject * obj0 = 0 ;
19062
19063   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getName",&obj0)) SWIG_fail;
19064   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19065   if (!SWIG_IsOK(res1)) {
19066     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getName" "', argument " "1"" of type '" "Hex::EltBase *""'");
19067   }
19068   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19069   result = (cpchar)(arg1)->getName();
19070   resultobj = SWIG_FromCharPtr((const char *)result);
19071   return resultobj;
19072 fail:
19073   return NULL;
19074 }
19075
19076
19077 SWIGINTERN PyObject *_wrap_EltBase_getName(PyObject *self, PyObject *args) {
19078   int argc;
19079   PyObject *argv[3];
19080   int ii;
19081
19082   if (!PyTuple_Check(args)) SWIG_fail;
19083   argc = PyObject_Length(args);
19084   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
19085     argv[ii] = PyTuple_GET_ITEM(args,ii);
19086   }
19087   if (argc == 1) {
19088     int _v;
19089     void *vptr = 0;
19090     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19091     _v = SWIG_CheckState(res);
19092     if (_v) {
19093       return _wrap_EltBase_getName__SWIG_1(self, args);
19094     }
19095   }
19096   if (argc == 2) {
19097     int _v;
19098     void *vptr = 0;
19099     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19100     _v = SWIG_CheckState(res);
19101     if (_v) {
19102       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19103       _v = SWIG_CheckState(res);
19104       if (_v) {
19105         return _wrap_EltBase_getName__SWIG_0(self, args);
19106       }
19107     }
19108   }
19109
19110 fail:
19111   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_getName'.\n  Possible C/C++ prototypes are:\n    getName(pchar)\n    getName()\n");
19112   return NULL;
19113 }
19114
19115
19116 SWIGINTERN PyObject *_wrap_EltBase_setName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19117   PyObject *resultobj = 0;
19118   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19119   string *arg2 = 0 ;
19120   void *argp1 = 0 ;
19121   int res1 = 0 ;
19122   void *argp2 = 0 ;
19123   int res2 = 0 ;
19124   PyObject * obj0 = 0 ;
19125   PyObject * obj1 = 0 ;
19126
19127   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setName",&obj0,&obj1)) SWIG_fail;
19128   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19129   if (!SWIG_IsOK(res1)) {
19130     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setName" "', argument " "1"" of type '" "Hex::EltBase *""'");
19131   }
19132   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19133   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string,  0  | 0);
19134   if (!SWIG_IsOK(res2)) {
19135     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setName" "', argument " "2"" of type '" "string const &""'");
19136   }
19137   if (!argp2) {
19138     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EltBase_setName" "', argument " "2"" of type '" "string const &""'");
19139   }
19140   arg2 = reinterpret_cast< string * >(argp2);
19141   (arg1)->setName((string const &)*arg2);
19142   resultobj = SWIG_Py_Void();
19143   return resultobj;
19144 fail:
19145   return NULL;
19146 }
19147
19148
19149 SWIGINTERN PyObject *_wrap_EltBase_setName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19150   PyObject *resultobj = 0;
19151   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19152   cpchar arg2 = (cpchar) 0 ;
19153   void *argp1 = 0 ;
19154   int res1 = 0 ;
19155   int res2 ;
19156   char *buf2 = 0 ;
19157   int alloc2 = 0 ;
19158   PyObject * obj0 = 0 ;
19159   PyObject * obj1 = 0 ;
19160
19161   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setName",&obj0,&obj1)) SWIG_fail;
19162   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19163   if (!SWIG_IsOK(res1)) {
19164     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setName" "', argument " "1"" of type '" "Hex::EltBase *""'");
19165   }
19166   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19167   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
19168   if (!SWIG_IsOK(res2)) {
19169     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setName" "', argument " "2"" of type '" "cpchar""'");
19170   }
19171   arg2 = reinterpret_cast< cpchar >(buf2);
19172   (arg1)->setName(arg2);
19173   resultobj = SWIG_Py_Void();
19174   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19175   return resultobj;
19176 fail:
19177   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19178   return NULL;
19179 }
19180
19181
19182 SWIGINTERN PyObject *_wrap_EltBase_setName(PyObject *self, PyObject *args) {
19183   int argc;
19184   PyObject *argv[3];
19185   int ii;
19186
19187   if (!PyTuple_Check(args)) SWIG_fail;
19188   argc = PyObject_Length(args);
19189   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
19190     argv[ii] = PyTuple_GET_ITEM(args,ii);
19191   }
19192   if (argc == 2) {
19193     int _v;
19194     void *vptr = 0;
19195     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19196     _v = SWIG_CheckState(res);
19197     if (_v) {
19198       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_string, 0);
19199       _v = SWIG_CheckState(res);
19200       if (_v) {
19201         return _wrap_EltBase_setName__SWIG_0(self, args);
19202       }
19203     }
19204   }
19205   if (argc == 2) {
19206     int _v;
19207     void *vptr = 0;
19208     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19209     _v = SWIG_CheckState(res);
19210     if (_v) {
19211       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
19212       _v = SWIG_CheckState(res);
19213       if (_v) {
19214         return _wrap_EltBase_setName__SWIG_1(self, args);
19215       }
19216     }
19217   }
19218
19219 fail:
19220   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_setName'.\n  Possible C/C++ prototypes are:\n    setName(string const &)\n    setName(cpchar)\n");
19221   return NULL;
19222 }
19223
19224
19225 SWIGINTERN PyObject *_wrap_EltBase_debug__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19226   PyObject *resultobj = 0;
19227   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19228   int arg2 ;
19229   bool result;
19230   void *argp1 = 0 ;
19231   int res1 = 0 ;
19232   int val2 ;
19233   int ecode2 = 0 ;
19234   PyObject * obj0 = 0 ;
19235   PyObject * obj1 = 0 ;
19236
19237   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_debug",&obj0,&obj1)) SWIG_fail;
19238   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19239   if (!SWIG_IsOK(res1)) {
19240     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_debug" "', argument " "1"" of type '" "Hex::EltBase *""'");
19241   }
19242   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19243   ecode2 = SWIG_AsVal_int(obj1, &val2);
19244   if (!SWIG_IsOK(ecode2)) {
19245     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_debug" "', argument " "2"" of type '" "int""'");
19246   }
19247   arg2 = static_cast< int >(val2);
19248   result = (bool)(arg1)->debug(arg2);
19249   resultobj = SWIG_From_bool(static_cast< bool >(result));
19250   return resultobj;
19251 fail:
19252   return NULL;
19253 }
19254
19255
19256 SWIGINTERN PyObject *_wrap_EltBase_debug__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19257   PyObject *resultobj = 0;
19258   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19259   bool result;
19260   void *argp1 = 0 ;
19261   int res1 = 0 ;
19262   PyObject * obj0 = 0 ;
19263
19264   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_debug",&obj0)) SWIG_fail;
19265   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19266   if (!SWIG_IsOK(res1)) {
19267     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_debug" "', argument " "1"" of type '" "Hex::EltBase *""'");
19268   }
19269   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19270   result = (bool)(arg1)->debug();
19271   resultobj = SWIG_From_bool(static_cast< bool >(result));
19272   return resultobj;
19273 fail:
19274   return NULL;
19275 }
19276
19277
19278 SWIGINTERN PyObject *_wrap_EltBase_debug(PyObject *self, PyObject *args) {
19279   int argc;
19280   PyObject *argv[3];
19281   int ii;
19282
19283   if (!PyTuple_Check(args)) SWIG_fail;
19284   argc = PyObject_Length(args);
19285   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
19286     argv[ii] = PyTuple_GET_ITEM(args,ii);
19287   }
19288   if (argc == 1) {
19289     int _v;
19290     void *vptr = 0;
19291     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19292     _v = SWIG_CheckState(res);
19293     if (_v) {
19294       return _wrap_EltBase_debug__SWIG_1(self, args);
19295     }
19296   }
19297   if (argc == 2) {
19298     int _v;
19299     void *vptr = 0;
19300     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
19301     _v = SWIG_CheckState(res);
19302     if (_v) {
19303       {
19304         int res = SWIG_AsVal_int(argv[1], NULL);
19305         _v = SWIG_CheckState(res);
19306       }
19307       if (_v) {
19308         return _wrap_EltBase_debug__SWIG_0(self, args);
19309       }
19310     }
19311   }
19312
19313 fail:
19314   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EltBase_debug'.\n  Possible C/C++ prototypes are:\n    debug(int)\n    debug()\n");
19315   return NULL;
19316 }
19317
19318
19319 SWIGINTERN PyObject *_wrap_EltBase_isAssociated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19320   PyObject *resultobj = 0;
19321   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19322   bool result;
19323   void *argp1 = 0 ;
19324   int res1 = 0 ;
19325   PyObject * obj0 = 0 ;
19326
19327   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isAssociated",&obj0)) SWIG_fail;
19328   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19329   if (!SWIG_IsOK(res1)) {
19330     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isAssociated" "', argument " "1"" of type '" "Hex::EltBase *""'");
19331   }
19332   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19333   result = (bool)(arg1)->isAssociated();
19334   resultobj = SWIG_From_bool(static_cast< bool >(result));
19335   return resultobj;
19336 fail:
19337   return NULL;
19338 }
19339
19340
19341 SWIGINTERN PyObject *_wrap_EltBase_getNextName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19342   PyObject *resultobj = 0;
19343   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
19344   string result;
19345   void *argp1 = 0 ;
19346   int res1 = 0 ;
19347   PyObject * obj0 = 0 ;
19348
19349   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNextName",&obj0)) SWIG_fail;
19350   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
19351   if (!SWIG_IsOK(res1)) {
19352     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getNextName" "', argument " "1"" of type '" "Hex::EltBase *""'");
19353   }
19354   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
19355   result = (arg1)->getNextName();
19356   resultobj = SWIG_NewPointerObj((new string(static_cast< const string& >(result))), SWIGTYPE_p_string, SWIG_POINTER_OWN |  0 );
19357   return resultobj;
19358 fail:
19359   return NULL;
19360 }
19361
19362
19363 SWIGINTERN PyObject *EltBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19364   PyObject *obj;
19365   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
19366   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__EltBase, SWIG_NewClientData(obj));
19367   return SWIG_Py_Void();
19368 }
19369
19370 SWIGINTERN PyObject *_wrap_Vertex_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19371   PyObject *resultobj = 0;
19372   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19373   double result;
19374   void *argp1 = 0 ;
19375   int res1 = 0 ;
19376   PyObject * obj0 = 0 ;
19377
19378   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getX",&obj0)) SWIG_fail;
19379   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19380   if (!SWIG_IsOK(res1)) {
19381     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getX" "', argument " "1"" of type '" "Hex::Vertex *""'");
19382   }
19383   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19384   result = (double)(arg1)->getX();
19385   resultobj = SWIG_From_double(static_cast< double >(result));
19386   return resultobj;
19387 fail:
19388   return NULL;
19389 }
19390
19391
19392 SWIGINTERN PyObject *_wrap_Vertex_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19393   PyObject *resultobj = 0;
19394   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19395   double result;
19396   void *argp1 = 0 ;
19397   int res1 = 0 ;
19398   PyObject * obj0 = 0 ;
19399
19400   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getY",&obj0)) SWIG_fail;
19401   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19402   if (!SWIG_IsOK(res1)) {
19403     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getY" "', argument " "1"" of type '" "Hex::Vertex *""'");
19404   }
19405   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19406   result = (double)(arg1)->getY();
19407   resultobj = SWIG_From_double(static_cast< double >(result));
19408   return resultobj;
19409 fail:
19410   return NULL;
19411 }
19412
19413
19414 SWIGINTERN PyObject *_wrap_Vertex_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19415   PyObject *resultobj = 0;
19416   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19417   double result;
19418   void *argp1 = 0 ;
19419   int res1 = 0 ;
19420   PyObject * obj0 = 0 ;
19421
19422   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getZ",&obj0)) SWIG_fail;
19423   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19424   if (!SWIG_IsOK(res1)) {
19425     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
19426   }
19427   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19428   result = (double)(arg1)->getZ();
19429   resultobj = SWIG_From_double(static_cast< double >(result));
19430   return resultobj;
19431 fail:
19432   return NULL;
19433 }
19434
19435
19436 SWIGINTERN PyObject *_wrap_Vertex_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19437   PyObject *resultobj = 0;
19438   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19439   double arg2 ;
19440   void *argp1 = 0 ;
19441   int res1 = 0 ;
19442   double val2 ;
19443   int ecode2 = 0 ;
19444   PyObject * obj0 = 0 ;
19445   PyObject * obj1 = 0 ;
19446
19447   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setX",&obj0,&obj1)) SWIG_fail;
19448   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19449   if (!SWIG_IsOK(res1)) {
19450     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setX" "', argument " "1"" of type '" "Hex::Vertex *""'");
19451   }
19452   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19453   ecode2 = SWIG_AsVal_double(obj1, &val2);
19454   if (!SWIG_IsOK(ecode2)) {
19455     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setX" "', argument " "2"" of type '" "double""'");
19456   }
19457   arg2 = static_cast< double >(val2);
19458   (arg1)->setX(arg2);
19459   resultobj = SWIG_Py_Void();
19460   return resultobj;
19461 fail:
19462   return NULL;
19463 }
19464
19465
19466 SWIGINTERN PyObject *_wrap_Vertex_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19467   PyObject *resultobj = 0;
19468   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19469   double arg2 ;
19470   void *argp1 = 0 ;
19471   int res1 = 0 ;
19472   double val2 ;
19473   int ecode2 = 0 ;
19474   PyObject * obj0 = 0 ;
19475   PyObject * obj1 = 0 ;
19476
19477   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setY",&obj0,&obj1)) SWIG_fail;
19478   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19479   if (!SWIG_IsOK(res1)) {
19480     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setY" "', argument " "1"" of type '" "Hex::Vertex *""'");
19481   }
19482   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19483   ecode2 = SWIG_AsVal_double(obj1, &val2);
19484   if (!SWIG_IsOK(ecode2)) {
19485     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setY" "', argument " "2"" of type '" "double""'");
19486   }
19487   arg2 = static_cast< double >(val2);
19488   (arg1)->setY(arg2);
19489   resultobj = SWIG_Py_Void();
19490   return resultobj;
19491 fail:
19492   return NULL;
19493 }
19494
19495
19496 SWIGINTERN PyObject *_wrap_Vertex_setZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19497   PyObject *resultobj = 0;
19498   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19499   double arg2 ;
19500   void *argp1 = 0 ;
19501   int res1 = 0 ;
19502   double val2 ;
19503   int ecode2 = 0 ;
19504   PyObject * obj0 = 0 ;
19505   PyObject * obj1 = 0 ;
19506
19507   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setZ",&obj0,&obj1)) SWIG_fail;
19508   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19509   if (!SWIG_IsOK(res1)) {
19510     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
19511   }
19512   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19513   ecode2 = SWIG_AsVal_double(obj1, &val2);
19514   if (!SWIG_IsOK(ecode2)) {
19515     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setZ" "', argument " "2"" of type '" "double""'");
19516   }
19517   arg2 = static_cast< double >(val2);
19518   (arg1)->setZ(arg2);
19519   resultobj = SWIG_Py_Void();
19520   return resultobj;
19521 fail:
19522   return NULL;
19523 }
19524
19525
19526 SWIGINTERN PyObject *_wrap_Vertex_getAssoX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19527   PyObject *resultobj = 0;
19528   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19529   double result;
19530   void *argp1 = 0 ;
19531   int res1 = 0 ;
19532   PyObject * obj0 = 0 ;
19533
19534   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoX",&obj0)) SWIG_fail;
19535   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19536   if (!SWIG_IsOK(res1)) {
19537     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoX" "', argument " "1"" of type '" "Hex::Vertex *""'");
19538   }
19539   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19540   result = (double)(arg1)->getAssoX();
19541   resultobj = SWIG_From_double(static_cast< double >(result));
19542   return resultobj;
19543 fail:
19544   return NULL;
19545 }
19546
19547
19548 SWIGINTERN PyObject *_wrap_Vertex_getAssoY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19549   PyObject *resultobj = 0;
19550   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19551   double result;
19552   void *argp1 = 0 ;
19553   int res1 = 0 ;
19554   PyObject * obj0 = 0 ;
19555
19556   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoY",&obj0)) SWIG_fail;
19557   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19558   if (!SWIG_IsOK(res1)) {
19559     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoY" "', argument " "1"" of type '" "Hex::Vertex *""'");
19560   }
19561   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19562   result = (double)(arg1)->getAssoY();
19563   resultobj = SWIG_From_double(static_cast< double >(result));
19564   return resultobj;
19565 fail:
19566   return NULL;
19567 }
19568
19569
19570 SWIGINTERN PyObject *_wrap_Vertex_getAssoZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19571   PyObject *resultobj = 0;
19572   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19573   double result;
19574   void *argp1 = 0 ;
19575   int res1 = 0 ;
19576   PyObject * obj0 = 0 ;
19577
19578   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoZ",&obj0)) SWIG_fail;
19579   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19580   if (!SWIG_IsOK(res1)) {
19581     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
19582   }
19583   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19584   result = (double)(arg1)->getAssoZ();
19585   resultobj = SWIG_From_double(static_cast< double >(result));
19586   return resultobj;
19587 fail:
19588   return NULL;
19589 }
19590
19591
19592 SWIGINTERN PyObject *_wrap_Vertex_setAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19593   PyObject *resultobj = 0;
19594   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19595   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
19596   int arg3 ;
19597   int result;
19598   void *argp1 = 0 ;
19599   int res1 = 0 ;
19600   void *argp2 = 0 ;
19601   int res2 = 0 ;
19602   int val3 ;
19603   int ecode3 = 0 ;
19604   PyObject * obj0 = 0 ;
19605   PyObject * obj1 = 0 ;
19606   PyObject * obj2 = 0 ;
19607
19608   if (!PyArg_ParseTuple(args,(char *)"OOO:Vertex_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
19609   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19610   if (!SWIG_IsOK(res1)) {
19611     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setAssociation" "', argument " "1"" of type '" "Hex::Vertex *""'");
19612   }
19613   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19614   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
19615   if (!SWIG_IsOK(res2)) {
19616     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vertex_setAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
19617   }
19618   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
19619   ecode3 = SWIG_AsVal_int(obj2, &val3);
19620   if (!SWIG_IsOK(ecode3)) {
19621     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vertex_setAssociation" "', argument " "3"" of type '" "int""'");
19622   }
19623   arg3 = static_cast< int >(val3);
19624   result = (int)(arg1)->setAssociation(arg2,arg3);
19625   resultobj = SWIG_From_int(static_cast< int >(result));
19626   return resultobj;
19627 fail:
19628   return NULL;
19629 }
19630
19631
19632 SWIGINTERN PyObject *_wrap_Vertex_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19633   PyObject *resultobj = 0;
19634   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19635   void *argp1 = 0 ;
19636   int res1 = 0 ;
19637   PyObject * obj0 = 0 ;
19638
19639   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_clearAssociation",&obj0)) SWIG_fail;
19640   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19641   if (!SWIG_IsOK(res1)) {
19642     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_clearAssociation" "', argument " "1"" of type '" "Hex::Vertex *""'");
19643   }
19644   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19645   (arg1)->clearAssociation();
19646   resultobj = SWIG_Py_Void();
19647   return resultobj;
19648 fail:
19649   return NULL;
19650 }
19651
19652
19653 SWIGINTERN PyObject *_wrap_Vertex_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19654   PyObject *resultobj = 0;
19655   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19656   double arg2 ;
19657   void *argp1 = 0 ;
19658   int res1 = 0 ;
19659   double val2 ;
19660   int ecode2 = 0 ;
19661   PyObject * obj0 = 0 ;
19662   PyObject * obj1 = 0 ;
19663
19664   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setColor",&obj0,&obj1)) SWIG_fail;
19665   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19666   if (!SWIG_IsOK(res1)) {
19667     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setColor" "', argument " "1"" of type '" "Hex::Vertex *""'");
19668   }
19669   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19670   ecode2 = SWIG_AsVal_double(obj1, &val2);
19671   if (!SWIG_IsOK(ecode2)) {
19672     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setColor" "', argument " "2"" of type '" "double""'");
19673   }
19674   arg2 = static_cast< double >(val2);
19675   (arg1)->setColor(arg2);
19676   resultobj = SWIG_Py_Void();
19677   return resultobj;
19678 fail:
19679   return NULL;
19680 }
19681
19682
19683 SWIGINTERN PyObject *_wrap_new_Vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19684   PyObject *resultobj = 0;
19685   Hex::Document *arg1 = (Hex::Document *) 0 ;
19686   double arg2 ;
19687   double arg3 ;
19688   double arg4 ;
19689   Hex::Vertex *result = 0 ;
19690   void *argp1 = 0 ;
19691   int res1 = 0 ;
19692   double val2 ;
19693   int ecode2 = 0 ;
19694   double val3 ;
19695   int ecode3 = 0 ;
19696   double val4 ;
19697   int ecode4 = 0 ;
19698   PyObject * obj0 = 0 ;
19699   PyObject * obj1 = 0 ;
19700   PyObject * obj2 = 0 ;
19701   PyObject * obj3 = 0 ;
19702
19703   if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19704   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
19705   if (!SWIG_IsOK(res1)) {
19706     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vertex" "', argument " "1"" of type '" "Hex::Document *""'");
19707   }
19708   arg1 = reinterpret_cast< Hex::Document * >(argp1);
19709   ecode2 = SWIG_AsVal_double(obj1, &val2);
19710   if (!SWIG_IsOK(ecode2)) {
19711     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vertex" "', argument " "2"" of type '" "double""'");
19712   }
19713   arg2 = static_cast< double >(val2);
19714   ecode3 = SWIG_AsVal_double(obj2, &val3);
19715   if (!SWIG_IsOK(ecode3)) {
19716     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vertex" "', argument " "3"" of type '" "double""'");
19717   }
19718   arg3 = static_cast< double >(val3);
19719   ecode4 = SWIG_AsVal_double(obj3, &val4);
19720   if (!SWIG_IsOK(ecode4)) {
19721     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vertex" "', argument " "4"" of type '" "double""'");
19722   }
19723   arg4 = static_cast< double >(val4);
19724   result = (Hex::Vertex *)new Hex::Vertex(arg1,arg2,arg3,arg4);
19725   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, SWIG_POINTER_NEW |  0 );
19726   return resultobj;
19727 fail:
19728   return NULL;
19729 }
19730
19731
19732 SWIGINTERN PyObject *_wrap_delete_Vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19733   PyObject *resultobj = 0;
19734   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
19735   void *argp1 = 0 ;
19736   int res1 = 0 ;
19737   PyObject * obj0 = 0 ;
19738
19739   if (!PyArg_ParseTuple(args,(char *)"O:delete_Vertex",&obj0)) SWIG_fail;
19740   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, SWIG_POINTER_DISOWN |  0 );
19741   if (!SWIG_IsOK(res1)) {
19742     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vertex" "', argument " "1"" of type '" "Hex::Vertex *""'");
19743   }
19744   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
19745   delete arg1;
19746
19747   resultobj = SWIG_Py_Void();
19748   return resultobj;
19749 fail:
19750   return NULL;
19751 }
19752
19753
19754 SWIGINTERN PyObject *Vertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19755   PyObject *obj;
19756   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
19757   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vertex, SWIG_NewClientData(obj));
19758   return SWIG_Py_Void();
19759 }
19760
19761 SWIGINTERN PyObject *_wrap_Edge_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19762   PyObject *resultobj = 0;
19763   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19764   int arg2 ;
19765   Hex::Vertex *result = 0 ;
19766   void *argp1 = 0 ;
19767   int res1 = 0 ;
19768   int val2 ;
19769   int ecode2 = 0 ;
19770   PyObject * obj0 = 0 ;
19771   PyObject * obj1 = 0 ;
19772
19773   if (!PyArg_ParseTuple(args,(char *)"OO:Edge_getVertex",&obj0,&obj1)) SWIG_fail;
19774   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
19775   if (!SWIG_IsOK(res1)) {
19776     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getVertex" "', argument " "1"" of type '" "Hex::Edge *""'");
19777   }
19778   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19779   ecode2 = SWIG_AsVal_int(obj1, &val2);
19780   if (!SWIG_IsOK(ecode2)) {
19781     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Edge_getVertex" "', argument " "2"" of type '" "int""'");
19782   }
19783   arg2 = static_cast< int >(val2);
19784   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
19785   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
19786   return resultobj;
19787 fail:
19788   return NULL;
19789 }
19790
19791
19792 SWIGINTERN PyObject *_wrap_Edge_addAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19793   PyObject *resultobj = 0;
19794   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19795   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
19796   int arg3 ;
19797   double arg4 ;
19798   double arg5 ;
19799   int result;
19800   void *argp1 = 0 ;
19801   int res1 = 0 ;
19802   void *argp2 = 0 ;
19803   int res2 = 0 ;
19804   int val3 ;
19805   int ecode3 = 0 ;
19806   double val4 ;
19807   int ecode4 = 0 ;
19808   double val5 ;
19809   int ecode5 = 0 ;
19810   PyObject * obj0 = 0 ;
19811   PyObject * obj1 = 0 ;
19812   PyObject * obj2 = 0 ;
19813   PyObject * obj3 = 0 ;
19814   PyObject * obj4 = 0 ;
19815
19816   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Edge_addAssociation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19817   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
19818   if (!SWIG_IsOK(res1)) {
19819     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_addAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
19820   }
19821   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19822   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
19823   if (!SWIG_IsOK(res2)) {
19824     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_addAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
19825   }
19826   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
19827   ecode3 = SWIG_AsVal_int(obj2, &val3);
19828   if (!SWIG_IsOK(ecode3)) {
19829     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Edge_addAssociation" "', argument " "3"" of type '" "int""'");
19830   }
19831   arg3 = static_cast< int >(val3);
19832   ecode4 = SWIG_AsVal_double(obj3, &val4);
19833   if (!SWIG_IsOK(ecode4)) {
19834     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Edge_addAssociation" "', argument " "4"" of type '" "double""'");
19835   }
19836   arg4 = static_cast< double >(val4);
19837   ecode5 = SWIG_AsVal_double(obj4, &val5);
19838   if (!SWIG_IsOK(ecode5)) {
19839     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Edge_addAssociation" "', argument " "5"" of type '" "double""'");
19840   }
19841   arg5 = static_cast< double >(val5);
19842   result = (int)(arg1)->addAssociation(arg2,arg3,arg4,arg5);
19843   resultobj = SWIG_From_int(static_cast< int >(result));
19844   return resultobj;
19845 fail:
19846   return NULL;
19847 }
19848
19849
19850 SWIGINTERN PyObject *_wrap_Edge_setAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19851   PyObject *resultobj = 0;
19852   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19853   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
19854   int arg3 ;
19855   int result;
19856   void *argp1 = 0 ;
19857   int res1 = 0 ;
19858   void *argp2 = 0 ;
19859   int res2 = 0 ;
19860   int val3 ;
19861   int ecode3 = 0 ;
19862   PyObject * obj0 = 0 ;
19863   PyObject * obj1 = 0 ;
19864   PyObject * obj2 = 0 ;
19865
19866   if (!PyArg_ParseTuple(args,(char *)"OOO:Edge_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
19867   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
19868   if (!SWIG_IsOK(res1)) {
19869     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_setAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
19870   }
19871   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19872   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
19873   if (!SWIG_IsOK(res2)) {
19874     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_setAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
19875   }
19876   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
19877   ecode3 = SWIG_AsVal_int(obj2, &val3);
19878   if (!SWIG_IsOK(ecode3)) {
19879     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Edge_setAssociation" "', argument " "3"" of type '" "int""'");
19880   }
19881   arg3 = static_cast< int >(val3);
19882   result = (int)(arg1)->setAssociation(arg2,arg3);
19883   resultobj = SWIG_From_int(static_cast< int >(result));
19884   return resultobj;
19885 fail:
19886   return NULL;
19887 }
19888
19889
19890 SWIGINTERN PyObject *_wrap_Edge_findAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19891   PyObject *resultobj = 0;
19892   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19893   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
19894   int result;
19895   void *argp1 = 0 ;
19896   int res1 = 0 ;
19897   void *argp2 = 0 ;
19898   int res2 = 0 ;
19899   PyObject * obj0 = 0 ;
19900   PyObject * obj1 = 0 ;
19901
19902   if (!PyArg_ParseTuple(args,(char *)"OO:Edge_findAssociation",&obj0,&obj1)) SWIG_fail;
19903   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
19904   if (!SWIG_IsOK(res1)) {
19905     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_findAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
19906   }
19907   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19908   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
19909   if (!SWIG_IsOK(res2)) {
19910     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_findAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
19911   }
19912   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
19913   result = (int)(arg1)->findAssociation(arg2);
19914   resultobj = SWIG_From_int(static_cast< int >(result));
19915   return resultobj;
19916 fail:
19917   return NULL;
19918 }
19919
19920
19921 SWIGINTERN PyObject *_wrap_Edge_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19922   PyObject *resultobj = 0;
19923   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19924   void *argp1 = 0 ;
19925   int res1 = 0 ;
19926   PyObject * obj0 = 0 ;
19927
19928   if (!PyArg_ParseTuple(args,(char *)"O:Edge_clearAssociation",&obj0)) SWIG_fail;
19929   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
19930   if (!SWIG_IsOK(res1)) {
19931     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_clearAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
19932   }
19933   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19934   (arg1)->clearAssociation();
19935   resultobj = SWIG_Py_Void();
19936   return resultobj;
19937 fail:
19938   return NULL;
19939 }
19940
19941
19942 SWIGINTERN PyObject *_wrap_Edge_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19943   PyObject *resultobj = 0;
19944   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19945   double arg2 ;
19946   void *argp1 = 0 ;
19947   int res1 = 0 ;
19948   double val2 ;
19949   int ecode2 = 0 ;
19950   PyObject * obj0 = 0 ;
19951   PyObject * obj1 = 0 ;
19952
19953   if (!PyArg_ParseTuple(args,(char *)"OO:Edge_setColor",&obj0,&obj1)) SWIG_fail;
19954   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
19955   if (!SWIG_IsOK(res1)) {
19956     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_setColor" "', argument " "1"" of type '" "Hex::Edge *""'");
19957   }
19958   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19959   ecode2 = SWIG_AsVal_double(obj1, &val2);
19960   if (!SWIG_IsOK(ecode2)) {
19961     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Edge_setColor" "', argument " "2"" of type '" "double""'");
19962   }
19963   arg2 = static_cast< double >(val2);
19964   (arg1)->setColor(arg2);
19965   resultobj = SWIG_Py_Void();
19966   return resultobj;
19967 fail:
19968   return NULL;
19969 }
19970
19971
19972 SWIGINTERN PyObject *_wrap_Edge_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19973   PyObject *resultobj = 0;
19974   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19975   bool result;
19976   void *argp1 = 0 ;
19977   int res1 = 0 ;
19978   PyObject * obj0 = 0 ;
19979
19980   if (!PyArg_ParseTuple(args,(char *)"O:Edge_getWay",&obj0)) SWIG_fail;
19981   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
19982   if (!SWIG_IsOK(res1)) {
19983     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getWay" "', argument " "1"" of type '" "Hex::Edge *""'");
19984   }
19985   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
19986   result = (bool)(arg1)->getWay();
19987   resultobj = SWIG_From_bool(static_cast< bool >(result));
19988   return resultobj;
19989 fail:
19990   return NULL;
19991 }
19992
19993
19994 SWIGINTERN PyObject *_wrap_Edge_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19995   PyObject *resultobj = 0;
19996   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
19997   double result;
19998   void *argp1 = 0 ;
19999   int res1 = 0 ;
20000   PyObject * obj0 = 0 ;
20001
20002   if (!PyArg_ParseTuple(args,(char *)"O:Edge_getLength",&obj0)) SWIG_fail;
20003   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
20004   if (!SWIG_IsOK(res1)) {
20005     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getLength" "', argument " "1"" of type '" "Hex::Edge *""'");
20006   }
20007   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
20008   result = (double)(arg1)->getLength();
20009   resultobj = SWIG_From_double(static_cast< double >(result));
20010   return resultobj;
20011 fail:
20012   return NULL;
20013 }
20014
20015
20016 SWIGINTERN PyObject *_wrap_new_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20017   PyObject *resultobj = 0;
20018   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20019   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
20020   Hex::Edge *result = 0 ;
20021   void *argp1 = 0 ;
20022   int res1 = 0 ;
20023   void *argp2 = 0 ;
20024   int res2 = 0 ;
20025   PyObject * obj0 = 0 ;
20026   PyObject * obj1 = 0 ;
20027
20028   if (!PyArg_ParseTuple(args,(char *)"OO:new_Edge",&obj0,&obj1)) SWIG_fail;
20029   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20030   if (!SWIG_IsOK(res1)) {
20031     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Edge" "', argument " "1"" of type '" "Hex::Vertex *""'");
20032   }
20033   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20034   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20035   if (!SWIG_IsOK(res2)) {
20036     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Edge" "', argument " "2"" of type '" "Hex::Vertex *""'");
20037   }
20038   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
20039   result = (Hex::Edge *)new Hex::Edge(arg1,arg2);
20040   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, SWIG_POINTER_NEW |  0 );
20041   return resultobj;
20042 fail:
20043   return NULL;
20044 }
20045
20046
20047 SWIGINTERN PyObject *_wrap_delete_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20048   PyObject *resultobj = 0;
20049   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
20050   void *argp1 = 0 ;
20051   int res1 = 0 ;
20052   PyObject * obj0 = 0 ;
20053
20054   if (!PyArg_ParseTuple(args,(char *)"O:delete_Edge",&obj0)) SWIG_fail;
20055   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, SWIG_POINTER_DISOWN |  0 );
20056   if (!SWIG_IsOK(res1)) {
20057     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Edge" "', argument " "1"" of type '" "Hex::Edge *""'");
20058   }
20059   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
20060   delete arg1;
20061
20062   resultobj = SWIG_Py_Void();
20063   return resultobj;
20064 fail:
20065   return NULL;
20066 }
20067
20068
20069 SWIGINTERN PyObject *Edge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20070   PyObject *obj;
20071   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
20072   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Edge, SWIG_NewClientData(obj));
20073   return SWIG_Py_Void();
20074 }
20075
20076 SWIGINTERN PyObject *_wrap_Quad_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20077   PyObject *resultobj = 0;
20078   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20079   int arg2 ;
20080   Hex::Edge *result = 0 ;
20081   void *argp1 = 0 ;
20082   int res1 = 0 ;
20083   int val2 ;
20084   int ecode2 = 0 ;
20085   PyObject * obj0 = 0 ;
20086   PyObject * obj1 = 0 ;
20087
20088   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getEdge",&obj0,&obj1)) SWIG_fail;
20089   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20090   if (!SWIG_IsOK(res1)) {
20091     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getEdge" "', argument " "1"" of type '" "Hex::Quad *""'");
20092   }
20093   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20094   ecode2 = SWIG_AsVal_int(obj1, &val2);
20095   if (!SWIG_IsOK(ecode2)) {
20096     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_getEdge" "', argument " "2"" of type '" "int""'");
20097   }
20098   arg2 = static_cast< int >(val2);
20099   result = (Hex::Edge *)(arg1)->getEdge(arg2);
20100   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
20101   return resultobj;
20102 fail:
20103   return NULL;
20104 }
20105
20106
20107 SWIGINTERN PyObject *_wrap_Quad_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20108   PyObject *resultobj = 0;
20109   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20110   int arg2 ;
20111   Hex::Vertex *result = 0 ;
20112   void *argp1 = 0 ;
20113   int res1 = 0 ;
20114   int val2 ;
20115   int ecode2 = 0 ;
20116   PyObject * obj0 = 0 ;
20117   PyObject * obj1 = 0 ;
20118
20119   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getVertex",&obj0,&obj1)) SWIG_fail;
20120   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20121   if (!SWIG_IsOK(res1)) {
20122     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getVertex" "', argument " "1"" of type '" "Hex::Quad *""'");
20123   }
20124   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20125   ecode2 = SWIG_AsVal_int(obj1, &val2);
20126   if (!SWIG_IsOK(ecode2)) {
20127     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_getVertex" "', argument " "2"" of type '" "int""'");
20128   }
20129   arg2 = static_cast< int >(val2);
20130   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
20131   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20132   return resultobj;
20133 fail:
20134   return NULL;
20135 }
20136
20137
20138 SWIGINTERN PyObject *_wrap_Quad_addAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20139   PyObject *resultobj = 0;
20140   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20141   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
20142   int arg3 ;
20143   int result;
20144   void *argp1 = 0 ;
20145   int res1 = 0 ;
20146   void *argp2 = 0 ;
20147   int res2 = 0 ;
20148   int val3 ;
20149   int ecode3 = 0 ;
20150   PyObject * obj0 = 0 ;
20151   PyObject * obj1 = 0 ;
20152   PyObject * obj2 = 0 ;
20153
20154   if (!PyArg_ParseTuple(args,(char *)"OOO:Quad_addAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
20155   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20156   if (!SWIG_IsOK(res1)) {
20157     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_addAssociation" "', argument " "1"" of type '" "Hex::Quad *""'");
20158   }
20159   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20160   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
20161   if (!SWIG_IsOK(res2)) {
20162     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_addAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
20163   }
20164   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
20165   ecode3 = SWIG_AsVal_int(obj2, &val3);
20166   if (!SWIG_IsOK(ecode3)) {
20167     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quad_addAssociation" "', argument " "3"" of type '" "int""'");
20168   }
20169   arg3 = static_cast< int >(val3);
20170   result = (int)(arg1)->addAssociation(arg2,arg3);
20171   resultobj = SWIG_From_int(static_cast< int >(result));
20172   return resultobj;
20173 fail:
20174   return NULL;
20175 }
20176
20177
20178 SWIGINTERN PyObject *_wrap_Quad_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20179   PyObject *resultobj = 0;
20180   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20181   void *argp1 = 0 ;
20182   int res1 = 0 ;
20183   PyObject * obj0 = 0 ;
20184
20185   if (!PyArg_ParseTuple(args,(char *)"O:Quad_clearAssociation",&obj0)) SWIG_fail;
20186   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20187   if (!SWIG_IsOK(res1)) {
20188     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_clearAssociation" "', argument " "1"" of type '" "Hex::Quad *""'");
20189   }
20190   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20191   (arg1)->clearAssociation();
20192   resultobj = SWIG_Py_Void();
20193   return resultobj;
20194 fail:
20195   return NULL;
20196 }
20197
20198
20199 SWIGINTERN PyObject *_wrap_Quad_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20200   PyObject *resultobj = 0;
20201   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20202   double arg2 ;
20203   void *argp1 = 0 ;
20204   int res1 = 0 ;
20205   double val2 ;
20206   int ecode2 = 0 ;
20207   PyObject * obj0 = 0 ;
20208   PyObject * obj1 = 0 ;
20209
20210   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_setColor",&obj0,&obj1)) SWIG_fail;
20211   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20212   if (!SWIG_IsOK(res1)) {
20213     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_setColor" "', argument " "1"" of type '" "Hex::Quad *""'");
20214   }
20215   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20216   ecode2 = SWIG_AsVal_double(obj1, &val2);
20217   if (!SWIG_IsOK(ecode2)) {
20218     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_setColor" "', argument " "2"" of type '" "double""'");
20219   }
20220   arg2 = static_cast< double >(val2);
20221   (arg1)->setColor(arg2);
20222   resultobj = SWIG_Py_Void();
20223   return resultobj;
20224 fail:
20225   return NULL;
20226 }
20227
20228
20229 SWIGINTERN PyObject *_wrap_Quad_nearestVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20230   PyObject *resultobj = 0;
20231   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20232   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
20233   Hex::Vertex *result = 0 ;
20234   void *argp1 = 0 ;
20235   int res1 = 0 ;
20236   void *argp2 = 0 ;
20237   int res2 = 0 ;
20238   PyObject * obj0 = 0 ;
20239   PyObject * obj1 = 0 ;
20240
20241   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_nearestVertex",&obj0,&obj1)) SWIG_fail;
20242   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20243   if (!SWIG_IsOK(res1)) {
20244     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_nearestVertex" "', argument " "1"" of type '" "Hex::Quad *""'");
20245   }
20246   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20247   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20248   if (!SWIG_IsOK(res2)) {
20249     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_nearestVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
20250   }
20251   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
20252   result = (Hex::Vertex *)(arg1)->nearestVertex(arg2);
20253   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20254   return resultobj;
20255 fail:
20256   return NULL;
20257 }
20258
20259
20260 SWIGINTERN PyObject *_wrap_Quad_getCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20261   PyObject *resultobj = 0;
20262   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20263   double *arg2 = (double *) 0 ;
20264   double *result = 0 ;
20265   void *argp1 = 0 ;
20266   int res1 = 0 ;
20267   void *argp2 = 0 ;
20268   int res2 = 0 ;
20269   PyObject * obj0 = 0 ;
20270   PyObject * obj1 = 0 ;
20271
20272   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getCenter",&obj0,&obj1)) SWIG_fail;
20273   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20274   if (!SWIG_IsOK(res1)) {
20275     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getCenter" "', argument " "1"" of type '" "Hex::Quad *""'");
20276   }
20277   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20278   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20279   if (!SWIG_IsOK(res2)) {
20280     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_getCenter" "', argument " "2"" of type '" "double *""'");
20281   }
20282   arg2 = reinterpret_cast< double * >(argp2);
20283   result = (double *)(arg1)->getCenter(arg2);
20284   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
20285   return resultobj;
20286 fail:
20287   return NULL;
20288 }
20289
20290
20291 SWIGINTERN PyObject *_wrap_new_Quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20292   PyObject *resultobj = 0;
20293   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
20294   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
20295   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
20296   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
20297   Hex::Quad *result = 0 ;
20298   void *argp1 = 0 ;
20299   int res1 = 0 ;
20300   void *argp2 = 0 ;
20301   int res2 = 0 ;
20302   void *argp3 = 0 ;
20303   int res3 = 0 ;
20304   void *argp4 = 0 ;
20305   int res4 = 0 ;
20306   PyObject * obj0 = 0 ;
20307   PyObject * obj1 = 0 ;
20308   PyObject * obj2 = 0 ;
20309   PyObject * obj3 = 0 ;
20310
20311   if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Quad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20312   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20313   if (!SWIG_IsOK(res1)) {
20314     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Quad" "', argument " "1"" of type '" "Hex::Vertex *""'");
20315   }
20316   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
20317   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20318   if (!SWIG_IsOK(res2)) {
20319     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Quad" "', argument " "2"" of type '" "Hex::Vertex *""'");
20320   }
20321   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
20322   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20323   if (!SWIG_IsOK(res3)) {
20324     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Quad" "', argument " "3"" of type '" "Hex::Vertex *""'");
20325   }
20326   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
20327   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20328   if (!SWIG_IsOK(res4)) {
20329     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Quad" "', argument " "4"" of type '" "Hex::Vertex *""'");
20330   }
20331   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
20332   result = (Hex::Quad *)new Hex::Quad(arg1,arg2,arg3,arg4);
20333   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, SWIG_POINTER_NEW |  0 );
20334   return resultobj;
20335 fail:
20336   return NULL;
20337 }
20338
20339
20340 SWIGINTERN PyObject *_wrap_delete_Quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20341   PyObject *resultobj = 0;
20342   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20343   void *argp1 = 0 ;
20344   int res1 = 0 ;
20345   PyObject * obj0 = 0 ;
20346
20347   if (!PyArg_ParseTuple(args,(char *)"O:delete_Quad",&obj0)) SWIG_fail;
20348   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, SWIG_POINTER_DISOWN |  0 );
20349   if (!SWIG_IsOK(res1)) {
20350     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Quad" "', argument " "1"" of type '" "Hex::Quad *""'");
20351   }
20352   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20353   delete arg1;
20354
20355   resultobj = SWIG_Py_Void();
20356   return resultobj;
20357 fail:
20358   return NULL;
20359 }
20360
20361
20362 SWIGINTERN PyObject *Quad_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20363   PyObject *obj;
20364   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
20365   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Quad, SWIG_NewClientData(obj));
20366   return SWIG_Py_Void();
20367 }
20368
20369 SWIGINTERN PyObject *_wrap_Hexa_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20370   PyObject *resultobj = 0;
20371   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
20372   int arg2 ;
20373   Hex::Quad *result = 0 ;
20374   void *argp1 = 0 ;
20375   int res1 = 0 ;
20376   int val2 ;
20377   int ecode2 = 0 ;
20378   PyObject * obj0 = 0 ;
20379   PyObject * obj1 = 0 ;
20380
20381   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getQuad",&obj0,&obj1)) SWIG_fail;
20382   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
20383   if (!SWIG_IsOK(res1)) {
20384     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getQuad" "', argument " "1"" of type '" "Hex::Hexa *""'");
20385   }
20386   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
20387   ecode2 = SWIG_AsVal_int(obj1, &val2);
20388   if (!SWIG_IsOK(ecode2)) {
20389     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getQuad" "', argument " "2"" of type '" "int""'");
20390   }
20391   arg2 = static_cast< int >(val2);
20392   result = (Hex::Quad *)(arg1)->getQuad(arg2);
20393   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
20394   return resultobj;
20395 fail:
20396   return NULL;
20397 }
20398
20399
20400 SWIGINTERN PyObject *_wrap_Hexa_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20401   PyObject *resultobj = 0;
20402   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
20403   int arg2 ;
20404   Hex::Edge *result = 0 ;
20405   void *argp1 = 0 ;
20406   int res1 = 0 ;
20407   int val2 ;
20408   int ecode2 = 0 ;
20409   PyObject * obj0 = 0 ;
20410   PyObject * obj1 = 0 ;
20411
20412   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getEdge",&obj0,&obj1)) SWIG_fail;
20413   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
20414   if (!SWIG_IsOK(res1)) {
20415     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getEdge" "', argument " "1"" of type '" "Hex::Hexa *""'");
20416   }
20417   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
20418   ecode2 = SWIG_AsVal_int(obj1, &val2);
20419   if (!SWIG_IsOK(ecode2)) {
20420     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getEdge" "', argument " "2"" of type '" "int""'");
20421   }
20422   arg2 = static_cast< int >(val2);
20423   result = (Hex::Edge *)(arg1)->getEdge(arg2);
20424   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
20425   return resultobj;
20426 fail:
20427   return NULL;
20428 }
20429
20430
20431 SWIGINTERN PyObject *_wrap_Hexa_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20432   PyObject *resultobj = 0;
20433   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
20434   int arg2 ;
20435   Hex::Vertex *result = 0 ;
20436   void *argp1 = 0 ;
20437   int res1 = 0 ;
20438   int val2 ;
20439   int ecode2 = 0 ;
20440   PyObject * obj0 = 0 ;
20441   PyObject * obj1 = 0 ;
20442
20443   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getVertex",&obj0,&obj1)) SWIG_fail;
20444   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
20445   if (!SWIG_IsOK(res1)) {
20446     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getVertex" "', argument " "1"" of type '" "Hex::Hexa *""'");
20447   }
20448   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
20449   ecode2 = SWIG_AsVal_int(obj1, &val2);
20450   if (!SWIG_IsOK(ecode2)) {
20451     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getVertex" "', argument " "2"" of type '" "int""'");
20452   }
20453   arg2 = static_cast< int >(val2);
20454   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
20455   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
20456   return resultobj;
20457 fail:
20458   return NULL;
20459 }
20460
20461
20462 SWIGINTERN PyObject *_wrap_Hexa_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20463   PyObject *resultobj = 0;
20464   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
20465   double arg2 ;
20466   void *argp1 = 0 ;
20467   int res1 = 0 ;
20468   double val2 ;
20469   int ecode2 = 0 ;
20470   PyObject * obj0 = 0 ;
20471   PyObject * obj1 = 0 ;
20472
20473   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_setColor",&obj0,&obj1)) SWIG_fail;
20474   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
20475   if (!SWIG_IsOK(res1)) {
20476     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_setColor" "', argument " "1"" of type '" "Hex::Hexa *""'");
20477   }
20478   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
20479   ecode2 = SWIG_AsVal_double(obj1, &val2);
20480   if (!SWIG_IsOK(ecode2)) {
20481     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_setColor" "', argument " "2"" of type '" "double""'");
20482   }
20483   arg2 = static_cast< double >(val2);
20484   (arg1)->setColor(arg2);
20485   resultobj = SWIG_Py_Void();
20486   return resultobj;
20487 fail:
20488   return NULL;
20489 }
20490
20491
20492 SWIGINTERN PyObject *_wrap_new_Hexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20493   PyObject *resultobj = 0;
20494   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
20495   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
20496   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
20497   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
20498   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
20499   Hex::Quad *arg6 = (Hex::Quad *) 0 ;
20500   Hex::Hexa *result = 0 ;
20501   void *argp1 = 0 ;
20502   int res1 = 0 ;
20503   void *argp2 = 0 ;
20504   int res2 = 0 ;
20505   void *argp3 = 0 ;
20506   int res3 = 0 ;
20507   void *argp4 = 0 ;
20508   int res4 = 0 ;
20509   void *argp5 = 0 ;
20510   int res5 = 0 ;
20511   void *argp6 = 0 ;
20512   int res6 = 0 ;
20513   PyObject * obj0 = 0 ;
20514   PyObject * obj1 = 0 ;
20515   PyObject * obj2 = 0 ;
20516   PyObject * obj3 = 0 ;
20517   PyObject * obj4 = 0 ;
20518   PyObject * obj5 = 0 ;
20519
20520   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Hexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20521   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20522   if (!SWIG_IsOK(res1)) {
20523     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Hexa" "', argument " "1"" of type '" "Hex::Quad *""'");
20524   }
20525   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
20526   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20527   if (!SWIG_IsOK(res2)) {
20528     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Hexa" "', argument " "2"" of type '" "Hex::Quad *""'");
20529   }
20530   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
20531   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20532   if (!SWIG_IsOK(res3)) {
20533     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Hexa" "', argument " "3"" of type '" "Hex::Quad *""'");
20534   }
20535   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
20536   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20537   if (!SWIG_IsOK(res4)) {
20538     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Hexa" "', argument " "4"" of type '" "Hex::Quad *""'");
20539   }
20540   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
20541   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20542   if (!SWIG_IsOK(res5)) {
20543     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Hexa" "', argument " "5"" of type '" "Hex::Quad *""'");
20544   }
20545   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
20546   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 |  0 );
20547   if (!SWIG_IsOK(res6)) {
20548     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Hexa" "', argument " "6"" of type '" "Hex::Quad *""'");
20549   }
20550   arg6 = reinterpret_cast< Hex::Quad * >(argp6);
20551   result = (Hex::Hexa *)new Hex::Hexa(arg1,arg2,arg3,arg4,arg5,arg6);
20552   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, SWIG_POINTER_NEW |  0 );
20553   return resultobj;
20554 fail:
20555   return NULL;
20556 }
20557
20558
20559 SWIGINTERN PyObject *_wrap_delete_Hexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20560   PyObject *resultobj = 0;
20561   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
20562   void *argp1 = 0 ;
20563   int res1 = 0 ;
20564   PyObject * obj0 = 0 ;
20565
20566   if (!PyArg_ParseTuple(args,(char *)"O:delete_Hexa",&obj0)) SWIG_fail;
20567   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, SWIG_POINTER_DISOWN |  0 );
20568   if (!SWIG_IsOK(res1)) {
20569     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hexa" "', argument " "1"" of type '" "Hex::Hexa *""'");
20570   }
20571   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
20572   delete arg1;
20573
20574   resultobj = SWIG_Py_Void();
20575   return resultobj;
20576 fail:
20577   return NULL;
20578 }
20579
20580
20581 SWIGINTERN PyObject *Hexa_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20582   PyObject *obj;
20583   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
20584   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hexa, SWIG_NewClientData(obj));
20585   return SWIG_Py_Void();
20586 }
20587
20588 SWIGINTERN PyObject *_wrap_Vector_getDx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20589   PyObject *resultobj = 0;
20590   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20591   double result;
20592   void *argp1 = 0 ;
20593   int res1 = 0 ;
20594   PyObject * obj0 = 0 ;
20595
20596   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDx",&obj0)) SWIG_fail;
20597   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
20598   if (!SWIG_IsOK(res1)) {
20599     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDx" "', argument " "1"" of type '" "Hex::Vector *""'");
20600   }
20601   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20602   result = (double)(arg1)->getDx();
20603   resultobj = SWIG_From_double(static_cast< double >(result));
20604   return resultobj;
20605 fail:
20606   return NULL;
20607 }
20608
20609
20610 SWIGINTERN PyObject *_wrap_Vector_getDy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20611   PyObject *resultobj = 0;
20612   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20613   double result;
20614   void *argp1 = 0 ;
20615   int res1 = 0 ;
20616   PyObject * obj0 = 0 ;
20617
20618   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDy",&obj0)) SWIG_fail;
20619   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
20620   if (!SWIG_IsOK(res1)) {
20621     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDy" "', argument " "1"" of type '" "Hex::Vector *""'");
20622   }
20623   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20624   result = (double)(arg1)->getDy();
20625   resultobj = SWIG_From_double(static_cast< double >(result));
20626   return resultobj;
20627 fail:
20628   return NULL;
20629 }
20630
20631
20632 SWIGINTERN PyObject *_wrap_Vector_getDz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20633   PyObject *resultobj = 0;
20634   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20635   double result;
20636   void *argp1 = 0 ;
20637   int res1 = 0 ;
20638   PyObject * obj0 = 0 ;
20639
20640   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDz",&obj0)) SWIG_fail;
20641   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
20642   if (!SWIG_IsOK(res1)) {
20643     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDz" "', argument " "1"" of type '" "Hex::Vector *""'");
20644   }
20645   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20646   result = (double)(arg1)->getDz();
20647   resultobj = SWIG_From_double(static_cast< double >(result));
20648   return resultobj;
20649 fail:
20650   return NULL;
20651 }
20652
20653
20654 SWIGINTERN PyObject *_wrap_Vector_getNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20655   PyObject *resultobj = 0;
20656   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20657   double result;
20658   void *argp1 = 0 ;
20659   int res1 = 0 ;
20660   PyObject * obj0 = 0 ;
20661
20662   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getNorm",&obj0)) SWIG_fail;
20663   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
20664   if (!SWIG_IsOK(res1)) {
20665     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getNorm" "', argument " "1"" of type '" "Hex::Vector *""'");
20666   }
20667   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20668   result = (double)(arg1)->getNorm();
20669   resultobj = SWIG_From_double(static_cast< double >(result));
20670   return resultobj;
20671 fail:
20672   return NULL;
20673 }
20674
20675
20676 SWIGINTERN PyObject *_wrap_Vector_getAngleX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20677   PyObject *resultobj = 0;
20678   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20679   double result;
20680   void *argp1 = 0 ;
20681   int res1 = 0 ;
20682   PyObject * obj0 = 0 ;
20683
20684   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getAngleX",&obj0)) SWIG_fail;
20685   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
20686   if (!SWIG_IsOK(res1)) {
20687     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getAngleX" "', argument " "1"" of type '" "Hex::Vector *""'");
20688   }
20689   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20690   result = (double)(arg1)->getAngleX();
20691   resultobj = SWIG_From_double(static_cast< double >(result));
20692   return resultobj;
20693 fail:
20694   return NULL;
20695 }
20696
20697
20698 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20699   PyObject *resultobj = 0;
20700   Hex::Document *arg1 = (Hex::Document *) 0 ;
20701   double arg2 ;
20702   double arg3 ;
20703   double arg4 ;
20704   Hex::Vector *result = 0 ;
20705   void *argp1 = 0 ;
20706   int res1 = 0 ;
20707   double val2 ;
20708   int ecode2 = 0 ;
20709   double val3 ;
20710   int ecode3 = 0 ;
20711   double val4 ;
20712   int ecode4 = 0 ;
20713   PyObject * obj0 = 0 ;
20714   PyObject * obj1 = 0 ;
20715   PyObject * obj2 = 0 ;
20716   PyObject * obj3 = 0 ;
20717
20718   if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20719   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
20720   if (!SWIG_IsOK(res1)) {
20721     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
20722   }
20723   arg1 = reinterpret_cast< Hex::Document * >(argp1);
20724   ecode2 = SWIG_AsVal_double(obj1, &val2);
20725   if (!SWIG_IsOK(ecode2)) {
20726     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
20727   }
20728   arg2 = static_cast< double >(val2);
20729   ecode3 = SWIG_AsVal_double(obj2, &val3);
20730   if (!SWIG_IsOK(ecode3)) {
20731     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vector" "', argument " "3"" of type '" "double""'");
20732   }
20733   arg3 = static_cast< double >(val3);
20734   ecode4 = SWIG_AsVal_double(obj3, &val4);
20735   if (!SWIG_IsOK(ecode4)) {
20736     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vector" "', argument " "4"" of type '" "double""'");
20737   }
20738   arg4 = static_cast< double >(val4);
20739   result = (Hex::Vector *)new Hex::Vector(arg1,arg2,arg3,arg4);
20740   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
20741   return resultobj;
20742 fail:
20743   return NULL;
20744 }
20745
20746
20747 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20748   PyObject *resultobj = 0;
20749   Hex::Document *arg1 = (Hex::Document *) 0 ;
20750   double arg2 ;
20751   double arg3 ;
20752   Hex::Vector *result = 0 ;
20753   void *argp1 = 0 ;
20754   int res1 = 0 ;
20755   double val2 ;
20756   int ecode2 = 0 ;
20757   double val3 ;
20758   int ecode3 = 0 ;
20759   PyObject * obj0 = 0 ;
20760   PyObject * obj1 = 0 ;
20761   PyObject * obj2 = 0 ;
20762
20763   if (!PyArg_ParseTuple(args,(char *)"OOO:new_Vector",&obj0,&obj1,&obj2)) SWIG_fail;
20764   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
20765   if (!SWIG_IsOK(res1)) {
20766     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
20767   }
20768   arg1 = reinterpret_cast< Hex::Document * >(argp1);
20769   ecode2 = SWIG_AsVal_double(obj1, &val2);
20770   if (!SWIG_IsOK(ecode2)) {
20771     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
20772   }
20773   arg2 = static_cast< double >(val2);
20774   ecode3 = SWIG_AsVal_double(obj2, &val3);
20775   if (!SWIG_IsOK(ecode3)) {
20776     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vector" "', argument " "3"" of type '" "double""'");
20777   }
20778   arg3 = static_cast< double >(val3);
20779   result = (Hex::Vector *)new Hex::Vector(arg1,arg2,arg3);
20780   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
20781   return resultobj;
20782 fail:
20783   return NULL;
20784 }
20785
20786
20787 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20788   PyObject *resultobj = 0;
20789   Hex::Document *arg1 = (Hex::Document *) 0 ;
20790   double arg2 ;
20791   Hex::Vector *result = 0 ;
20792   void *argp1 = 0 ;
20793   int res1 = 0 ;
20794   double val2 ;
20795   int ecode2 = 0 ;
20796   PyObject * obj0 = 0 ;
20797   PyObject * obj1 = 0 ;
20798
20799   if (!PyArg_ParseTuple(args,(char *)"OO:new_Vector",&obj0,&obj1)) SWIG_fail;
20800   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
20801   if (!SWIG_IsOK(res1)) {
20802     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
20803   }
20804   arg1 = reinterpret_cast< Hex::Document * >(argp1);
20805   ecode2 = SWIG_AsVal_double(obj1, &val2);
20806   if (!SWIG_IsOK(ecode2)) {
20807     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
20808   }
20809   arg2 = static_cast< double >(val2);
20810   result = (Hex::Vector *)new Hex::Vector(arg1,arg2);
20811   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
20812   return resultobj;
20813 fail:
20814   return NULL;
20815 }
20816
20817
20818 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20819   PyObject *resultobj = 0;
20820   Hex::Document *arg1 = (Hex::Document *) 0 ;
20821   Hex::Vector *result = 0 ;
20822   void *argp1 = 0 ;
20823   int res1 = 0 ;
20824   PyObject * obj0 = 0 ;
20825
20826   if (!PyArg_ParseTuple(args,(char *)"O:new_Vector",&obj0)) SWIG_fail;
20827   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
20828   if (!SWIG_IsOK(res1)) {
20829     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
20830   }
20831   arg1 = reinterpret_cast< Hex::Document * >(argp1);
20832   result = (Hex::Vector *)new Hex::Vector(arg1);
20833   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
20834   return resultobj;
20835 fail:
20836   return NULL;
20837 }
20838
20839
20840 SWIGINTERN PyObject *_wrap_new_Vector(PyObject *self, PyObject *args) {
20841   int argc;
20842   PyObject *argv[5];
20843   int ii;
20844
20845   if (!PyTuple_Check(args)) SWIG_fail;
20846   argc = PyObject_Length(args);
20847   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
20848     argv[ii] = PyTuple_GET_ITEM(args,ii);
20849   }
20850   if (argc == 1) {
20851     int _v;
20852     void *vptr = 0;
20853     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
20854     _v = SWIG_CheckState(res);
20855     if (_v) {
20856       return _wrap_new_Vector__SWIG_3(self, args);
20857     }
20858   }
20859   if (argc == 2) {
20860     int _v;
20861     void *vptr = 0;
20862     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
20863     _v = SWIG_CheckState(res);
20864     if (_v) {
20865       {
20866         int res = SWIG_AsVal_double(argv[1], NULL);
20867         _v = SWIG_CheckState(res);
20868       }
20869       if (_v) {
20870         return _wrap_new_Vector__SWIG_2(self, args);
20871       }
20872     }
20873   }
20874   if (argc == 3) {
20875     int _v;
20876     void *vptr = 0;
20877     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
20878     _v = SWIG_CheckState(res);
20879     if (_v) {
20880       {
20881         int res = SWIG_AsVal_double(argv[1], NULL);
20882         _v = SWIG_CheckState(res);
20883       }
20884       if (_v) {
20885         {
20886           int res = SWIG_AsVal_double(argv[2], NULL);
20887           _v = SWIG_CheckState(res);
20888         }
20889         if (_v) {
20890           return _wrap_new_Vector__SWIG_1(self, args);
20891         }
20892       }
20893     }
20894   }
20895   if (argc == 4) {
20896     int _v;
20897     void *vptr = 0;
20898     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
20899     _v = SWIG_CheckState(res);
20900     if (_v) {
20901       {
20902         int res = SWIG_AsVal_double(argv[1], NULL);
20903         _v = SWIG_CheckState(res);
20904       }
20905       if (_v) {
20906         {
20907           int res = SWIG_AsVal_double(argv[2], NULL);
20908           _v = SWIG_CheckState(res);
20909         }
20910         if (_v) {
20911           {
20912             int res = SWIG_AsVal_double(argv[3], NULL);
20913             _v = SWIG_CheckState(res);
20914           }
20915           if (_v) {
20916             return _wrap_new_Vector__SWIG_0(self, args);
20917           }
20918         }
20919       }
20920     }
20921   }
20922
20923 fail:
20924   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vector'.\n  Possible C/C++ prototypes are:\n    Hex::Vector(Hex::Document *,double,double,double)\n    Hex::Vector(Hex::Document *,double,double)\n    Hex::Vector(Hex::Document *,double)\n    Hex::Vector(Hex::Document *)\n");
20925   return NULL;
20926 }
20927
20928
20929 SWIGINTERN PyObject *_wrap_delete_Vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20930   PyObject *resultobj = 0;
20931   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
20932   void *argp1 = 0 ;
20933   int res1 = 0 ;
20934   PyObject * obj0 = 0 ;
20935
20936   if (!PyArg_ParseTuple(args,(char *)"O:delete_Vector",&obj0)) SWIG_fail;
20937   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, SWIG_POINTER_DISOWN |  0 );
20938   if (!SWIG_IsOK(res1)) {
20939     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector" "', argument " "1"" of type '" "Hex::Vector *""'");
20940   }
20941   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
20942   delete arg1;
20943
20944   resultobj = SWIG_Py_Void();
20945   return resultobj;
20946 fail:
20947   return NULL;
20948 }
20949
20950
20951 SWIGINTERN PyObject *Vector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20952   PyObject *obj;
20953   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
20954   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vector, SWIG_NewClientData(obj));
20955   return SWIG_Py_Void();
20956 }
20957
20958 SWIGINTERN PyObject *_wrap_new_Document__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20959   PyObject *resultobj = 0;
20960   cpchar arg1 = (cpchar) 0 ;
20961   Hex::Hex *arg2 = (Hex::Hex *) 0 ;
20962   Hex::Document *result = 0 ;
20963   int res1 ;
20964   char *buf1 = 0 ;
20965   int alloc1 = 0 ;
20966   void *argp2 = 0 ;
20967   int res2 = 0 ;
20968   PyObject * obj0 = 0 ;
20969   PyObject * obj1 = 0 ;
20970
20971   if (!PyArg_ParseTuple(args,(char *)"OO:new_Document",&obj0,&obj1)) SWIG_fail;
20972   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20973   if (!SWIG_IsOK(res1)) {
20974     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Document" "', argument " "1"" of type '" "cpchar""'");
20975   }
20976   arg1 = reinterpret_cast< cpchar >(buf1);
20977   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hex, 0 |  0 );
20978   if (!SWIG_IsOK(res2)) {
20979     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Document" "', argument " "2"" of type '" "Hex::Hex *""'");
20980   }
20981   arg2 = reinterpret_cast< Hex::Hex * >(argp2);
20982   result = (Hex::Document *)new Hex::Document(arg1,arg2);
20983   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, SWIG_POINTER_NEW |  0 );
20984   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20985   return resultobj;
20986 fail:
20987   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20988   return NULL;
20989 }
20990
20991
20992 SWIGINTERN PyObject *_wrap_new_Document__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20993   PyObject *resultobj = 0;
20994   cpchar arg1 = (cpchar) 0 ;
20995   Hex::Document *result = 0 ;
20996   int res1 ;
20997   char *buf1 = 0 ;
20998   int alloc1 = 0 ;
20999   PyObject * obj0 = 0 ;
21000
21001   if (!PyArg_ParseTuple(args,(char *)"O:new_Document",&obj0)) SWIG_fail;
21002   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
21003   if (!SWIG_IsOK(res1)) {
21004     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Document" "', argument " "1"" of type '" "cpchar""'");
21005   }
21006   arg1 = reinterpret_cast< cpchar >(buf1);
21007   result = (Hex::Document *)new Hex::Document(arg1);
21008   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, SWIG_POINTER_NEW |  0 );
21009   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21010   return resultobj;
21011 fail:
21012   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21013   return NULL;
21014 }
21015
21016
21017 SWIGINTERN PyObject *_wrap_new_Document(PyObject *self, PyObject *args) {
21018   int argc;
21019   PyObject *argv[3];
21020   int ii;
21021
21022   if (!PyTuple_Check(args)) SWIG_fail;
21023   argc = PyObject_Length(args);
21024   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
21025     argv[ii] = PyTuple_GET_ITEM(args,ii);
21026   }
21027   if (argc == 1) {
21028     int _v;
21029     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
21030     _v = SWIG_CheckState(res);
21031     if (_v) {
21032       return _wrap_new_Document__SWIG_1(self, args);
21033     }
21034   }
21035   if (argc == 2) {
21036     int _v;
21037     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
21038     _v = SWIG_CheckState(res);
21039     if (_v) {
21040       void *vptr = 0;
21041       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Hex, 0);
21042       _v = SWIG_CheckState(res);
21043       if (_v) {
21044         return _wrap_new_Document__SWIG_0(self, args);
21045       }
21046     }
21047   }
21048
21049 fail:
21050   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Document'.\n  Possible C/C++ prototypes are:\n    Hex::Document(cpchar,Hex::Hex *)\n    Hex::Document(cpchar)\n");
21051   return NULL;
21052 }
21053
21054
21055 SWIGINTERN PyObject *_wrap_Document_dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21056   PyObject *resultobj = 0;
21057   Hex::Document *arg1 = (Hex::Document *) 0 ;
21058   void *argp1 = 0 ;
21059   int res1 = 0 ;
21060   PyObject * obj0 = 0 ;
21061
21062   if (!PyArg_ParseTuple(args,(char *)"O:Document_dump",&obj0)) SWIG_fail;
21063   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21064   if (!SWIG_IsOK(res1)) {
21065     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_dump" "', argument " "1"" of type '" "Hex::Document *""'");
21066   }
21067   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21068   (arg1)->dump();
21069   resultobj = SWIG_Py_Void();
21070   return resultobj;
21071 fail:
21072   return NULL;
21073 }
21074
21075
21076 SWIGINTERN PyObject *_wrap_Document_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21077   PyObject *resultobj = 0;
21078   Hex::Document *arg1 = (Hex::Document *) 0 ;
21079   char *arg2 = (char *) 0 ;
21080   int result;
21081   void *argp1 = 0 ;
21082   int res1 = 0 ;
21083   int res2 ;
21084   char *buf2 = 0 ;
21085   int alloc2 = 0 ;
21086   PyObject * obj0 = 0 ;
21087   PyObject * obj1 = 0 ;
21088
21089   if (!PyArg_ParseTuple(args,(char *)"OO:Document_setName",&obj0,&obj1)) SWIG_fail;
21090   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21091   if (!SWIG_IsOK(res1)) {
21092     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setName" "', argument " "1"" of type '" "Hex::Document *""'");
21093   }
21094   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21095   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21096   if (!SWIG_IsOK(res2)) {
21097     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_setName" "', argument " "2"" of type '" "char const *""'");
21098   }
21099   arg2 = reinterpret_cast< char * >(buf2);
21100   result = (int)(arg1)->setName((char const *)arg2);
21101   resultobj = SWIG_From_int(static_cast< int >(result));
21102   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21103   return resultobj;
21104 fail:
21105   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21106   return NULL;
21107 }
21108
21109
21110 SWIGINTERN PyObject *_wrap_Document_setLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21111   PyObject *resultobj = 0;
21112   Hex::Document *arg1 = (Hex::Document *) 0 ;
21113   int arg2 ;
21114   void *argp1 = 0 ;
21115   int res1 = 0 ;
21116   int val2 ;
21117   int ecode2 = 0 ;
21118   PyObject * obj0 = 0 ;
21119   PyObject * obj1 = 0 ;
21120
21121   if (!PyArg_ParseTuple(args,(char *)"OO:Document_setLevel",&obj0,&obj1)) SWIG_fail;
21122   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21123   if (!SWIG_IsOK(res1)) {
21124     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setLevel" "', argument " "1"" of type '" "Hex::Document *""'");
21125   }
21126   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21127   ecode2 = SWIG_AsVal_int(obj1, &val2);
21128   if (!SWIG_IsOK(ecode2)) {
21129     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_setLevel" "', argument " "2"" of type '" "int""'");
21130   }
21131   arg2 = static_cast< int >(val2);
21132   (arg1)->setLevel(arg2);
21133   resultobj = SWIG_Py_Void();
21134   return resultobj;
21135 fail:
21136   return NULL;
21137 }
21138
21139
21140 SWIGINTERN PyObject *_wrap_Document_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21141   PyObject *resultobj = 0;
21142   Hex::Document *arg1 = (Hex::Document *) 0 ;
21143   char *arg2 = (char *) 0 ;
21144   int result;
21145   void *argp1 = 0 ;
21146   int res1 = 0 ;
21147   int res2 ;
21148   char *buf2 = 0 ;
21149   int alloc2 = 0 ;
21150   PyObject * obj0 = 0 ;
21151   PyObject * obj1 = 0 ;
21152
21153   if (!PyArg_ParseTuple(args,(char *)"OO:Document_save",&obj0,&obj1)) SWIG_fail;
21154   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21155   if (!SWIG_IsOK(res1)) {
21156     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_save" "', argument " "1"" of type '" "Hex::Document *""'");
21157   }
21158   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21159   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21160   if (!SWIG_IsOK(res2)) {
21161     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_save" "', argument " "2"" of type '" "char const *""'");
21162   }
21163   arg2 = reinterpret_cast< char * >(buf2);
21164   result = (int)(arg1)->save((char const *)arg2);
21165   resultobj = SWIG_From_int(static_cast< int >(result));
21166   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21167   return resultobj;
21168 fail:
21169   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21170   return NULL;
21171 }
21172
21173
21174 SWIGINTERN PyObject *_wrap_Document_saveVtk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175   PyObject *resultobj = 0;
21176   Hex::Document *arg1 = (Hex::Document *) 0 ;
21177   cpchar arg2 = (cpchar) 0 ;
21178   int result;
21179   void *argp1 = 0 ;
21180   int res1 = 0 ;
21181   int res2 ;
21182   char *buf2 = 0 ;
21183   int alloc2 = 0 ;
21184   PyObject * obj0 = 0 ;
21185   PyObject * obj1 = 0 ;
21186
21187   if (!PyArg_ParseTuple(args,(char *)"OO:Document_saveVtk",&obj0,&obj1)) SWIG_fail;
21188   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21189   if (!SWIG_IsOK(res1)) {
21190     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_saveVtk" "', argument " "1"" of type '" "Hex::Document *""'");
21191   }
21192   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21193   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21194   if (!SWIG_IsOK(res2)) {
21195     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_saveVtk" "', argument " "2"" of type '" "cpchar""'");
21196   }
21197   arg2 = reinterpret_cast< cpchar >(buf2);
21198   result = (int)(arg1)->saveVtk(arg2);
21199   resultobj = SWIG_From_int(static_cast< int >(result));
21200   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21201   return resultobj;
21202 fail:
21203   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21204   return NULL;
21205 }
21206
21207
21208 SWIGINTERN PyObject *_wrap_Document_purge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21209   PyObject *resultobj = 0;
21210   Hex::Document *arg1 = (Hex::Document *) 0 ;
21211   void *argp1 = 0 ;
21212   int res1 = 0 ;
21213   PyObject * obj0 = 0 ;
21214
21215   if (!PyArg_ParseTuple(args,(char *)"O:Document_purge",&obj0)) SWIG_fail;
21216   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21217   if (!SWIG_IsOK(res1)) {
21218     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_purge" "', argument " "1"" of type '" "Hex::Document *""'");
21219   }
21220   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21221   (arg1)->purge();
21222   resultobj = SWIG_Py_Void();
21223   return resultobj;
21224 fail:
21225   return NULL;
21226 }
21227
21228
21229 SWIGINTERN PyObject *_wrap_Document_setTolerance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21230   PyObject *resultobj = 0;
21231   Hex::Document *arg1 = (Hex::Document *) 0 ;
21232   double arg2 ;
21233   void *argp1 = 0 ;
21234   int res1 = 0 ;
21235   double val2 ;
21236   int ecode2 = 0 ;
21237   PyObject * obj0 = 0 ;
21238   PyObject * obj1 = 0 ;
21239
21240   if (!PyArg_ParseTuple(args,(char *)"OO:Document_setTolerance",&obj0,&obj1)) SWIG_fail;
21241   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21242   if (!SWIG_IsOK(res1)) {
21243     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setTolerance" "', argument " "1"" of type '" "Hex::Document *""'");
21244   }
21245   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21246   ecode2 = SWIG_AsVal_double(obj1, &val2);
21247   if (!SWIG_IsOK(ecode2)) {
21248     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_setTolerance" "', argument " "2"" of type '" "double""'");
21249   }
21250   arg2 = static_cast< double >(val2);
21251   (arg1)->setTolerance(arg2);
21252   resultobj = SWIG_Py_Void();
21253   return resultobj;
21254 fail:
21255   return NULL;
21256 }
21257
21258
21259 SWIGINTERN PyObject *_wrap_Document_getTolerance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21260   PyObject *resultobj = 0;
21261   Hex::Document *arg1 = (Hex::Document *) 0 ;
21262   double result;
21263   void *argp1 = 0 ;
21264   int res1 = 0 ;
21265   PyObject * obj0 = 0 ;
21266
21267   if (!PyArg_ParseTuple(args,(char *)"O:Document_getTolerance",&obj0)) SWIG_fail;
21268   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21269   if (!SWIG_IsOK(res1)) {
21270     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getTolerance" "', argument " "1"" of type '" "Hex::Document *""'");
21271   }
21272   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21273   result = (double)(arg1)->getTolerance();
21274   resultobj = SWIG_From_double(static_cast< double >(result));
21275   return resultobj;
21276 fail:
21277   return NULL;
21278 }
21279
21280
21281 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21282   PyObject *resultobj = 0;
21283   Hex::Document *arg1 = (Hex::Document *) 0 ;
21284   double arg2 ;
21285   double arg3 ;
21286   double arg4 ;
21287   Hex::Vertex *result = 0 ;
21288   void *argp1 = 0 ;
21289   int res1 = 0 ;
21290   double val2 ;
21291   int ecode2 = 0 ;
21292   double val3 ;
21293   int ecode3 = 0 ;
21294   double val4 ;
21295   int ecode4 = 0 ;
21296   PyObject * obj0 = 0 ;
21297   PyObject * obj1 = 0 ;
21298   PyObject * obj2 = 0 ;
21299   PyObject * obj3 = 0 ;
21300
21301   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21302   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21303   if (!SWIG_IsOK(res1)) {
21304     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
21305   }
21306   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21307   ecode2 = SWIG_AsVal_double(obj1, &val2);
21308   if (!SWIG_IsOK(ecode2)) {
21309     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
21310   }
21311   arg2 = static_cast< double >(val2);
21312   ecode3 = SWIG_AsVal_double(obj2, &val3);
21313   if (!SWIG_IsOK(ecode3)) {
21314     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVertex" "', argument " "3"" of type '" "double""'");
21315   }
21316   arg3 = static_cast< double >(val3);
21317   ecode4 = SWIG_AsVal_double(obj3, &val4);
21318   if (!SWIG_IsOK(ecode4)) {
21319     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_addVertex" "', argument " "4"" of type '" "double""'");
21320   }
21321   arg4 = static_cast< double >(val4);
21322   result = (Hex::Vertex *)(arg1)->addVertex(arg2,arg3,arg4);
21323   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21324   return resultobj;
21325 fail:
21326   return NULL;
21327 }
21328
21329
21330 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21331   PyObject *resultobj = 0;
21332   Hex::Document *arg1 = (Hex::Document *) 0 ;
21333   double arg2 ;
21334   double arg3 ;
21335   Hex::Vertex *result = 0 ;
21336   void *argp1 = 0 ;
21337   int res1 = 0 ;
21338   double val2 ;
21339   int ecode2 = 0 ;
21340   double val3 ;
21341   int ecode3 = 0 ;
21342   PyObject * obj0 = 0 ;
21343   PyObject * obj1 = 0 ;
21344   PyObject * obj2 = 0 ;
21345
21346   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVertex",&obj0,&obj1,&obj2)) SWIG_fail;
21347   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21348   if (!SWIG_IsOK(res1)) {
21349     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
21350   }
21351   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21352   ecode2 = SWIG_AsVal_double(obj1, &val2);
21353   if (!SWIG_IsOK(ecode2)) {
21354     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
21355   }
21356   arg2 = static_cast< double >(val2);
21357   ecode3 = SWIG_AsVal_double(obj2, &val3);
21358   if (!SWIG_IsOK(ecode3)) {
21359     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVertex" "', argument " "3"" of type '" "double""'");
21360   }
21361   arg3 = static_cast< double >(val3);
21362   result = (Hex::Vertex *)(arg1)->addVertex(arg2,arg3);
21363   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21364   return resultobj;
21365 fail:
21366   return NULL;
21367 }
21368
21369
21370 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21371   PyObject *resultobj = 0;
21372   Hex::Document *arg1 = (Hex::Document *) 0 ;
21373   double arg2 ;
21374   Hex::Vertex *result = 0 ;
21375   void *argp1 = 0 ;
21376   int res1 = 0 ;
21377   double val2 ;
21378   int ecode2 = 0 ;
21379   PyObject * obj0 = 0 ;
21380   PyObject * obj1 = 0 ;
21381
21382   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertex",&obj0,&obj1)) SWIG_fail;
21383   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21384   if (!SWIG_IsOK(res1)) {
21385     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
21386   }
21387   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21388   ecode2 = SWIG_AsVal_double(obj1, &val2);
21389   if (!SWIG_IsOK(ecode2)) {
21390     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
21391   }
21392   arg2 = static_cast< double >(val2);
21393   result = (Hex::Vertex *)(arg1)->addVertex(arg2);
21394   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21395   return resultobj;
21396 fail:
21397   return NULL;
21398 }
21399
21400
21401 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21402   PyObject *resultobj = 0;
21403   Hex::Document *arg1 = (Hex::Document *) 0 ;
21404   Hex::Vertex *result = 0 ;
21405   void *argp1 = 0 ;
21406   int res1 = 0 ;
21407   PyObject * obj0 = 0 ;
21408
21409   if (!PyArg_ParseTuple(args,(char *)"O:Document_addVertex",&obj0)) SWIG_fail;
21410   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21411   if (!SWIG_IsOK(res1)) {
21412     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
21413   }
21414   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21415   result = (Hex::Vertex *)(arg1)->addVertex();
21416   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21417   return resultobj;
21418 fail:
21419   return NULL;
21420 }
21421
21422
21423 SWIGINTERN PyObject *_wrap_Document_addVertex(PyObject *self, PyObject *args) {
21424   int argc;
21425   PyObject *argv[5];
21426   int ii;
21427
21428   if (!PyTuple_Check(args)) SWIG_fail;
21429   argc = PyObject_Length(args);
21430   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
21431     argv[ii] = PyTuple_GET_ITEM(args,ii);
21432   }
21433   if (argc == 1) {
21434     int _v;
21435     void *vptr = 0;
21436     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21437     _v = SWIG_CheckState(res);
21438     if (_v) {
21439       return _wrap_Document_addVertex__SWIG_3(self, args);
21440     }
21441   }
21442   if (argc == 2) {
21443     int _v;
21444     void *vptr = 0;
21445     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21446     _v = SWIG_CheckState(res);
21447     if (_v) {
21448       {
21449         int res = SWIG_AsVal_double(argv[1], NULL);
21450         _v = SWIG_CheckState(res);
21451       }
21452       if (_v) {
21453         return _wrap_Document_addVertex__SWIG_2(self, args);
21454       }
21455     }
21456   }
21457   if (argc == 3) {
21458     int _v;
21459     void *vptr = 0;
21460     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21461     _v = SWIG_CheckState(res);
21462     if (_v) {
21463       {
21464         int res = SWIG_AsVal_double(argv[1], NULL);
21465         _v = SWIG_CheckState(res);
21466       }
21467       if (_v) {
21468         {
21469           int res = SWIG_AsVal_double(argv[2], NULL);
21470           _v = SWIG_CheckState(res);
21471         }
21472         if (_v) {
21473           return _wrap_Document_addVertex__SWIG_1(self, args);
21474         }
21475       }
21476     }
21477   }
21478   if (argc == 4) {
21479     int _v;
21480     void *vptr = 0;
21481     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21482     _v = SWIG_CheckState(res);
21483     if (_v) {
21484       {
21485         int res = SWIG_AsVal_double(argv[1], NULL);
21486         _v = SWIG_CheckState(res);
21487       }
21488       if (_v) {
21489         {
21490           int res = SWIG_AsVal_double(argv[2], NULL);
21491           _v = SWIG_CheckState(res);
21492         }
21493         if (_v) {
21494           {
21495             int res = SWIG_AsVal_double(argv[3], NULL);
21496             _v = SWIG_CheckState(res);
21497           }
21498           if (_v) {
21499             return _wrap_Document_addVertex__SWIG_0(self, args);
21500           }
21501         }
21502       }
21503     }
21504   }
21505
21506 fail:
21507   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addVertex'.\n  Possible C/C++ prototypes are:\n    addVertex(double,double,double)\n    addVertex(double,double)\n    addVertex(double)\n    addVertex()\n");
21508   return NULL;
21509 }
21510
21511
21512 SWIGINTERN PyObject *_wrap_Document_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21513   PyObject *resultobj = 0;
21514   Hex::Document *arg1 = (Hex::Document *) 0 ;
21515   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21516   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
21517   Hex::Edge *result = 0 ;
21518   void *argp1 = 0 ;
21519   int res1 = 0 ;
21520   void *argp2 = 0 ;
21521   int res2 = 0 ;
21522   void *argp3 = 0 ;
21523   int res3 = 0 ;
21524   PyObject * obj0 = 0 ;
21525   PyObject * obj1 = 0 ;
21526   PyObject * obj2 = 0 ;
21527
21528   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdge",&obj0,&obj1,&obj2)) SWIG_fail;
21529   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21530   if (!SWIG_IsOK(res1)) {
21531     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdge" "', argument " "1"" of type '" "Hex::Document *""'");
21532   }
21533   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21534   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21535   if (!SWIG_IsOK(res2)) {
21536     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdge" "', argument " "2"" of type '" "Hex::Vertex *""'");
21537   }
21538   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21539   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21540   if (!SWIG_IsOK(res3)) {
21541     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addEdge" "', argument " "3"" of type '" "Hex::Vertex *""'");
21542   }
21543   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
21544   result = (Hex::Edge *)(arg1)->addEdge(arg2,arg3);
21545   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
21546   return resultobj;
21547 fail:
21548   return NULL;
21549 }
21550
21551
21552 SWIGINTERN PyObject *_wrap_Document_addEdgeVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21553   PyObject *resultobj = 0;
21554   Hex::Document *arg1 = (Hex::Document *) 0 ;
21555   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21556   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
21557   Hex::Edge *result = 0 ;
21558   void *argp1 = 0 ;
21559   int res1 = 0 ;
21560   void *argp2 = 0 ;
21561   int res2 = 0 ;
21562   void *argp3 = 0 ;
21563   int res3 = 0 ;
21564   PyObject * obj0 = 0 ;
21565   PyObject * obj1 = 0 ;
21566   PyObject * obj2 = 0 ;
21567
21568   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdgeVector",&obj0,&obj1,&obj2)) SWIG_fail;
21569   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21570   if (!SWIG_IsOK(res1)) {
21571     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeVector" "', argument " "1"" of type '" "Hex::Document *""'");
21572   }
21573   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21574   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21575   if (!SWIG_IsOK(res2)) {
21576     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeVector" "', argument " "2"" of type '" "Hex::Vertex *""'");
21577   }
21578   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21579   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
21580   if (!SWIG_IsOK(res3)) {
21581     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addEdgeVector" "', argument " "3"" of type '" "Hex::Vector *""'");
21582   }
21583   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
21584   result = (Hex::Edge *)(arg1)->addEdgeVector(arg2,arg3);
21585   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
21586   return resultobj;
21587 fail:
21588   return NULL;
21589 }
21590
21591
21592 SWIGINTERN PyObject *_wrap_Document_addQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21593   PyObject *resultobj = 0;
21594   Hex::Document *arg1 = (Hex::Document *) 0 ;
21595   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
21596   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
21597   Hex::Edge *arg4 = (Hex::Edge *) 0 ;
21598   Hex::Edge *arg5 = (Hex::Edge *) 0 ;
21599   Hex::Quad *result = 0 ;
21600   void *argp1 = 0 ;
21601   int res1 = 0 ;
21602   void *argp2 = 0 ;
21603   int res2 = 0 ;
21604   void *argp3 = 0 ;
21605   int res3 = 0 ;
21606   void *argp4 = 0 ;
21607   int res4 = 0 ;
21608   void *argp5 = 0 ;
21609   int res5 = 0 ;
21610   PyObject * obj0 = 0 ;
21611   PyObject * obj1 = 0 ;
21612   PyObject * obj2 = 0 ;
21613   PyObject * obj3 = 0 ;
21614   PyObject * obj4 = 0 ;
21615
21616   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21617   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21618   if (!SWIG_IsOK(res1)) {
21619     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuad" "', argument " "1"" of type '" "Hex::Document *""'");
21620   }
21621   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21622   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
21623   if (!SWIG_IsOK(res2)) {
21624     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuad" "', argument " "2"" of type '" "Hex::Edge *""'");
21625   }
21626   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
21627   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
21628   if (!SWIG_IsOK(res3)) {
21629     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addQuad" "', argument " "3"" of type '" "Hex::Edge *""'");
21630   }
21631   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
21632   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Edge, 0 |  0 );
21633   if (!SWIG_IsOK(res4)) {
21634     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addQuad" "', argument " "4"" of type '" "Hex::Edge *""'");
21635   }
21636   arg4 = reinterpret_cast< Hex::Edge * >(argp4);
21637   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Edge, 0 |  0 );
21638   if (!SWIG_IsOK(res5)) {
21639     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addQuad" "', argument " "5"" of type '" "Hex::Edge *""'");
21640   }
21641   arg5 = reinterpret_cast< Hex::Edge * >(argp5);
21642   result = (Hex::Quad *)(arg1)->addQuad(arg2,arg3,arg4,arg5);
21643   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
21644   return resultobj;
21645 fail:
21646   return NULL;
21647 }
21648
21649
21650 SWIGINTERN PyObject *_wrap_Document_addQuadVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21651   PyObject *resultobj = 0;
21652   Hex::Document *arg1 = (Hex::Document *) 0 ;
21653   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21654   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
21655   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
21656   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
21657   Hex::Quad *result = 0 ;
21658   void *argp1 = 0 ;
21659   int res1 = 0 ;
21660   void *argp2 = 0 ;
21661   int res2 = 0 ;
21662   void *argp3 = 0 ;
21663   int res3 = 0 ;
21664   void *argp4 = 0 ;
21665   int res4 = 0 ;
21666   void *argp5 = 0 ;
21667   int res5 = 0 ;
21668   PyObject * obj0 = 0 ;
21669   PyObject * obj1 = 0 ;
21670   PyObject * obj2 = 0 ;
21671   PyObject * obj3 = 0 ;
21672   PyObject * obj4 = 0 ;
21673
21674   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuadVertices",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21675   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21676   if (!SWIG_IsOK(res1)) {
21677     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadVertices" "', argument " "1"" of type '" "Hex::Document *""'");
21678   }
21679   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21680   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21681   if (!SWIG_IsOK(res2)) {
21682     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
21683   }
21684   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21685   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21686   if (!SWIG_IsOK(res3)) {
21687     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addQuadVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
21688   }
21689   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
21690   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21691   if (!SWIG_IsOK(res4)) {
21692     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addQuadVertices" "', argument " "4"" of type '" "Hex::Vertex *""'");
21693   }
21694   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
21695   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21696   if (!SWIG_IsOK(res5)) {
21697     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addQuadVertices" "', argument " "5"" of type '" "Hex::Vertex *""'");
21698   }
21699   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
21700   result = (Hex::Quad *)(arg1)->addQuadVertices(arg2,arg3,arg4,arg5);
21701   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
21702   return resultobj;
21703 fail:
21704   return NULL;
21705 }
21706
21707
21708 SWIGINTERN PyObject *_wrap_Document_addHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21709   PyObject *resultobj = 0;
21710   Hex::Document *arg1 = (Hex::Document *) 0 ;
21711   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
21712   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
21713   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
21714   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
21715   Hex::Quad *arg6 = (Hex::Quad *) 0 ;
21716   Hex::Quad *arg7 = (Hex::Quad *) 0 ;
21717   Hex::Hexa *result = 0 ;
21718   void *argp1 = 0 ;
21719   int res1 = 0 ;
21720   void *argp2 = 0 ;
21721   int res2 = 0 ;
21722   void *argp3 = 0 ;
21723   int res3 = 0 ;
21724   void *argp4 = 0 ;
21725   int res4 = 0 ;
21726   void *argp5 = 0 ;
21727   int res5 = 0 ;
21728   void *argp6 = 0 ;
21729   int res6 = 0 ;
21730   void *argp7 = 0 ;
21731   int res7 = 0 ;
21732   PyObject * obj0 = 0 ;
21733   PyObject * obj1 = 0 ;
21734   PyObject * obj2 = 0 ;
21735   PyObject * obj3 = 0 ;
21736   PyObject * obj4 = 0 ;
21737   PyObject * obj5 = 0 ;
21738   PyObject * obj6 = 0 ;
21739
21740   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_addHexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
21741   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21742   if (!SWIG_IsOK(res1)) {
21743     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa" "', argument " "1"" of type '" "Hex::Document *""'");
21744   }
21745   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21746   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21747   if (!SWIG_IsOK(res2)) {
21748     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa" "', argument " "2"" of type '" "Hex::Quad *""'");
21749   }
21750   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
21751   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21752   if (!SWIG_IsOK(res3)) {
21753     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa" "', argument " "3"" of type '" "Hex::Quad *""'");
21754   }
21755   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
21756   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21757   if (!SWIG_IsOK(res4)) {
21758     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa" "', argument " "4"" of type '" "Hex::Quad *""'");
21759   }
21760   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
21761   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21762   if (!SWIG_IsOK(res5)) {
21763     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa" "', argument " "5"" of type '" "Hex::Quad *""'");
21764   }
21765   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
21766   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21767   if (!SWIG_IsOK(res6)) {
21768     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexa" "', argument " "6"" of type '" "Hex::Quad *""'");
21769   }
21770   arg6 = reinterpret_cast< Hex::Quad * >(argp6);
21771   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21772   if (!SWIG_IsOK(res7)) {
21773     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_addHexa" "', argument " "7"" of type '" "Hex::Quad *""'");
21774   }
21775   arg7 = reinterpret_cast< Hex::Quad * >(argp7);
21776   result = (Hex::Hexa *)(arg1)->addHexa(arg2,arg3,arg4,arg5,arg6,arg7);
21777   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
21778   return resultobj;
21779 fail:
21780   return NULL;
21781 }
21782
21783
21784 SWIGINTERN PyObject *_wrap_Document_addHexaVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21785   PyObject *resultobj = 0;
21786   Hex::Document *arg1 = (Hex::Document *) 0 ;
21787   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21788   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
21789   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
21790   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
21791   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
21792   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
21793   Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
21794   Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
21795   Hex::Hexa *result = 0 ;
21796   void *argp1 = 0 ;
21797   int res1 = 0 ;
21798   void *argp2 = 0 ;
21799   int res2 = 0 ;
21800   void *argp3 = 0 ;
21801   int res3 = 0 ;
21802   void *argp4 = 0 ;
21803   int res4 = 0 ;
21804   void *argp5 = 0 ;
21805   int res5 = 0 ;
21806   void *argp6 = 0 ;
21807   int res6 = 0 ;
21808   void *argp7 = 0 ;
21809   int res7 = 0 ;
21810   void *argp8 = 0 ;
21811   int res8 = 0 ;
21812   void *argp9 = 0 ;
21813   int res9 = 0 ;
21814   PyObject * obj0 = 0 ;
21815   PyObject * obj1 = 0 ;
21816   PyObject * obj2 = 0 ;
21817   PyObject * obj3 = 0 ;
21818   PyObject * obj4 = 0 ;
21819   PyObject * obj5 = 0 ;
21820   PyObject * obj6 = 0 ;
21821   PyObject * obj7 = 0 ;
21822   PyObject * obj8 = 0 ;
21823
21824   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_addHexaVertices",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
21825   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21826   if (!SWIG_IsOK(res1)) {
21827     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaVertices" "', argument " "1"" of type '" "Hex::Document *""'");
21828   }
21829   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21830   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21831   if (!SWIG_IsOK(res2)) {
21832     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
21833   }
21834   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21835   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21836   if (!SWIG_IsOK(res3)) {
21837     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexaVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
21838   }
21839   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
21840   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21841   if (!SWIG_IsOK(res4)) {
21842     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexaVertices" "', argument " "4"" of type '" "Hex::Vertex *""'");
21843   }
21844   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
21845   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21846   if (!SWIG_IsOK(res5)) {
21847     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexaVertices" "', argument " "5"" of type '" "Hex::Vertex *""'");
21848   }
21849   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
21850   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21851   if (!SWIG_IsOK(res6)) {
21852     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexaVertices" "', argument " "6"" of type '" "Hex::Vertex *""'");
21853   }
21854   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
21855   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21856   if (!SWIG_IsOK(res7)) {
21857     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_addHexaVertices" "', argument " "7"" of type '" "Hex::Vertex *""'");
21858   }
21859   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
21860   res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21861   if (!SWIG_IsOK(res8)) {
21862     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_addHexaVertices" "', argument " "8"" of type '" "Hex::Vertex *""'");
21863   }
21864   arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
21865   res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21866   if (!SWIG_IsOK(res9)) {
21867     SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Document_addHexaVertices" "', argument " "9"" of type '" "Hex::Vertex *""'");
21868   }
21869   arg9 = reinterpret_cast< Hex::Vertex * >(argp9);
21870   result = (Hex::Hexa *)(arg1)->addHexaVertices(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
21871   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
21872   return resultobj;
21873 fail:
21874   return NULL;
21875 }
21876
21877
21878 SWIGINTERN PyObject *_wrap_Document_addHexa2Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21879   PyObject *resultobj = 0;
21880   Hex::Document *arg1 = (Hex::Document *) 0 ;
21881   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
21882   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
21883   Hex::Hexa *result = 0 ;
21884   void *argp1 = 0 ;
21885   int res1 = 0 ;
21886   void *argp2 = 0 ;
21887   int res2 = 0 ;
21888   void *argp3 = 0 ;
21889   int res3 = 0 ;
21890   PyObject * obj0 = 0 ;
21891   PyObject * obj1 = 0 ;
21892   PyObject * obj2 = 0 ;
21893
21894   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addHexa2Quads",&obj0,&obj1,&obj2)) SWIG_fail;
21895   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21896   if (!SWIG_IsOK(res1)) {
21897     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa2Quads" "', argument " "1"" of type '" "Hex::Document *""'");
21898   }
21899   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21900   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21901   if (!SWIG_IsOK(res2)) {
21902     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa2Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
21903   }
21904   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
21905   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21906   if (!SWIG_IsOK(res3)) {
21907     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa2Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
21908   }
21909   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
21910   result = (Hex::Hexa *)(arg1)->addHexa2Quads(arg2,arg3);
21911   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
21912   return resultobj;
21913 fail:
21914   return NULL;
21915 }
21916
21917
21918 SWIGINTERN PyObject *_wrap_Document_addHexa3Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21919   PyObject *resultobj = 0;
21920   Hex::Document *arg1 = (Hex::Document *) 0 ;
21921   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
21922   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
21923   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
21924   Hex::Hexa *result = 0 ;
21925   void *argp1 = 0 ;
21926   int res1 = 0 ;
21927   void *argp2 = 0 ;
21928   int res2 = 0 ;
21929   void *argp3 = 0 ;
21930   int res3 = 0 ;
21931   void *argp4 = 0 ;
21932   int res4 = 0 ;
21933   PyObject * obj0 = 0 ;
21934   PyObject * obj1 = 0 ;
21935   PyObject * obj2 = 0 ;
21936   PyObject * obj3 = 0 ;
21937
21938   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addHexa3Quads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21939   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21940   if (!SWIG_IsOK(res1)) {
21941     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa3Quads" "', argument " "1"" of type '" "Hex::Document *""'");
21942   }
21943   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21944   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21945   if (!SWIG_IsOK(res2)) {
21946     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa3Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
21947   }
21948   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
21949   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21950   if (!SWIG_IsOK(res3)) {
21951     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa3Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
21952   }
21953   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
21954   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21955   if (!SWIG_IsOK(res4)) {
21956     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa3Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
21957   }
21958   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
21959   result = (Hex::Hexa *)(arg1)->addHexa3Quads(arg2,arg3,arg4);
21960   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
21961   return resultobj;
21962 fail:
21963   return NULL;
21964 }
21965
21966
21967 SWIGINTERN PyObject *_wrap_Document_addHexa4Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21968   PyObject *resultobj = 0;
21969   Hex::Document *arg1 = (Hex::Document *) 0 ;
21970   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
21971   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
21972   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
21973   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
21974   Hex::Hexa *result = 0 ;
21975   void *argp1 = 0 ;
21976   int res1 = 0 ;
21977   void *argp2 = 0 ;
21978   int res2 = 0 ;
21979   void *argp3 = 0 ;
21980   int res3 = 0 ;
21981   void *argp4 = 0 ;
21982   int res4 = 0 ;
21983   void *argp5 = 0 ;
21984   int res5 = 0 ;
21985   PyObject * obj0 = 0 ;
21986   PyObject * obj1 = 0 ;
21987   PyObject * obj2 = 0 ;
21988   PyObject * obj3 = 0 ;
21989   PyObject * obj4 = 0 ;
21990
21991   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addHexa4Quads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21992   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21993   if (!SWIG_IsOK(res1)) {
21994     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa4Quads" "', argument " "1"" of type '" "Hex::Document *""'");
21995   }
21996   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21997   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
21998   if (!SWIG_IsOK(res2)) {
21999     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa4Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
22000   }
22001   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
22002   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22003   if (!SWIG_IsOK(res3)) {
22004     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa4Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
22005   }
22006   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
22007   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22008   if (!SWIG_IsOK(res4)) {
22009     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa4Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
22010   }
22011   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
22012   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22013   if (!SWIG_IsOK(res5)) {
22014     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa4Quads" "', argument " "5"" of type '" "Hex::Quad *""'");
22015   }
22016   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
22017   result = (Hex::Hexa *)(arg1)->addHexa4Quads(arg2,arg3,arg4,arg5);
22018   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
22019   return resultobj;
22020 fail:
22021   return NULL;
22022 }
22023
22024
22025 SWIGINTERN PyObject *_wrap_Document_addHexa5Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22026   PyObject *resultobj = 0;
22027   Hex::Document *arg1 = (Hex::Document *) 0 ;
22028   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
22029   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
22030   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
22031   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
22032   Hex::Quad *arg6 = (Hex::Quad *) 0 ;
22033   Hex::Hexa *result = 0 ;
22034   void *argp1 = 0 ;
22035   int res1 = 0 ;
22036   void *argp2 = 0 ;
22037   int res2 = 0 ;
22038   void *argp3 = 0 ;
22039   int res3 = 0 ;
22040   void *argp4 = 0 ;
22041   int res4 = 0 ;
22042   void *argp5 = 0 ;
22043   int res5 = 0 ;
22044   void *argp6 = 0 ;
22045   int res6 = 0 ;
22046   PyObject * obj0 = 0 ;
22047   PyObject * obj1 = 0 ;
22048   PyObject * obj2 = 0 ;
22049   PyObject * obj3 = 0 ;
22050   PyObject * obj4 = 0 ;
22051   PyObject * obj5 = 0 ;
22052
22053   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_addHexa5Quads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
22054   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22055   if (!SWIG_IsOK(res1)) {
22056     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa5Quads" "', argument " "1"" of type '" "Hex::Document *""'");
22057   }
22058   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22059   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22060   if (!SWIG_IsOK(res2)) {
22061     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa5Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
22062   }
22063   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
22064   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22065   if (!SWIG_IsOK(res3)) {
22066     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa5Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
22067   }
22068   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
22069   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22070   if (!SWIG_IsOK(res4)) {
22071     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa5Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
22072   }
22073   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
22074   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22075   if (!SWIG_IsOK(res5)) {
22076     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa5Quads" "', argument " "5"" of type '" "Hex::Quad *""'");
22077   }
22078   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
22079   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 |  0 );
22080   if (!SWIG_IsOK(res6)) {
22081     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexa5Quads" "', argument " "6"" of type '" "Hex::Quad *""'");
22082   }
22083   arg6 = reinterpret_cast< Hex::Quad * >(argp6);
22084   result = (Hex::Hexa *)(arg1)->addHexa5Quads(arg2,arg3,arg4,arg5,arg6);
22085   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
22086   return resultobj;
22087 fail:
22088   return NULL;
22089 }
22090
22091
22092 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22093   PyObject *resultobj = 0;
22094   Hex::Document *arg1 = (Hex::Document *) 0 ;
22095   double arg2 ;
22096   double arg3 ;
22097   double arg4 ;
22098   Hex::Vector *result = 0 ;
22099   void *argp1 = 0 ;
22100   int res1 = 0 ;
22101   double val2 ;
22102   int ecode2 = 0 ;
22103   double val3 ;
22104   int ecode3 = 0 ;
22105   double val4 ;
22106   int ecode4 = 0 ;
22107   PyObject * obj0 = 0 ;
22108   PyObject * obj1 = 0 ;
22109   PyObject * obj2 = 0 ;
22110   PyObject * obj3 = 0 ;
22111
22112   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22113   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22114   if (!SWIG_IsOK(res1)) {
22115     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
22116   }
22117   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22118   ecode2 = SWIG_AsVal_double(obj1, &val2);
22119   if (!SWIG_IsOK(ecode2)) {
22120     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
22121   }
22122   arg2 = static_cast< double >(val2);
22123   ecode3 = SWIG_AsVal_double(obj2, &val3);
22124   if (!SWIG_IsOK(ecode3)) {
22125     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVector" "', argument " "3"" of type '" "double""'");
22126   }
22127   arg3 = static_cast< double >(val3);
22128   ecode4 = SWIG_AsVal_double(obj3, &val4);
22129   if (!SWIG_IsOK(ecode4)) {
22130     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_addVector" "', argument " "4"" of type '" "double""'");
22131   }
22132   arg4 = static_cast< double >(val4);
22133   result = (Hex::Vector *)(arg1)->addVector(arg2,arg3,arg4);
22134   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
22135   return resultobj;
22136 fail:
22137   return NULL;
22138 }
22139
22140
22141 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22142   PyObject *resultobj = 0;
22143   Hex::Document *arg1 = (Hex::Document *) 0 ;
22144   double arg2 ;
22145   double arg3 ;
22146   Hex::Vector *result = 0 ;
22147   void *argp1 = 0 ;
22148   int res1 = 0 ;
22149   double val2 ;
22150   int ecode2 = 0 ;
22151   double val3 ;
22152   int ecode3 = 0 ;
22153   PyObject * obj0 = 0 ;
22154   PyObject * obj1 = 0 ;
22155   PyObject * obj2 = 0 ;
22156
22157   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVector",&obj0,&obj1,&obj2)) SWIG_fail;
22158   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22159   if (!SWIG_IsOK(res1)) {
22160     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
22161   }
22162   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22163   ecode2 = SWIG_AsVal_double(obj1, &val2);
22164   if (!SWIG_IsOK(ecode2)) {
22165     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
22166   }
22167   arg2 = static_cast< double >(val2);
22168   ecode3 = SWIG_AsVal_double(obj2, &val3);
22169   if (!SWIG_IsOK(ecode3)) {
22170     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVector" "', argument " "3"" of type '" "double""'");
22171   }
22172   arg3 = static_cast< double >(val3);
22173   result = (Hex::Vector *)(arg1)->addVector(arg2,arg3);
22174   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
22175   return resultobj;
22176 fail:
22177   return NULL;
22178 }
22179
22180
22181 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22182   PyObject *resultobj = 0;
22183   Hex::Document *arg1 = (Hex::Document *) 0 ;
22184   double arg2 ;
22185   Hex::Vector *result = 0 ;
22186   void *argp1 = 0 ;
22187   int res1 = 0 ;
22188   double val2 ;
22189   int ecode2 = 0 ;
22190   PyObject * obj0 = 0 ;
22191   PyObject * obj1 = 0 ;
22192
22193   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVector",&obj0,&obj1)) SWIG_fail;
22194   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22195   if (!SWIG_IsOK(res1)) {
22196     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
22197   }
22198   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22199   ecode2 = SWIG_AsVal_double(obj1, &val2);
22200   if (!SWIG_IsOK(ecode2)) {
22201     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
22202   }
22203   arg2 = static_cast< double >(val2);
22204   result = (Hex::Vector *)(arg1)->addVector(arg2);
22205   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
22206   return resultobj;
22207 fail:
22208   return NULL;
22209 }
22210
22211
22212 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22213   PyObject *resultobj = 0;
22214   Hex::Document *arg1 = (Hex::Document *) 0 ;
22215   Hex::Vector *result = 0 ;
22216   void *argp1 = 0 ;
22217   int res1 = 0 ;
22218   PyObject * obj0 = 0 ;
22219
22220   if (!PyArg_ParseTuple(args,(char *)"O:Document_addVector",&obj0)) SWIG_fail;
22221   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22222   if (!SWIG_IsOK(res1)) {
22223     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
22224   }
22225   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22226   result = (Hex::Vector *)(arg1)->addVector();
22227   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
22228   return resultobj;
22229 fail:
22230   return NULL;
22231 }
22232
22233
22234 SWIGINTERN PyObject *_wrap_Document_addVector(PyObject *self, PyObject *args) {
22235   int argc;
22236   PyObject *argv[5];
22237   int ii;
22238
22239   if (!PyTuple_Check(args)) SWIG_fail;
22240   argc = PyObject_Length(args);
22241   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
22242     argv[ii] = PyTuple_GET_ITEM(args,ii);
22243   }
22244   if (argc == 1) {
22245     int _v;
22246     void *vptr = 0;
22247     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22248     _v = SWIG_CheckState(res);
22249     if (_v) {
22250       return _wrap_Document_addVector__SWIG_3(self, args);
22251     }
22252   }
22253   if (argc == 2) {
22254     int _v;
22255     void *vptr = 0;
22256     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22257     _v = SWIG_CheckState(res);
22258     if (_v) {
22259       {
22260         int res = SWIG_AsVal_double(argv[1], NULL);
22261         _v = SWIG_CheckState(res);
22262       }
22263       if (_v) {
22264         return _wrap_Document_addVector__SWIG_2(self, args);
22265       }
22266     }
22267   }
22268   if (argc == 3) {
22269     int _v;
22270     void *vptr = 0;
22271     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22272     _v = SWIG_CheckState(res);
22273     if (_v) {
22274       {
22275         int res = SWIG_AsVal_double(argv[1], NULL);
22276         _v = SWIG_CheckState(res);
22277       }
22278       if (_v) {
22279         {
22280           int res = SWIG_AsVal_double(argv[2], NULL);
22281           _v = SWIG_CheckState(res);
22282         }
22283         if (_v) {
22284           return _wrap_Document_addVector__SWIG_1(self, args);
22285         }
22286       }
22287     }
22288   }
22289   if (argc == 4) {
22290     int _v;
22291     void *vptr = 0;
22292     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22293     _v = SWIG_CheckState(res);
22294     if (_v) {
22295       {
22296         int res = SWIG_AsVal_double(argv[1], NULL);
22297         _v = SWIG_CheckState(res);
22298       }
22299       if (_v) {
22300         {
22301           int res = SWIG_AsVal_double(argv[2], NULL);
22302           _v = SWIG_CheckState(res);
22303         }
22304         if (_v) {
22305           {
22306             int res = SWIG_AsVal_double(argv[3], NULL);
22307             _v = SWIG_CheckState(res);
22308           }
22309           if (_v) {
22310             return _wrap_Document_addVector__SWIG_0(self, args);
22311           }
22312         }
22313       }
22314     }
22315   }
22316
22317 fail:
22318   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addVector'.\n  Possible C/C++ prototypes are:\n    addVector(double,double,double)\n    addVector(double,double)\n    addVector(double)\n    addVector()\n");
22319   return NULL;
22320 }
22321
22322
22323 SWIGINTERN PyObject *_wrap_Document_addVectorVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22324   PyObject *resultobj = 0;
22325   Hex::Document *arg1 = (Hex::Document *) 0 ;
22326   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
22327   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22328   Hex::Vector *result = 0 ;
22329   void *argp1 = 0 ;
22330   int res1 = 0 ;
22331   void *argp2 = 0 ;
22332   int res2 = 0 ;
22333   void *argp3 = 0 ;
22334   int res3 = 0 ;
22335   PyObject * obj0 = 0 ;
22336   PyObject * obj1 = 0 ;
22337   PyObject * obj2 = 0 ;
22338
22339   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVectorVertices",&obj0,&obj1,&obj2)) SWIG_fail;
22340   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22341   if (!SWIG_IsOK(res1)) {
22342     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVectorVertices" "', argument " "1"" of type '" "Hex::Document *""'");
22343   }
22344   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22345   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22346   if (!SWIG_IsOK(res2)) {
22347     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addVectorVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
22348   }
22349   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
22350   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22351   if (!SWIG_IsOK(res3)) {
22352     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addVectorVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
22353   }
22354   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22355   result = (Hex::Vector *)(arg1)->addVectorVertices(arg2,arg3);
22356   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
22357   return resultobj;
22358 fail:
22359   return NULL;
22360 }
22361
22362
22363 SWIGINTERN PyObject *_wrap_Document_addLaw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22364   PyObject *resultobj = 0;
22365   Hex::Document *arg1 = (Hex::Document *) 0 ;
22366   char *arg2 = (char *) 0 ;
22367   int arg3 ;
22368   Hex::Law *result = 0 ;
22369   void *argp1 = 0 ;
22370   int res1 = 0 ;
22371   int res2 ;
22372   char *buf2 = 0 ;
22373   int alloc2 = 0 ;
22374   int val3 ;
22375   int ecode3 = 0 ;
22376   PyObject * obj0 = 0 ;
22377   PyObject * obj1 = 0 ;
22378   PyObject * obj2 = 0 ;
22379
22380   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaw",&obj0,&obj1,&obj2)) SWIG_fail;
22381   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22382   if (!SWIG_IsOK(res1)) {
22383     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaw" "', argument " "1"" of type '" "Hex::Document *""'");
22384   }
22385   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22386   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22387   if (!SWIG_IsOK(res2)) {
22388     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addLaw" "', argument " "2"" of type '" "char const *""'");
22389   }
22390   arg2 = reinterpret_cast< char * >(buf2);
22391   ecode3 = SWIG_AsVal_int(obj2, &val3);
22392   if (!SWIG_IsOK(ecode3)) {
22393     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addLaw" "', argument " "3"" of type '" "int""'");
22394   }
22395   arg3 = static_cast< int >(val3);
22396   result = (Hex::Law *)(arg1)->addLaw((char const *)arg2,arg3);
22397   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
22398   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22399   return resultobj;
22400 fail:
22401   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22402   return NULL;
22403 }
22404
22405
22406 SWIGINTERN PyObject *_wrap_Document_addLaws__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22407   PyObject *resultobj = 0;
22408   Hex::Document *arg1 = (Hex::Document *) 0 ;
22409   double arg2 ;
22410   bool arg3 ;
22411   int result;
22412   void *argp1 = 0 ;
22413   int res1 = 0 ;
22414   double val2 ;
22415   int ecode2 = 0 ;
22416   bool val3 ;
22417   int ecode3 = 0 ;
22418   PyObject * obj0 = 0 ;
22419   PyObject * obj1 = 0 ;
22420   PyObject * obj2 = 0 ;
22421
22422   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaws",&obj0,&obj1,&obj2)) SWIG_fail;
22423   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22424   if (!SWIG_IsOK(res1)) {
22425     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaws" "', argument " "1"" of type '" "Hex::Document *""'");
22426   }
22427   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22428   ecode2 = SWIG_AsVal_double(obj1, &val2);
22429   if (!SWIG_IsOK(ecode2)) {
22430     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addLaws" "', argument " "2"" of type '" "double""'");
22431   }
22432   arg2 = static_cast< double >(val2);
22433   ecode3 = SWIG_AsVal_bool(obj2, &val3);
22434   if (!SWIG_IsOK(ecode3)) {
22435     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addLaws" "', argument " "3"" of type '" "bool""'");
22436   }
22437   arg3 = static_cast< bool >(val3);
22438   result = (int)(arg1)->addLaws(arg2,arg3);
22439   resultobj = SWIG_From_int(static_cast< int >(result));
22440   return resultobj;
22441 fail:
22442   return NULL;
22443 }
22444
22445
22446 SWIGINTERN PyObject *_wrap_Document_addLaws__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22447   PyObject *resultobj = 0;
22448   Hex::Document *arg1 = (Hex::Document *) 0 ;
22449   double arg2 ;
22450   int result;
22451   void *argp1 = 0 ;
22452   int res1 = 0 ;
22453   double val2 ;
22454   int ecode2 = 0 ;
22455   PyObject * obj0 = 0 ;
22456   PyObject * obj1 = 0 ;
22457
22458   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaws",&obj0,&obj1)) SWIG_fail;
22459   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22460   if (!SWIG_IsOK(res1)) {
22461     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaws" "', argument " "1"" of type '" "Hex::Document *""'");
22462   }
22463   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22464   ecode2 = SWIG_AsVal_double(obj1, &val2);
22465   if (!SWIG_IsOK(ecode2)) {
22466     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addLaws" "', argument " "2"" of type '" "double""'");
22467   }
22468   arg2 = static_cast< double >(val2);
22469   result = (int)(arg1)->addLaws(arg2);
22470   resultobj = SWIG_From_int(static_cast< int >(result));
22471   return resultobj;
22472 fail:
22473   return NULL;
22474 }
22475
22476
22477 SWIGINTERN PyObject *_wrap_Document_addLaws(PyObject *self, PyObject *args) {
22478   int argc;
22479   PyObject *argv[4];
22480   int ii;
22481
22482   if (!PyTuple_Check(args)) SWIG_fail;
22483   argc = PyObject_Length(args);
22484   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
22485     argv[ii] = PyTuple_GET_ITEM(args,ii);
22486   }
22487   if (argc == 2) {
22488     int _v;
22489     void *vptr = 0;
22490     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22491     _v = SWIG_CheckState(res);
22492     if (_v) {
22493       {
22494         int res = SWIG_AsVal_double(argv[1], NULL);
22495         _v = SWIG_CheckState(res);
22496       }
22497       if (_v) {
22498         return _wrap_Document_addLaws__SWIG_1(self, args);
22499       }
22500     }
22501   }
22502   if (argc == 3) {
22503     int _v;
22504     void *vptr = 0;
22505     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
22506     _v = SWIG_CheckState(res);
22507     if (_v) {
22508       {
22509         int res = SWIG_AsVal_double(argv[1], NULL);
22510         _v = SWIG_CheckState(res);
22511       }
22512       if (_v) {
22513         {
22514           int res = SWIG_AsVal_bool(argv[2], NULL);
22515           _v = SWIG_CheckState(res);
22516         }
22517         if (_v) {
22518           return _wrap_Document_addLaws__SWIG_0(self, args);
22519         }
22520       }
22521     }
22522   }
22523
22524 fail:
22525   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addLaws'.\n  Possible C/C++ prototypes are:\n    addLaws(double,bool)\n    addLaws(double)\n");
22526   return NULL;
22527 }
22528
22529
22530 SWIGINTERN PyObject *_wrap_Document_addHexaGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22531   PyObject *resultobj = 0;
22532   Hex::Document *arg1 = (Hex::Document *) 0 ;
22533   cpchar arg2 = (cpchar) 0 ;
22534   Hex::Group *result = 0 ;
22535   void *argp1 = 0 ;
22536   int res1 = 0 ;
22537   int res2 ;
22538   char *buf2 = 0 ;
22539   int alloc2 = 0 ;
22540   PyObject * obj0 = 0 ;
22541   PyObject * obj1 = 0 ;
22542
22543   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaGroup",&obj0,&obj1)) SWIG_fail;
22544   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22545   if (!SWIG_IsOK(res1)) {
22546     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22547   }
22548   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22549   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22550   if (!SWIG_IsOK(res2)) {
22551     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaGroup" "', argument " "2"" of type '" "cpchar""'");
22552   }
22553   arg2 = reinterpret_cast< cpchar >(buf2);
22554   result = (Hex::Group *)(arg1)->addHexaGroup(arg2);
22555   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
22556   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22557   return resultobj;
22558 fail:
22559   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22560   return NULL;
22561 }
22562
22563
22564 SWIGINTERN PyObject *_wrap_Document_addQuadGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22565   PyObject *resultobj = 0;
22566   Hex::Document *arg1 = (Hex::Document *) 0 ;
22567   cpchar arg2 = (cpchar) 0 ;
22568   Hex::Group *result = 0 ;
22569   void *argp1 = 0 ;
22570   int res1 = 0 ;
22571   int res2 ;
22572   char *buf2 = 0 ;
22573   int alloc2 = 0 ;
22574   PyObject * obj0 = 0 ;
22575   PyObject * obj1 = 0 ;
22576
22577   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadGroup",&obj0,&obj1)) SWIG_fail;
22578   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22579   if (!SWIG_IsOK(res1)) {
22580     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22581   }
22582   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22583   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22584   if (!SWIG_IsOK(res2)) {
22585     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadGroup" "', argument " "2"" of type '" "cpchar""'");
22586   }
22587   arg2 = reinterpret_cast< cpchar >(buf2);
22588   result = (Hex::Group *)(arg1)->addQuadGroup(arg2);
22589   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
22590   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22591   return resultobj;
22592 fail:
22593   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22594   return NULL;
22595 }
22596
22597
22598 SWIGINTERN PyObject *_wrap_Document_addQuadNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22599   PyObject *resultobj = 0;
22600   Hex::Document *arg1 = (Hex::Document *) 0 ;
22601   cpchar arg2 = (cpchar) 0 ;
22602   Hex::Group *result = 0 ;
22603   void *argp1 = 0 ;
22604   int res1 = 0 ;
22605   int res2 ;
22606   char *buf2 = 0 ;
22607   int alloc2 = 0 ;
22608   PyObject * obj0 = 0 ;
22609   PyObject * obj1 = 0 ;
22610
22611   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadNodeGroup",&obj0,&obj1)) SWIG_fail;
22612   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22613   if (!SWIG_IsOK(res1)) {
22614     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22615   }
22616   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22617   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22618   if (!SWIG_IsOK(res2)) {
22619     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadNodeGroup" "', argument " "2"" of type '" "cpchar""'");
22620   }
22621   arg2 = reinterpret_cast< cpchar >(buf2);
22622   result = (Hex::Group *)(arg1)->addQuadNodeGroup(arg2);
22623   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
22624   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22625   return resultobj;
22626 fail:
22627   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22628   return NULL;
22629 }
22630
22631
22632 SWIGINTERN PyObject *_wrap_Document_addHexaNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22633   PyObject *resultobj = 0;
22634   Hex::Document *arg1 = (Hex::Document *) 0 ;
22635   cpchar arg2 = (cpchar) 0 ;
22636   Hex::Group *result = 0 ;
22637   void *argp1 = 0 ;
22638   int res1 = 0 ;
22639   int res2 ;
22640   char *buf2 = 0 ;
22641   int alloc2 = 0 ;
22642   PyObject * obj0 = 0 ;
22643   PyObject * obj1 = 0 ;
22644
22645   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaNodeGroup",&obj0,&obj1)) SWIG_fail;
22646   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22647   if (!SWIG_IsOK(res1)) {
22648     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22649   }
22650   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22651   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22652   if (!SWIG_IsOK(res2)) {
22653     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaNodeGroup" "', argument " "2"" of type '" "cpchar""'");
22654   }
22655   arg2 = reinterpret_cast< cpchar >(buf2);
22656   result = (Hex::Group *)(arg1)->addHexaNodeGroup(arg2);
22657   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
22658   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22659   return resultobj;
22660 fail:
22661   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22662   return NULL;
22663 }
22664
22665
22666 SWIGINTERN PyObject *_wrap_Document_addEdgeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22667   PyObject *resultobj = 0;
22668   Hex::Document *arg1 = (Hex::Document *) 0 ;
22669   cpchar arg2 = (cpchar) 0 ;
22670   Hex::Group *result = 0 ;
22671   void *argp1 = 0 ;
22672   int res1 = 0 ;
22673   int res2 ;
22674   char *buf2 = 0 ;
22675   int alloc2 = 0 ;
22676   PyObject * obj0 = 0 ;
22677   PyObject * obj1 = 0 ;
22678
22679   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeGroup",&obj0,&obj1)) SWIG_fail;
22680   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22681   if (!SWIG_IsOK(res1)) {
22682     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22683   }
22684   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22685   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22686   if (!SWIG_IsOK(res2)) {
22687     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeGroup" "', argument " "2"" of type '" "cpchar""'");
22688   }
22689   arg2 = reinterpret_cast< cpchar >(buf2);
22690   result = (Hex::Group *)(arg1)->addEdgeGroup(arg2);
22691   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
22692   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22693   return resultobj;
22694 fail:
22695   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22696   return NULL;
22697 }
22698
22699
22700 SWIGINTERN PyObject *_wrap_Document_addEdgeNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22701   PyObject *resultobj = 0;
22702   Hex::Document *arg1 = (Hex::Document *) 0 ;
22703   cpchar arg2 = (cpchar) 0 ;
22704   Hex::Group *result = 0 ;
22705   void *argp1 = 0 ;
22706   int res1 = 0 ;
22707   int res2 ;
22708   char *buf2 = 0 ;
22709   int alloc2 = 0 ;
22710   PyObject * obj0 = 0 ;
22711   PyObject * obj1 = 0 ;
22712
22713   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeNodeGroup",&obj0,&obj1)) SWIG_fail;
22714   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22715   if (!SWIG_IsOK(res1)) {
22716     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22717   }
22718   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22719   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22720   if (!SWIG_IsOK(res2)) {
22721     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeNodeGroup" "', argument " "2"" of type '" "cpchar""'");
22722   }
22723   arg2 = reinterpret_cast< cpchar >(buf2);
22724   result = (Hex::Group *)(arg1)->addEdgeNodeGroup(arg2);
22725   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
22726   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22727   return resultobj;
22728 fail:
22729   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22730   return NULL;
22731 }
22732
22733
22734 SWIGINTERN PyObject *_wrap_Document_addVertexNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22735   PyObject *resultobj = 0;
22736   Hex::Document *arg1 = (Hex::Document *) 0 ;
22737   cpchar arg2 = (cpchar) 0 ;
22738   Hex::Group *result = 0 ;
22739   void *argp1 = 0 ;
22740   int res1 = 0 ;
22741   int res2 ;
22742   char *buf2 = 0 ;
22743   int alloc2 = 0 ;
22744   PyObject * obj0 = 0 ;
22745   PyObject * obj1 = 0 ;
22746
22747   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertexNodeGroup",&obj0,&obj1)) SWIG_fail;
22748   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22749   if (!SWIG_IsOK(res1)) {
22750     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertexNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
22751   }
22752   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22753   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22754   if (!SWIG_IsOK(res2)) {
22755     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addVertexNodeGroup" "', argument " "2"" of type '" "cpchar""'");
22756   }
22757   arg2 = reinterpret_cast< cpchar >(buf2);
22758   result = (Hex::Group *)(arg1)->addVertexNodeGroup(arg2);
22759   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
22760   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22761   return resultobj;
22762 fail:
22763   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22764   return NULL;
22765 }
22766
22767
22768 SWIGINTERN PyObject *_wrap_Document_makeTranslation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769   PyObject *resultobj = 0;
22770   Hex::Document *arg1 = (Hex::Document *) 0 ;
22771   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
22772   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
22773   Hex::Elements *result = 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   PyObject * obj0 = 0 ;
22781   PyObject * obj1 = 0 ;
22782   PyObject * obj2 = 0 ;
22783
22784   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
22785   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22786   if (!SWIG_IsOK(res1)) {
22787     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeTranslation" "', argument " "1"" of type '" "Hex::Document *""'");
22788   }
22789   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22790   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
22791   if (!SWIG_IsOK(res2)) {
22792     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeTranslation" "', argument " "2"" of type '" "Hex::Elements *""'");
22793   }
22794   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
22795   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
22796   if (!SWIG_IsOK(res3)) {
22797     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeTranslation" "', argument " "3"" of type '" "Hex::Vector *""'");
22798   }
22799   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
22800   result = (Hex::Elements *)(arg1)->makeTranslation(arg2,arg3);
22801   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
22802   return resultobj;
22803 fail:
22804   return NULL;
22805 }
22806
22807
22808 SWIGINTERN PyObject *_wrap_Document_makeScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22809   PyObject *resultobj = 0;
22810   Hex::Document *arg1 = (Hex::Document *) 0 ;
22811   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
22812   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22813   double arg4 ;
22814   Hex::Elements *result = 0 ;
22815   void *argp1 = 0 ;
22816   int res1 = 0 ;
22817   void *argp2 = 0 ;
22818   int res2 = 0 ;
22819   void *argp3 = 0 ;
22820   int res3 = 0 ;
22821   double val4 ;
22822   int ecode4 = 0 ;
22823   PyObject * obj0 = 0 ;
22824   PyObject * obj1 = 0 ;
22825   PyObject * obj2 = 0 ;
22826   PyObject * obj3 = 0 ;
22827
22828   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22829   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22830   if (!SWIG_IsOK(res1)) {
22831     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeScale" "', argument " "1"" of type '" "Hex::Document *""'");
22832   }
22833   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22834   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
22835   if (!SWIG_IsOK(res2)) {
22836     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeScale" "', argument " "2"" of type '" "Hex::Elements *""'");
22837   }
22838   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
22839   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22840   if (!SWIG_IsOK(res3)) {
22841     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeScale" "', argument " "3"" of type '" "Hex::Vertex *""'");
22842   }
22843   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22844   ecode4 = SWIG_AsVal_double(obj3, &val4);
22845   if (!SWIG_IsOK(ecode4)) {
22846     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeScale" "', argument " "4"" of type '" "double""'");
22847   }
22848   arg4 = static_cast< double >(val4);
22849   result = (Hex::Elements *)(arg1)->makeScale(arg2,arg3,arg4);
22850   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
22851   return resultobj;
22852 fail:
22853   return NULL;
22854 }
22855
22856
22857 SWIGINTERN PyObject *_wrap_Document_makeRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22858   PyObject *resultobj = 0;
22859   Hex::Document *arg1 = (Hex::Document *) 0 ;
22860   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
22861   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22862   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
22863   double arg5 ;
22864   Hex::Elements *result = 0 ;
22865   void *argp1 = 0 ;
22866   int res1 = 0 ;
22867   void *argp2 = 0 ;
22868   int res2 = 0 ;
22869   void *argp3 = 0 ;
22870   int res3 = 0 ;
22871   void *argp4 = 0 ;
22872   int res4 = 0 ;
22873   double val5 ;
22874   int ecode5 = 0 ;
22875   PyObject * obj0 = 0 ;
22876   PyObject * obj1 = 0 ;
22877   PyObject * obj2 = 0 ;
22878   PyObject * obj3 = 0 ;
22879   PyObject * obj4 = 0 ;
22880
22881   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) 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_makeRotation" "', argument " "1"" of type '" "Hex::Document *""'");
22885   }
22886   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22887   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
22888   if (!SWIG_IsOK(res2)) {
22889     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRotation" "', argument " "2"" of type '" "Hex::Elements *""'");
22890   }
22891   arg2 = reinterpret_cast< Hex::Elements * >(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_makeRotation" "', argument " "3"" of type '" "Hex::Vertex *""'");
22895   }
22896   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22897   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
22898   if (!SWIG_IsOK(res4)) {
22899     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRotation" "', argument " "4"" of type '" "Hex::Vector *""'");
22900   }
22901   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
22902   ecode5 = SWIG_AsVal_double(obj4, &val5);
22903   if (!SWIG_IsOK(ecode5)) {
22904     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeRotation" "', argument " "5"" of type '" "double""'");
22905   }
22906   arg5 = static_cast< double >(val5);
22907   result = (Hex::Elements *)(arg1)->makeRotation(arg2,arg3,arg4,arg5);
22908   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
22909   return resultobj;
22910 fail:
22911   return NULL;
22912 }
22913
22914
22915 SWIGINTERN PyObject *_wrap_Document_makeSymmetryPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22916   PyObject *resultobj = 0;
22917   Hex::Document *arg1 = (Hex::Document *) 0 ;
22918   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
22919   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22920   Hex::Elements *result = 0 ;
22921   void *argp1 = 0 ;
22922   int res1 = 0 ;
22923   void *argp2 = 0 ;
22924   int res2 = 0 ;
22925   void *argp3 = 0 ;
22926   int res3 = 0 ;
22927   PyObject * obj0 = 0 ;
22928   PyObject * obj1 = 0 ;
22929   PyObject * obj2 = 0 ;
22930
22931   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
22932   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22933   if (!SWIG_IsOK(res1)) {
22934     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryPoint" "', argument " "1"" of type '" "Hex::Document *""'");
22935   }
22936   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22937   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
22938   if (!SWIG_IsOK(res2)) {
22939     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryPoint" "', argument " "2"" of type '" "Hex::Elements *""'");
22940   }
22941   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
22942   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22943   if (!SWIG_IsOK(res3)) {
22944     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryPoint" "', argument " "3"" of type '" "Hex::Vertex *""'");
22945   }
22946   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22947   result = (Hex::Elements *)(arg1)->makeSymmetryPoint(arg2,arg3);
22948   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
22949   return resultobj;
22950 fail:
22951   return NULL;
22952 }
22953
22954
22955 SWIGINTERN PyObject *_wrap_Document_makeSymmetryLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22956   PyObject *resultobj = 0;
22957   Hex::Document *arg1 = (Hex::Document *) 0 ;
22958   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
22959   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
22960   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
22961   Hex::Elements *result = 0 ;
22962   void *argp1 = 0 ;
22963   int res1 = 0 ;
22964   void *argp2 = 0 ;
22965   int res2 = 0 ;
22966   void *argp3 = 0 ;
22967   int res3 = 0 ;
22968   void *argp4 = 0 ;
22969   int res4 = 0 ;
22970   PyObject * obj0 = 0 ;
22971   PyObject * obj1 = 0 ;
22972   PyObject * obj2 = 0 ;
22973   PyObject * obj3 = 0 ;
22974
22975   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22976   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
22977   if (!SWIG_IsOK(res1)) {
22978     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryLine" "', argument " "1"" of type '" "Hex::Document *""'");
22979   }
22980   arg1 = reinterpret_cast< Hex::Document * >(argp1);
22981   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
22982   if (!SWIG_IsOK(res2)) {
22983     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryLine" "', argument " "2"" of type '" "Hex::Elements *""'");
22984   }
22985   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
22986   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22987   if (!SWIG_IsOK(res3)) {
22988     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryLine" "', argument " "3"" of type '" "Hex::Vertex *""'");
22989   }
22990   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
22991   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
22992   if (!SWIG_IsOK(res4)) {
22993     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSymmetryLine" "', argument " "4"" of type '" "Hex::Vector *""'");
22994   }
22995   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
22996   result = (Hex::Elements *)(arg1)->makeSymmetryLine(arg2,arg3,arg4);
22997   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
22998   return resultobj;
22999 fail:
23000   return NULL;
23001 }
23002
23003
23004 SWIGINTERN PyObject *_wrap_Document_makeSymmetryPlane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23005   PyObject *resultobj = 0;
23006   Hex::Document *arg1 = (Hex::Document *) 0 ;
23007   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23008   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23009   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
23010   Hex::Elements *result = 0 ;
23011   void *argp1 = 0 ;
23012   int res1 = 0 ;
23013   void *argp2 = 0 ;
23014   int res2 = 0 ;
23015   void *argp3 = 0 ;
23016   int res3 = 0 ;
23017   void *argp4 = 0 ;
23018   int res4 = 0 ;
23019   PyObject * obj0 = 0 ;
23020   PyObject * obj1 = 0 ;
23021   PyObject * obj2 = 0 ;
23022   PyObject * obj3 = 0 ;
23023
23024   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23025   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23026   if (!SWIG_IsOK(res1)) {
23027     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryPlane" "', argument " "1"" of type '" "Hex::Document *""'");
23028   }
23029   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23030   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
23031   if (!SWIG_IsOK(res2)) {
23032     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryPlane" "', argument " "2"" of type '" "Hex::Elements *""'");
23033   }
23034   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23035   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23036   if (!SWIG_IsOK(res3)) {
23037     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryPlane" "', argument " "3"" of type '" "Hex::Vertex *""'");
23038   }
23039   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23040   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
23041   if (!SWIG_IsOK(res4)) {
23042     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSymmetryPlane" "', argument " "4"" of type '" "Hex::Vector *""'");
23043   }
23044   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
23045   result = (Hex::Elements *)(arg1)->makeSymmetryPlane(arg2,arg3,arg4);
23046   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
23047   return resultobj;
23048 fail:
23049   return NULL;
23050 }
23051
23052
23053 SWIGINTERN PyObject *_wrap_Document_performTranslation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23054   PyObject *resultobj = 0;
23055   Hex::Document *arg1 = (Hex::Document *) 0 ;
23056   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23057   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
23058   int result;
23059   void *argp1 = 0 ;
23060   int res1 = 0 ;
23061   void *argp2 = 0 ;
23062   int res2 = 0 ;
23063   void *argp3 = 0 ;
23064   int res3 = 0 ;
23065   PyObject * obj0 = 0 ;
23066   PyObject * obj1 = 0 ;
23067   PyObject * obj2 = 0 ;
23068
23069   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
23070   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23071   if (!SWIG_IsOK(res1)) {
23072     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performTranslation" "', argument " "1"" of type '" "Hex::Document *""'");
23073   }
23074   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23075   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
23076   if (!SWIG_IsOK(res2)) {
23077     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performTranslation" "', argument " "2"" of type '" "Hex::Elements *""'");
23078   }
23079   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23080   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
23081   if (!SWIG_IsOK(res3)) {
23082     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performTranslation" "', argument " "3"" of type '" "Hex::Vector *""'");
23083   }
23084   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
23085   result = (int)(arg1)->performTranslation(arg2,arg3);
23086   resultobj = SWIG_From_int(static_cast< int >(result));
23087   return resultobj;
23088 fail:
23089   return NULL;
23090 }
23091
23092
23093 SWIGINTERN PyObject *_wrap_Document_performScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23094   PyObject *resultobj = 0;
23095   Hex::Document *arg1 = (Hex::Document *) 0 ;
23096   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23097   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23098   double arg4 ;
23099   int result;
23100   void *argp1 = 0 ;
23101   int res1 = 0 ;
23102   void *argp2 = 0 ;
23103   int res2 = 0 ;
23104   void *argp3 = 0 ;
23105   int res3 = 0 ;
23106   double val4 ;
23107   int ecode4 = 0 ;
23108   PyObject * obj0 = 0 ;
23109   PyObject * obj1 = 0 ;
23110   PyObject * obj2 = 0 ;
23111   PyObject * obj3 = 0 ;
23112
23113   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23114   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23115   if (!SWIG_IsOK(res1)) {
23116     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performScale" "', argument " "1"" of type '" "Hex::Document *""'");
23117   }
23118   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23119   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
23120   if (!SWIG_IsOK(res2)) {
23121     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performScale" "', argument " "2"" of type '" "Hex::Elements *""'");
23122   }
23123   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23124   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23125   if (!SWIG_IsOK(res3)) {
23126     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performScale" "', argument " "3"" of type '" "Hex::Vertex *""'");
23127   }
23128   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23129   ecode4 = SWIG_AsVal_double(obj3, &val4);
23130   if (!SWIG_IsOK(ecode4)) {
23131     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_performScale" "', argument " "4"" of type '" "double""'");
23132   }
23133   arg4 = static_cast< double >(val4);
23134   result = (int)(arg1)->performScale(arg2,arg3,arg4);
23135   resultobj = SWIG_From_int(static_cast< int >(result));
23136   return resultobj;
23137 fail:
23138   return NULL;
23139 }
23140
23141
23142 SWIGINTERN PyObject *_wrap_Document_performRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23143   PyObject *resultobj = 0;
23144   Hex::Document *arg1 = (Hex::Document *) 0 ;
23145   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23146   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23147   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
23148   double arg5 ;
23149   int result;
23150   void *argp1 = 0 ;
23151   int res1 = 0 ;
23152   void *argp2 = 0 ;
23153   int res2 = 0 ;
23154   void *argp3 = 0 ;
23155   int res3 = 0 ;
23156   void *argp4 = 0 ;
23157   int res4 = 0 ;
23158   double val5 ;
23159   int ecode5 = 0 ;
23160   PyObject * obj0 = 0 ;
23161   PyObject * obj1 = 0 ;
23162   PyObject * obj2 = 0 ;
23163   PyObject * obj3 = 0 ;
23164   PyObject * obj4 = 0 ;
23165
23166   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_performRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23167   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23168   if (!SWIG_IsOK(res1)) {
23169     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performRotation" "', argument " "1"" of type '" "Hex::Document *""'");
23170   }
23171   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23172   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
23173   if (!SWIG_IsOK(res2)) {
23174     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performRotation" "', argument " "2"" of type '" "Hex::Elements *""'");
23175   }
23176   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23177   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23178   if (!SWIG_IsOK(res3)) {
23179     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performRotation" "', argument " "3"" of type '" "Hex::Vertex *""'");
23180   }
23181   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23182   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
23183   if (!SWIG_IsOK(res4)) {
23184     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performRotation" "', argument " "4"" of type '" "Hex::Vector *""'");
23185   }
23186   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
23187   ecode5 = SWIG_AsVal_double(obj4, &val5);
23188   if (!SWIG_IsOK(ecode5)) {
23189     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_performRotation" "', argument " "5"" of type '" "double""'");
23190   }
23191   arg5 = static_cast< double >(val5);
23192   result = (int)(arg1)->performRotation(arg2,arg3,arg4,arg5);
23193   resultobj = SWIG_From_int(static_cast< int >(result));
23194   return resultobj;
23195 fail:
23196   return NULL;
23197 }
23198
23199
23200 SWIGINTERN PyObject *_wrap_Document_performSymmetryPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23201   PyObject *resultobj = 0;
23202   Hex::Document *arg1 = (Hex::Document *) 0 ;
23203   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23204   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23205   int result;
23206   void *argp1 = 0 ;
23207   int res1 = 0 ;
23208   void *argp2 = 0 ;
23209   int res2 = 0 ;
23210   void *argp3 = 0 ;
23211   int res3 = 0 ;
23212   PyObject * obj0 = 0 ;
23213   PyObject * obj1 = 0 ;
23214   PyObject * obj2 = 0 ;
23215
23216   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
23217   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23218   if (!SWIG_IsOK(res1)) {
23219     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryPoint" "', argument " "1"" of type '" "Hex::Document *""'");
23220   }
23221   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23222   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
23223   if (!SWIG_IsOK(res2)) {
23224     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryPoint" "', argument " "2"" of type '" "Hex::Elements *""'");
23225   }
23226   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23227   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23228   if (!SWIG_IsOK(res3)) {
23229     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryPoint" "', argument " "3"" of type '" "Hex::Vertex *""'");
23230   }
23231   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23232   result = (int)(arg1)->performSymmetryPoint(arg2,arg3);
23233   resultobj = SWIG_From_int(static_cast< int >(result));
23234   return resultobj;
23235 fail:
23236   return NULL;
23237 }
23238
23239
23240 SWIGINTERN PyObject *_wrap_Document_performSymmetryLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23241   PyObject *resultobj = 0;
23242   Hex::Document *arg1 = (Hex::Document *) 0 ;
23243   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23244   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23245   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
23246   int result;
23247   void *argp1 = 0 ;
23248   int res1 = 0 ;
23249   void *argp2 = 0 ;
23250   int res2 = 0 ;
23251   void *argp3 = 0 ;
23252   int res3 = 0 ;
23253   void *argp4 = 0 ;
23254   int res4 = 0 ;
23255   PyObject * obj0 = 0 ;
23256   PyObject * obj1 = 0 ;
23257   PyObject * obj2 = 0 ;
23258   PyObject * obj3 = 0 ;
23259
23260   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23261   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23262   if (!SWIG_IsOK(res1)) {
23263     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryLine" "', argument " "1"" of type '" "Hex::Document *""'");
23264   }
23265   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23266   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
23267   if (!SWIG_IsOK(res2)) {
23268     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryLine" "', argument " "2"" of type '" "Hex::Elements *""'");
23269   }
23270   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23271   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23272   if (!SWIG_IsOK(res3)) {
23273     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryLine" "', argument " "3"" of type '" "Hex::Vertex *""'");
23274   }
23275   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23276   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
23277   if (!SWIG_IsOK(res4)) {
23278     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performSymmetryLine" "', argument " "4"" of type '" "Hex::Vector *""'");
23279   }
23280   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
23281   result = (int)(arg1)->performSymmetryLine(arg2,arg3,arg4);
23282   resultobj = SWIG_From_int(static_cast< int >(result));
23283   return resultobj;
23284 fail:
23285   return NULL;
23286 }
23287
23288
23289 SWIGINTERN PyObject *_wrap_Document_performSymmetryPlane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23290   PyObject *resultobj = 0;
23291   Hex::Document *arg1 = (Hex::Document *) 0 ;
23292   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
23293   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23294   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
23295   int result;
23296   void *argp1 = 0 ;
23297   int res1 = 0 ;
23298   void *argp2 = 0 ;
23299   int res2 = 0 ;
23300   void *argp3 = 0 ;
23301   int res3 = 0 ;
23302   void *argp4 = 0 ;
23303   int res4 = 0 ;
23304   PyObject * obj0 = 0 ;
23305   PyObject * obj1 = 0 ;
23306   PyObject * obj2 = 0 ;
23307   PyObject * obj3 = 0 ;
23308
23309   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23310   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23311   if (!SWIG_IsOK(res1)) {
23312     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryPlane" "', argument " "1"" of type '" "Hex::Document *""'");
23313   }
23314   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23315   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
23316   if (!SWIG_IsOK(res2)) {
23317     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryPlane" "', argument " "2"" of type '" "Hex::Elements *""'");
23318   }
23319   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
23320   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23321   if (!SWIG_IsOK(res3)) {
23322     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryPlane" "', argument " "3"" of type '" "Hex::Vertex *""'");
23323   }
23324   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23325   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
23326   if (!SWIG_IsOK(res4)) {
23327     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performSymmetryPlane" "', argument " "4"" of type '" "Hex::Vector *""'");
23328   }
23329   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
23330   result = (int)(arg1)->performSymmetryPlane(arg2,arg3,arg4);
23331   resultobj = SWIG_From_int(static_cast< int >(result));
23332   return resultobj;
23333 fail:
23334   return NULL;
23335 }
23336
23337
23338 SWIGINTERN PyObject *_wrap_Document_disconnectQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23339   PyObject *resultobj = 0;
23340   Hex::Document *arg1 = (Hex::Document *) 0 ;
23341   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
23342   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
23343   Hex::Elements *result = 0 ;
23344   void *argp1 = 0 ;
23345   int res1 = 0 ;
23346   void *argp2 = 0 ;
23347   int res2 = 0 ;
23348   void *argp3 = 0 ;
23349   int res3 = 0 ;
23350   PyObject * obj0 = 0 ;
23351   PyObject * obj1 = 0 ;
23352   PyObject * obj2 = 0 ;
23353
23354   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectQuad",&obj0,&obj1,&obj2)) SWIG_fail;
23355   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23356   if (!SWIG_IsOK(res1)) {
23357     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectQuad" "', argument " "1"" of type '" "Hex::Document *""'");
23358   }
23359   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23360   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
23361   if (!SWIG_IsOK(res2)) {
23362     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectQuad" "', argument " "2"" of type '" "Hex::Hexa *""'");
23363   }
23364   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
23365   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23366   if (!SWIG_IsOK(res3)) {
23367     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectQuad" "', argument " "3"" of type '" "Hex::Quad *""'");
23368   }
23369   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
23370   result = (Hex::Elements *)(arg1)->disconnectQuad(arg2,arg3);
23371   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
23372   return resultobj;
23373 fail:
23374   return NULL;
23375 }
23376
23377
23378 SWIGINTERN PyObject *_wrap_Document_disconnectEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23379   PyObject *resultobj = 0;
23380   Hex::Document *arg1 = (Hex::Document *) 0 ;
23381   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
23382   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
23383   Hex::Elements *result = 0 ;
23384   void *argp1 = 0 ;
23385   int res1 = 0 ;
23386   void *argp2 = 0 ;
23387   int res2 = 0 ;
23388   void *argp3 = 0 ;
23389   int res3 = 0 ;
23390   PyObject * obj0 = 0 ;
23391   PyObject * obj1 = 0 ;
23392   PyObject * obj2 = 0 ;
23393
23394   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdge",&obj0,&obj1,&obj2)) SWIG_fail;
23395   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23396   if (!SWIG_IsOK(res1)) {
23397     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectEdge" "', argument " "1"" of type '" "Hex::Document *""'");
23398   }
23399   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23400   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
23401   if (!SWIG_IsOK(res2)) {
23402     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectEdge" "', argument " "2"" of type '" "Hex::Hexa *""'");
23403   }
23404   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
23405   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
23406   if (!SWIG_IsOK(res3)) {
23407     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectEdge" "', argument " "3"" of type '" "Hex::Edge *""'");
23408   }
23409   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
23410   result = (Hex::Elements *)(arg1)->disconnectEdge(arg2,arg3);
23411   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
23412   return resultobj;
23413 fail:
23414   return NULL;
23415 }
23416
23417
23418 SWIGINTERN PyObject *_wrap_Document_disconnectVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23419   PyObject *resultobj = 0;
23420   Hex::Document *arg1 = (Hex::Document *) 0 ;
23421   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
23422   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23423   Hex::Elements *result = 0 ;
23424   void *argp1 = 0 ;
23425   int res1 = 0 ;
23426   void *argp2 = 0 ;
23427   int res2 = 0 ;
23428   void *argp3 = 0 ;
23429   int res3 = 0 ;
23430   PyObject * obj0 = 0 ;
23431   PyObject * obj1 = 0 ;
23432   PyObject * obj2 = 0 ;
23433
23434   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectVertex",&obj0,&obj1,&obj2)) SWIG_fail;
23435   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23436   if (!SWIG_IsOK(res1)) {
23437     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectVertex" "', argument " "1"" of type '" "Hex::Document *""'");
23438   }
23439   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23440   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
23441   if (!SWIG_IsOK(res2)) {
23442     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectVertex" "', argument " "2"" of type '" "Hex::Hexa *""'");
23443   }
23444   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
23445   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23446   if (!SWIG_IsOK(res3)) {
23447     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectVertex" "', argument " "3"" of type '" "Hex::Vertex *""'");
23448   }
23449   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23450   result = (Hex::Elements *)(arg1)->disconnectVertex(arg2,arg3);
23451   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
23452   return resultobj;
23453 fail:
23454   return NULL;
23455 }
23456
23457
23458 SWIGINTERN PyObject *_wrap_Document_disconnectEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23459   PyObject *resultobj = 0;
23460   Hex::Document *arg1 = (Hex::Document *) 0 ;
23461   Hex::Hexas arg2 ;
23462   Hex::Edges arg3 ;
23463   Hex::Elements *result = 0 ;
23464   void *argp1 = 0 ;
23465   int res1 = 0 ;
23466   PyObject * obj0 = 0 ;
23467   PyObject * obj1 = 0 ;
23468   PyObject * obj2 = 0 ;
23469
23470   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdges",&obj0,&obj1,&obj2)) SWIG_fail;
23471   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23472   if (!SWIG_IsOK(res1)) {
23473     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectEdges" "', argument " "1"" of type '" "Hex::Document *""'");
23474   }
23475   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23476   {
23477     std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *ptr = (std::vector<Hex::Hexa*,std::allocator<Hex::Hexa * > > *)0;
23478     int res = swig::asptr(obj1, &ptr);
23479     if (!SWIG_IsOK(res) || !ptr) {
23480       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "2"" of type '" "Hex::Hexas""'");
23481     }
23482     arg2 = *ptr;
23483     if (SWIG_IsNewObj(res)) delete ptr;
23484   }
23485   {
23486     std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
23487     int res = swig::asptr(obj2, &ptr);
23488     if (!SWIG_IsOK(res) || !ptr) {
23489       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "3"" of type '" "Hex::Edges""'");
23490     }
23491     arg3 = *ptr;
23492     if (SWIG_IsNewObj(res)) delete ptr;
23493   }
23494   result = (Hex::Elements *)(arg1)->disconnectEdges(arg2,arg3);
23495   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
23496   return resultobj;
23497 fail:
23498   return NULL;
23499 }
23500
23501
23502 SWIGINTERN PyObject *_wrap_Document_replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23503   PyObject *resultobj = 0;
23504   Hex::Document *arg1 = (Hex::Document *) 0 ;
23505   Hex::Quads arg2 ;
23506   Hex::Quads arg3 ;
23507   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
23508   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
23509   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
23510   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
23511   Hex::Elements *result = 0 ;
23512   void *argp1 = 0 ;
23513   int res1 = 0 ;
23514   void *argp4 = 0 ;
23515   int res4 = 0 ;
23516   void *argp5 = 0 ;
23517   int res5 = 0 ;
23518   void *argp6 = 0 ;
23519   int res6 = 0 ;
23520   void *argp7 = 0 ;
23521   int res7 = 0 ;
23522   PyObject * obj0 = 0 ;
23523   PyObject * obj1 = 0 ;
23524   PyObject * obj2 = 0 ;
23525   PyObject * obj3 = 0 ;
23526   PyObject * obj4 = 0 ;
23527   PyObject * obj5 = 0 ;
23528   PyObject * obj6 = 0 ;
23529
23530   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_replace",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23531   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23532   if (!SWIG_IsOK(res1)) {
23533     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_replace" "', argument " "1"" of type '" "Hex::Document *""'");
23534   }
23535   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23536   {
23537     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
23538     int res = swig::asptr(obj1, &ptr);
23539     if (!SWIG_IsOK(res) || !ptr) {
23540       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "2"" of type '" "Hex::Quads""'");
23541     }
23542     arg2 = *ptr;
23543     if (SWIG_IsNewObj(res)) delete ptr;
23544   }
23545   {
23546     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
23547     int res = swig::asptr(obj2, &ptr);
23548     if (!SWIG_IsOK(res) || !ptr) {
23549       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "3"" of type '" "Hex::Quads""'");
23550     }
23551     arg3 = *ptr;
23552     if (SWIG_IsNewObj(res)) delete ptr;
23553   }
23554   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23555   if (!SWIG_IsOK(res4)) {
23556     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_replace" "', argument " "4"" of type '" "Hex::Vertex *""'");
23557   }
23558   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
23559   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23560   if (!SWIG_IsOK(res5)) {
23561     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_replace" "', argument " "5"" of type '" "Hex::Vertex *""'");
23562   }
23563   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
23564   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23565   if (!SWIG_IsOK(res6)) {
23566     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_replace" "', argument " "6"" of type '" "Hex::Vertex *""'");
23567   }
23568   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
23569   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23570   if (!SWIG_IsOK(res7)) {
23571     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_replace" "', argument " "7"" of type '" "Hex::Vertex *""'");
23572   }
23573   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
23574   result = (Hex::Elements *)(arg1)->replace(arg2,arg3,arg4,arg5,arg6,arg7);
23575   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
23576   return resultobj;
23577 fail:
23578   return NULL;
23579 }
23580
23581
23582 SWIGINTERN PyObject *_wrap_Document_mergeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23583   PyObject *resultobj = 0;
23584   Hex::Document *arg1 = (Hex::Document *) 0 ;
23585   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
23586   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23587   int result;
23588   void *argp1 = 0 ;
23589   int res1 = 0 ;
23590   void *argp2 = 0 ;
23591   int res2 = 0 ;
23592   void *argp3 = 0 ;
23593   int res3 = 0 ;
23594   PyObject * obj0 = 0 ;
23595   PyObject * obj1 = 0 ;
23596   PyObject * obj2 = 0 ;
23597
23598   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_mergeVertices",&obj0,&obj1,&obj2)) SWIG_fail;
23599   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23600   if (!SWIG_IsOK(res1)) {
23601     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeVertices" "', argument " "1"" of type '" "Hex::Document *""'");
23602   }
23603   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23604   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23605   if (!SWIG_IsOK(res2)) {
23606     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
23607   }
23608   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
23609   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23610   if (!SWIG_IsOK(res3)) {
23611     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
23612   }
23613   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23614   result = (int)(arg1)->mergeVertices(arg2,arg3);
23615   resultobj = SWIG_From_int(static_cast< int >(result));
23616   return resultobj;
23617 fail:
23618   return NULL;
23619 }
23620
23621
23622 SWIGINTERN PyObject *_wrap_Document_mergeEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23623   PyObject *resultobj = 0;
23624   Hex::Document *arg1 = (Hex::Document *) 0 ;
23625   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
23626   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
23627   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
23628   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
23629   int result;
23630   void *argp1 = 0 ;
23631   int res1 = 0 ;
23632   void *argp2 = 0 ;
23633   int res2 = 0 ;
23634   void *argp3 = 0 ;
23635   int res3 = 0 ;
23636   void *argp4 = 0 ;
23637   int res4 = 0 ;
23638   void *argp5 = 0 ;
23639   int res5 = 0 ;
23640   PyObject * obj0 = 0 ;
23641   PyObject * obj1 = 0 ;
23642   PyObject * obj2 = 0 ;
23643   PyObject * obj3 = 0 ;
23644   PyObject * obj4 = 0 ;
23645
23646   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_mergeEdges",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23647   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23648   if (!SWIG_IsOK(res1)) {
23649     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeEdges" "', argument " "1"" of type '" "Hex::Document *""'");
23650   }
23651   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23652   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
23653   if (!SWIG_IsOK(res2)) {
23654     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeEdges" "', argument " "2"" of type '" "Hex::Edge *""'");
23655   }
23656   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
23657   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
23658   if (!SWIG_IsOK(res3)) {
23659     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeEdges" "', argument " "3"" of type '" "Hex::Edge *""'");
23660   }
23661   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
23662   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23663   if (!SWIG_IsOK(res4)) {
23664     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_mergeEdges" "', argument " "4"" of type '" "Hex::Vertex *""'");
23665   }
23666   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
23667   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23668   if (!SWIG_IsOK(res5)) {
23669     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_mergeEdges" "', argument " "5"" of type '" "Hex::Vertex *""'");
23670   }
23671   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
23672   result = (int)(arg1)->mergeEdges(arg2,arg3,arg4,arg5);
23673   resultobj = SWIG_From_int(static_cast< int >(result));
23674   return resultobj;
23675 fail:
23676   return NULL;
23677 }
23678
23679
23680 SWIGINTERN PyObject *_wrap_Document_mergeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23681   PyObject *resultobj = 0;
23682   Hex::Document *arg1 = (Hex::Document *) 0 ;
23683   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
23684   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
23685   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
23686   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
23687   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
23688   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
23689   int result;
23690   void *argp1 = 0 ;
23691   int res1 = 0 ;
23692   void *argp2 = 0 ;
23693   int res2 = 0 ;
23694   void *argp3 = 0 ;
23695   int res3 = 0 ;
23696   void *argp4 = 0 ;
23697   int res4 = 0 ;
23698   void *argp5 = 0 ;
23699   int res5 = 0 ;
23700   void *argp6 = 0 ;
23701   int res6 = 0 ;
23702   void *argp7 = 0 ;
23703   int res7 = 0 ;
23704   PyObject * obj0 = 0 ;
23705   PyObject * obj1 = 0 ;
23706   PyObject * obj2 = 0 ;
23707   PyObject * obj3 = 0 ;
23708   PyObject * obj4 = 0 ;
23709   PyObject * obj5 = 0 ;
23710   PyObject * obj6 = 0 ;
23711
23712   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_mergeQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23713   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23714   if (!SWIG_IsOK(res1)) {
23715     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
23716   }
23717   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23718   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23719   if (!SWIG_IsOK(res2)) {
23720     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeQuads" "', argument " "2"" of type '" "Hex::Quad *""'");
23721   }
23722   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
23723   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23724   if (!SWIG_IsOK(res3)) {
23725     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
23726   }
23727   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
23728   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23729   if (!SWIG_IsOK(res4)) {
23730     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_mergeQuads" "', argument " "4"" of type '" "Hex::Vertex *""'");
23731   }
23732   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
23733   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23734   if (!SWIG_IsOK(res5)) {
23735     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_mergeQuads" "', argument " "5"" of type '" "Hex::Vertex *""'");
23736   }
23737   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
23738   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23739   if (!SWIG_IsOK(res6)) {
23740     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_mergeQuads" "', argument " "6"" of type '" "Hex::Vertex *""'");
23741   }
23742   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
23743   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23744   if (!SWIG_IsOK(res7)) {
23745     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_mergeQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
23746   }
23747   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
23748   result = (int)(arg1)->mergeQuads(arg2,arg3,arg4,arg5,arg6,arg7);
23749   resultobj = SWIG_From_int(static_cast< int >(result));
23750   return resultobj;
23751 fail:
23752   return NULL;
23753 }
23754
23755
23756 SWIGINTERN PyObject *_wrap_Document_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23757   PyObject *resultobj = 0;
23758   Hex::Document *arg1 = (Hex::Document *) 0 ;
23759   void *argp1 = 0 ;
23760   int res1 = 0 ;
23761   PyObject * obj0 = 0 ;
23762
23763   if (!PyArg_ParseTuple(args,(char *)"O:Document_clearAssociation",&obj0)) SWIG_fail;
23764   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23765   if (!SWIG_IsOK(res1)) {
23766     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_clearAssociation" "', argument " "1"" of type '" "Hex::Document *""'");
23767   }
23768   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23769   (arg1)->clearAssociation();
23770   resultobj = SWIG_Py_Void();
23771   return resultobj;
23772 fail:
23773   return NULL;
23774 }
23775
23776
23777 SWIGINTERN PyObject *_wrap_Document_associateOpenedLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23778   PyObject *resultobj = 0;
23779   Hex::Document *arg1 = (Hex::Document *) 0 ;
23780   Hex::Edges arg2 ;
23781   Hex::NewShapes arg3 ;
23782   Hex::IntVector arg4 ;
23783   double arg5 ;
23784   double arg6 ;
23785   int result;
23786   void *argp1 = 0 ;
23787   int res1 = 0 ;
23788   double val5 ;
23789   int ecode5 = 0 ;
23790   double val6 ;
23791   int ecode6 = 0 ;
23792   PyObject * obj0 = 0 ;
23793   PyObject * obj1 = 0 ;
23794   PyObject * obj2 = 0 ;
23795   PyObject * obj3 = 0 ;
23796   PyObject * obj4 = 0 ;
23797   PyObject * obj5 = 0 ;
23798
23799   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_associateOpenedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
23800   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23801   if (!SWIG_IsOK(res1)) {
23802     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_associateOpenedLine" "', argument " "1"" of type '" "Hex::Document *""'");
23803   }
23804   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23805   {
23806     std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
23807     int res = swig::asptr(obj1, &ptr);
23808     if (!SWIG_IsOK(res) || !ptr) {
23809       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "2"" of type '" "Hex::Edges""'");
23810     }
23811     arg2 = *ptr;
23812     if (SWIG_IsNewObj(res)) delete ptr;
23813   }
23814   {
23815     std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
23816     int res = swig::asptr(obj2, &ptr);
23817     if (!SWIG_IsOK(res) || !ptr) {
23818       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "3"" of type '" "Hex::NewShapes""'");
23819     }
23820     arg3 = *ptr;
23821     if (SWIG_IsNewObj(res)) delete ptr;
23822   }
23823   {
23824     std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
23825     int res = swig::asptr(obj3, &ptr);
23826     if (!SWIG_IsOK(res) || !ptr) {
23827       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "4"" of type '" "Hex::IntVector""'");
23828     }
23829     arg4 = *ptr;
23830     if (SWIG_IsNewObj(res)) delete ptr;
23831   }
23832   ecode5 = SWIG_AsVal_double(obj4, &val5);
23833   if (!SWIG_IsOK(ecode5)) {
23834     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_associateOpenedLine" "', argument " "5"" of type '" "double""'");
23835   }
23836   arg5 = static_cast< double >(val5);
23837   ecode6 = SWIG_AsVal_double(obj5, &val6);
23838   if (!SWIG_IsOK(ecode6)) {
23839     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_associateOpenedLine" "', argument " "6"" of type '" "double""'");
23840   }
23841   arg6 = static_cast< double >(val6);
23842   result = (int)(arg1)->associateOpenedLine(arg2,arg3,arg4,arg5,arg6);
23843   resultobj = SWIG_From_int(static_cast< int >(result));
23844   return resultobj;
23845 fail:
23846   return NULL;
23847 }
23848
23849
23850 SWIGINTERN PyObject *_wrap_Document_associateClosedLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23851   PyObject *resultobj = 0;
23852   Hex::Document *arg1 = (Hex::Document *) 0 ;
23853   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
23854   Hex::Edges arg3 ;
23855   Hex::NewShapes arg4 ;
23856   Hex::IntVector arg5 ;
23857   double arg6 ;
23858   bool arg7 ;
23859   int result;
23860   void *argp1 = 0 ;
23861   int res1 = 0 ;
23862   void *argp2 = 0 ;
23863   int res2 = 0 ;
23864   double val6 ;
23865   int ecode6 = 0 ;
23866   bool val7 ;
23867   int ecode7 = 0 ;
23868   PyObject * obj0 = 0 ;
23869   PyObject * obj1 = 0 ;
23870   PyObject * obj2 = 0 ;
23871   PyObject * obj3 = 0 ;
23872   PyObject * obj4 = 0 ;
23873   PyObject * obj5 = 0 ;
23874   PyObject * obj6 = 0 ;
23875
23876   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_associateClosedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23877   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23878   if (!SWIG_IsOK(res1)) {
23879     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_associateClosedLine" "', argument " "1"" of type '" "Hex::Document *""'");
23880   }
23881   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23882   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23883   if (!SWIG_IsOK(res2)) {
23884     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_associateClosedLine" "', argument " "2"" of type '" "Hex::Vertex *""'");
23885   }
23886   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
23887   {
23888     std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *ptr = (std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > *)0;
23889     int res = swig::asptr(obj2, &ptr);
23890     if (!SWIG_IsOK(res) || !ptr) {
23891       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "3"" of type '" "Hex::Edges""'");
23892     }
23893     arg3 = *ptr;
23894     if (SWIG_IsNewObj(res)) delete ptr;
23895   }
23896   {
23897     std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *ptr = (std::vector<Hex::NewShape*,std::allocator<Hex::NewShape * > > *)0;
23898     int res = swig::asptr(obj3, &ptr);
23899     if (!SWIG_IsOK(res) || !ptr) {
23900       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "4"" of type '" "Hex::NewShapes""'");
23901     }
23902     arg4 = *ptr;
23903     if (SWIG_IsNewObj(res)) delete ptr;
23904   }
23905   {
23906     std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
23907     int res = swig::asptr(obj4, &ptr);
23908     if (!SWIG_IsOK(res) || !ptr) {
23909       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "5"" of type '" "Hex::IntVector""'");
23910     }
23911     arg5 = *ptr;
23912     if (SWIG_IsNewObj(res)) delete ptr;
23913   }
23914   ecode6 = SWIG_AsVal_double(obj5, &val6);
23915   if (!SWIG_IsOK(ecode6)) {
23916     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_associateClosedLine" "', argument " "6"" of type '" "double""'");
23917   }
23918   arg6 = static_cast< double >(val6);
23919   ecode7 = SWIG_AsVal_bool(obj6, &val7);
23920   if (!SWIG_IsOK(ecode7)) {
23921     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_associateClosedLine" "', argument " "7"" of type '" "bool""'");
23922   }
23923   arg7 = static_cast< bool >(val7);
23924   result = (int)(arg1)->associateClosedLine(arg2,arg3,arg4,arg5,arg6,arg7);
23925   resultobj = SWIG_From_int(static_cast< int >(result));
23926   return resultobj;
23927 fail:
23928   return NULL;
23929 }
23930
23931
23932 SWIGINTERN PyObject *_wrap_Document_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23933   PyObject *resultobj = 0;
23934   Hex::Document *arg1 = (Hex::Document *) 0 ;
23935   int result;
23936   void *argp1 = 0 ;
23937   int res1 = 0 ;
23938   PyObject * obj0 = 0 ;
23939
23940   if (!PyArg_ParseTuple(args,(char *)"O:Document_countHexa",&obj0)) SWIG_fail;
23941   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23942   if (!SWIG_IsOK(res1)) {
23943     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countHexa" "', argument " "1"" of type '" "Hex::Document *""'");
23944   }
23945   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23946   result = (int)(arg1)->countHexa();
23947   resultobj = SWIG_From_int(static_cast< int >(result));
23948   return resultobj;
23949 fail:
23950   return NULL;
23951 }
23952
23953
23954 SWIGINTERN PyObject *_wrap_Document_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23955   PyObject *resultobj = 0;
23956   Hex::Document *arg1 = (Hex::Document *) 0 ;
23957   int result;
23958   void *argp1 = 0 ;
23959   int res1 = 0 ;
23960   PyObject * obj0 = 0 ;
23961
23962   if (!PyArg_ParseTuple(args,(char *)"O:Document_countQuad",&obj0)) SWIG_fail;
23963   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23964   if (!SWIG_IsOK(res1)) {
23965     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countQuad" "', argument " "1"" of type '" "Hex::Document *""'");
23966   }
23967   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23968   result = (int)(arg1)->countQuad();
23969   resultobj = SWIG_From_int(static_cast< int >(result));
23970   return resultobj;
23971 fail:
23972   return NULL;
23973 }
23974
23975
23976 SWIGINTERN PyObject *_wrap_Document_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23977   PyObject *resultobj = 0;
23978   Hex::Document *arg1 = (Hex::Document *) 0 ;
23979   int result;
23980   void *argp1 = 0 ;
23981   int res1 = 0 ;
23982   PyObject * obj0 = 0 ;
23983
23984   if (!PyArg_ParseTuple(args,(char *)"O:Document_countEdge",&obj0)) SWIG_fail;
23985   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23986   if (!SWIG_IsOK(res1)) {
23987     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countEdge" "', argument " "1"" of type '" "Hex::Document *""'");
23988   }
23989   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23990   result = (int)(arg1)->countEdge();
23991   resultobj = SWIG_From_int(static_cast< int >(result));
23992   return resultobj;
23993 fail:
23994   return NULL;
23995 }
23996
23997
23998 SWIGINTERN PyObject *_wrap_Document_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23999   PyObject *resultobj = 0;
24000   Hex::Document *arg1 = (Hex::Document *) 0 ;
24001   int result;
24002   void *argp1 = 0 ;
24003   int res1 = 0 ;
24004   PyObject * obj0 = 0 ;
24005
24006   if (!PyArg_ParseTuple(args,(char *)"O:Document_countVertex",&obj0)) SWIG_fail;
24007   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24008   if (!SWIG_IsOK(res1)) {
24009     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24010   }
24011   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24012   result = (int)(arg1)->countVertex();
24013   resultobj = SWIG_From_int(static_cast< int >(result));
24014   return resultobj;
24015 fail:
24016   return NULL;
24017 }
24018
24019
24020 SWIGINTERN PyObject *_wrap_Document_countVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24021   PyObject *resultobj = 0;
24022   Hex::Document *arg1 = (Hex::Document *) 0 ;
24023   int result;
24024   void *argp1 = 0 ;
24025   int res1 = 0 ;
24026   PyObject * obj0 = 0 ;
24027
24028   if (!PyArg_ParseTuple(args,(char *)"O:Document_countVector",&obj0)) SWIG_fail;
24029   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24030   if (!SWIG_IsOK(res1)) {
24031     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countVector" "', argument " "1"" of type '" "Hex::Document *""'");
24032   }
24033   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24034   result = (int)(arg1)->countVector();
24035   resultobj = SWIG_From_int(static_cast< int >(result));
24036   return resultobj;
24037 fail:
24038   return NULL;
24039 }
24040
24041
24042 SWIGINTERN PyObject *_wrap_Document_countGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24043   PyObject *resultobj = 0;
24044   Hex::Document *arg1 = (Hex::Document *) 0 ;
24045   int result;
24046   void *argp1 = 0 ;
24047   int res1 = 0 ;
24048   PyObject * obj0 = 0 ;
24049
24050   if (!PyArg_ParseTuple(args,(char *)"O:Document_countGroup",&obj0)) SWIG_fail;
24051   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24052   if (!SWIG_IsOK(res1)) {
24053     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countGroup" "', argument " "1"" of type '" "Hex::Document *""'");
24054   }
24055   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24056   result = (int)(arg1)->countGroup();
24057   resultobj = SWIG_From_int(static_cast< int >(result));
24058   return resultobj;
24059 fail:
24060   return NULL;
24061 }
24062
24063
24064 SWIGINTERN PyObject *_wrap_Document_countLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24065   PyObject *resultobj = 0;
24066   Hex::Document *arg1 = (Hex::Document *) 0 ;
24067   int result;
24068   void *argp1 = 0 ;
24069   int res1 = 0 ;
24070   PyObject * obj0 = 0 ;
24071
24072   if (!PyArg_ParseTuple(args,(char *)"O:Document_countLaw",&obj0)) SWIG_fail;
24073   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24074   if (!SWIG_IsOK(res1)) {
24075     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countLaw" "', argument " "1"" of type '" "Hex::Document *""'");
24076   }
24077   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24078   result = (int)(arg1)->countLaw();
24079   resultobj = SWIG_From_int(static_cast< int >(result));
24080   return resultobj;
24081 fail:
24082   return NULL;
24083 }
24084
24085
24086 SWIGINTERN PyObject *_wrap_Document_countPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24087   PyObject *resultobj = 0;
24088   Hex::Document *arg1 = (Hex::Document *) 0 ;
24089   int result;
24090   void *argp1 = 0 ;
24091   int res1 = 0 ;
24092   PyObject * obj0 = 0 ;
24093
24094   if (!PyArg_ParseTuple(args,(char *)"O:Document_countPropagation",&obj0)) SWIG_fail;
24095   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24096   if (!SWIG_IsOK(res1)) {
24097     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
24098   }
24099   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24100   result = (int)(arg1)->countPropagation();
24101   resultobj = SWIG_From_int(static_cast< int >(result));
24102   return resultobj;
24103 fail:
24104   return NULL;
24105 }
24106
24107
24108 SWIGINTERN PyObject *_wrap_Document_countShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24109   PyObject *resultobj = 0;
24110   Hex::Document *arg1 = (Hex::Document *) 0 ;
24111   int result;
24112   void *argp1 = 0 ;
24113   int res1 = 0 ;
24114   PyObject * obj0 = 0 ;
24115
24116   if (!PyArg_ParseTuple(args,(char *)"O:Document_countShape",&obj0)) SWIG_fail;
24117   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24118   if (!SWIG_IsOK(res1)) {
24119     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countShape" "', argument " "1"" of type '" "Hex::Document *""'");
24120   }
24121   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24122   result = (int)(arg1)->countShape();
24123   resultobj = SWIG_From_int(static_cast< int >(result));
24124   return resultobj;
24125 fail:
24126   return NULL;
24127 }
24128
24129
24130 SWIGINTERN PyObject *_wrap_Document_countUsedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24131   PyObject *resultobj = 0;
24132   Hex::Document *arg1 = (Hex::Document *) 0 ;
24133   int result;
24134   void *argp1 = 0 ;
24135   int res1 = 0 ;
24136   PyObject * obj0 = 0 ;
24137
24138   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedHexa",&obj0)) SWIG_fail;
24139   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24140   if (!SWIG_IsOK(res1)) {
24141     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
24142   }
24143   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24144   result = (int)(arg1)->countUsedHexa();
24145   resultobj = SWIG_From_int(static_cast< int >(result));
24146   return resultobj;
24147 fail:
24148   return NULL;
24149 }
24150
24151
24152 SWIGINTERN PyObject *_wrap_Document_countUsedQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24153   PyObject *resultobj = 0;
24154   Hex::Document *arg1 = (Hex::Document *) 0 ;
24155   int result;
24156   void *argp1 = 0 ;
24157   int res1 = 0 ;
24158   PyObject * obj0 = 0 ;
24159
24160   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedQuad",&obj0)) SWIG_fail;
24161   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24162   if (!SWIG_IsOK(res1)) {
24163     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24164   }
24165   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24166   result = (int)(arg1)->countUsedQuad();
24167   resultobj = SWIG_From_int(static_cast< int >(result));
24168   return resultobj;
24169 fail:
24170   return NULL;
24171 }
24172
24173
24174 SWIGINTERN PyObject *_wrap_Document_countUsedEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24175   PyObject *resultobj = 0;
24176   Hex::Document *arg1 = (Hex::Document *) 0 ;
24177   int result;
24178   void *argp1 = 0 ;
24179   int res1 = 0 ;
24180   PyObject * obj0 = 0 ;
24181
24182   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedEdge",&obj0)) SWIG_fail;
24183   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24184   if (!SWIG_IsOK(res1)) {
24185     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24186   }
24187   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24188   result = (int)(arg1)->countUsedEdge();
24189   resultobj = SWIG_From_int(static_cast< int >(result));
24190   return resultobj;
24191 fail:
24192   return NULL;
24193 }
24194
24195
24196 SWIGINTERN PyObject *_wrap_Document_countUsedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24197   PyObject *resultobj = 0;
24198   Hex::Document *arg1 = (Hex::Document *) 0 ;
24199   int result;
24200   void *argp1 = 0 ;
24201   int res1 = 0 ;
24202   PyObject * obj0 = 0 ;
24203
24204   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedVertex",&obj0)) SWIG_fail;
24205   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24206   if (!SWIG_IsOK(res1)) {
24207     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24208   }
24209   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24210   result = (int)(arg1)->countUsedVertex();
24211   resultobj = SWIG_From_int(static_cast< int >(result));
24212   return resultobj;
24213 fail:
24214   return NULL;
24215 }
24216
24217
24218 SWIGINTERN PyObject *_wrap_Document_getHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24219   PyObject *resultobj = 0;
24220   Hex::Document *arg1 = (Hex::Document *) 0 ;
24221   int arg2 ;
24222   Hex::Hexa *result = 0 ;
24223   void *argp1 = 0 ;
24224   int res1 = 0 ;
24225   int val2 ;
24226   int ecode2 = 0 ;
24227   PyObject * obj0 = 0 ;
24228   PyObject * obj1 = 0 ;
24229
24230   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getHexa",&obj0,&obj1)) SWIG_fail;
24231   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24232   if (!SWIG_IsOK(res1)) {
24233     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getHexa" "', argument " "1"" of type '" "Hex::Document *""'");
24234   }
24235   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24236   ecode2 = SWIG_AsVal_int(obj1, &val2);
24237   if (!SWIG_IsOK(ecode2)) {
24238     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getHexa" "', argument " "2"" of type '" "int""'");
24239   }
24240   arg2 = static_cast< int >(val2);
24241   result = (Hex::Hexa *)(arg1)->getHexa(arg2);
24242   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
24243   return resultobj;
24244 fail:
24245   return NULL;
24246 }
24247
24248
24249 SWIGINTERN PyObject *_wrap_Document_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24250   PyObject *resultobj = 0;
24251   Hex::Document *arg1 = (Hex::Document *) 0 ;
24252   int arg2 ;
24253   Hex::Quad *result = 0 ;
24254   void *argp1 = 0 ;
24255   int res1 = 0 ;
24256   int val2 ;
24257   int ecode2 = 0 ;
24258   PyObject * obj0 = 0 ;
24259   PyObject * obj1 = 0 ;
24260
24261   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getQuad",&obj0,&obj1)) SWIG_fail;
24262   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24263   if (!SWIG_IsOK(res1)) {
24264     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24265   }
24266   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24267   ecode2 = SWIG_AsVal_int(obj1, &val2);
24268   if (!SWIG_IsOK(ecode2)) {
24269     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getQuad" "', argument " "2"" of type '" "int""'");
24270   }
24271   arg2 = static_cast< int >(val2);
24272   result = (Hex::Quad *)(arg1)->getQuad(arg2);
24273   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
24274   return resultobj;
24275 fail:
24276   return NULL;
24277 }
24278
24279
24280 SWIGINTERN PyObject *_wrap_Document_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24281   PyObject *resultobj = 0;
24282   Hex::Document *arg1 = (Hex::Document *) 0 ;
24283   int arg2 ;
24284   Hex::Edge *result = 0 ;
24285   void *argp1 = 0 ;
24286   int res1 = 0 ;
24287   int val2 ;
24288   int ecode2 = 0 ;
24289   PyObject * obj0 = 0 ;
24290   PyObject * obj1 = 0 ;
24291
24292   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getEdge",&obj0,&obj1)) SWIG_fail;
24293   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24294   if (!SWIG_IsOK(res1)) {
24295     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24296   }
24297   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24298   ecode2 = SWIG_AsVal_int(obj1, &val2);
24299   if (!SWIG_IsOK(ecode2)) {
24300     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getEdge" "', argument " "2"" of type '" "int""'");
24301   }
24302   arg2 = static_cast< int >(val2);
24303   result = (Hex::Edge *)(arg1)->getEdge(arg2);
24304   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
24305   return resultobj;
24306 fail:
24307   return NULL;
24308 }
24309
24310
24311 SWIGINTERN PyObject *_wrap_Document_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24312   PyObject *resultobj = 0;
24313   Hex::Document *arg1 = (Hex::Document *) 0 ;
24314   int arg2 ;
24315   Hex::Vertex *result = 0 ;
24316   void *argp1 = 0 ;
24317   int res1 = 0 ;
24318   int val2 ;
24319   int ecode2 = 0 ;
24320   PyObject * obj0 = 0 ;
24321   PyObject * obj1 = 0 ;
24322
24323   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVertex",&obj0,&obj1)) SWIG_fail;
24324   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24325   if (!SWIG_IsOK(res1)) {
24326     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24327   }
24328   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24329   ecode2 = SWIG_AsVal_int(obj1, &val2);
24330   if (!SWIG_IsOK(ecode2)) {
24331     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getVertex" "', argument " "2"" of type '" "int""'");
24332   }
24333   arg2 = static_cast< int >(val2);
24334   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
24335   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24336   return resultobj;
24337 fail:
24338   return NULL;
24339 }
24340
24341
24342 SWIGINTERN PyObject *_wrap_Document_getUsedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24343   PyObject *resultobj = 0;
24344   Hex::Document *arg1 = (Hex::Document *) 0 ;
24345   int arg2 ;
24346   Hex::Hexa *result = 0 ;
24347   void *argp1 = 0 ;
24348   int res1 = 0 ;
24349   int val2 ;
24350   int ecode2 = 0 ;
24351   PyObject * obj0 = 0 ;
24352   PyObject * obj1 = 0 ;
24353
24354   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedHexa",&obj0,&obj1)) SWIG_fail;
24355   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24356   if (!SWIG_IsOK(res1)) {
24357     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
24358   }
24359   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24360   ecode2 = SWIG_AsVal_int(obj1, &val2);
24361   if (!SWIG_IsOK(ecode2)) {
24362     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedHexa" "', argument " "2"" of type '" "int""'");
24363   }
24364   arg2 = static_cast< int >(val2);
24365   result = (Hex::Hexa *)(arg1)->getUsedHexa(arg2);
24366   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
24367   return resultobj;
24368 fail:
24369   return NULL;
24370 }
24371
24372
24373 SWIGINTERN PyObject *_wrap_Document_getUsedQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24374   PyObject *resultobj = 0;
24375   Hex::Document *arg1 = (Hex::Document *) 0 ;
24376   int arg2 ;
24377   Hex::Quad *result = 0 ;
24378   void *argp1 = 0 ;
24379   int res1 = 0 ;
24380   int val2 ;
24381   int ecode2 = 0 ;
24382   PyObject * obj0 = 0 ;
24383   PyObject * obj1 = 0 ;
24384
24385   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedQuad",&obj0,&obj1)) SWIG_fail;
24386   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24387   if (!SWIG_IsOK(res1)) {
24388     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24389   }
24390   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24391   ecode2 = SWIG_AsVal_int(obj1, &val2);
24392   if (!SWIG_IsOK(ecode2)) {
24393     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedQuad" "', argument " "2"" of type '" "int""'");
24394   }
24395   arg2 = static_cast< int >(val2);
24396   result = (Hex::Quad *)(arg1)->getUsedQuad(arg2);
24397   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
24398   return resultobj;
24399 fail:
24400   return NULL;
24401 }
24402
24403
24404 SWIGINTERN PyObject *_wrap_Document_getUsedEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405   PyObject *resultobj = 0;
24406   Hex::Document *arg1 = (Hex::Document *) 0 ;
24407   int arg2 ;
24408   Hex::Edge *result = 0 ;
24409   void *argp1 = 0 ;
24410   int res1 = 0 ;
24411   int val2 ;
24412   int ecode2 = 0 ;
24413   PyObject * obj0 = 0 ;
24414   PyObject * obj1 = 0 ;
24415
24416   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedEdge",&obj0,&obj1)) SWIG_fail;
24417   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24418   if (!SWIG_IsOK(res1)) {
24419     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24420   }
24421   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24422   ecode2 = SWIG_AsVal_int(obj1, &val2);
24423   if (!SWIG_IsOK(ecode2)) {
24424     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedEdge" "', argument " "2"" of type '" "int""'");
24425   }
24426   arg2 = static_cast< int >(val2);
24427   result = (Hex::Edge *)(arg1)->getUsedEdge(arg2);
24428   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
24429   return resultobj;
24430 fail:
24431   return NULL;
24432 }
24433
24434
24435 SWIGINTERN PyObject *_wrap_Document_getUsedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24436   PyObject *resultobj = 0;
24437   Hex::Document *arg1 = (Hex::Document *) 0 ;
24438   int arg2 ;
24439   Hex::Vertex *result = 0 ;
24440   void *argp1 = 0 ;
24441   int res1 = 0 ;
24442   int val2 ;
24443   int ecode2 = 0 ;
24444   PyObject * obj0 = 0 ;
24445   PyObject * obj1 = 0 ;
24446
24447   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedVertex",&obj0,&obj1)) SWIG_fail;
24448   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24449   if (!SWIG_IsOK(res1)) {
24450     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24451   }
24452   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24453   ecode2 = SWIG_AsVal_int(obj1, &val2);
24454   if (!SWIG_IsOK(ecode2)) {
24455     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedVertex" "', argument " "2"" of type '" "int""'");
24456   }
24457   arg2 = static_cast< int >(val2);
24458   result = (Hex::Vertex *)(arg1)->getUsedVertex(arg2);
24459   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24460   return resultobj;
24461 fail:
24462   return NULL;
24463 }
24464
24465
24466 SWIGINTERN PyObject *_wrap_Document_getVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24467   PyObject *resultobj = 0;
24468   Hex::Document *arg1 = (Hex::Document *) 0 ;
24469   int arg2 ;
24470   Hex::Vector *result = 0 ;
24471   void *argp1 = 0 ;
24472   int res1 = 0 ;
24473   int val2 ;
24474   int ecode2 = 0 ;
24475   PyObject * obj0 = 0 ;
24476   PyObject * obj1 = 0 ;
24477
24478   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVector",&obj0,&obj1)) SWIG_fail;
24479   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24480   if (!SWIG_IsOK(res1)) {
24481     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getVector" "', argument " "1"" of type '" "Hex::Document *""'");
24482   }
24483   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24484   ecode2 = SWIG_AsVal_int(obj1, &val2);
24485   if (!SWIG_IsOK(ecode2)) {
24486     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getVector" "', argument " "2"" of type '" "int""'");
24487   }
24488   arg2 = static_cast< int >(val2);
24489   result = (Hex::Vector *)(arg1)->getVector(arg2);
24490   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
24491   return resultobj;
24492 fail:
24493   return NULL;
24494 }
24495
24496
24497 SWIGINTERN PyObject *_wrap_Document_getShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24498   PyObject *resultobj = 0;
24499   Hex::Document *arg1 = (Hex::Document *) 0 ;
24500   int arg2 ;
24501   Hex::NewShape *result = 0 ;
24502   void *argp1 = 0 ;
24503   int res1 = 0 ;
24504   int val2 ;
24505   int ecode2 = 0 ;
24506   PyObject * obj0 = 0 ;
24507   PyObject * obj1 = 0 ;
24508
24509   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getShape",&obj0,&obj1)) SWIG_fail;
24510   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24511   if (!SWIG_IsOK(res1)) {
24512     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getShape" "', argument " "1"" of type '" "Hex::Document *""'");
24513   }
24514   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24515   ecode2 = SWIG_AsVal_int(obj1, &val2);
24516   if (!SWIG_IsOK(ecode2)) {
24517     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getShape" "', argument " "2"" of type '" "int""'");
24518   }
24519   arg2 = static_cast< int >(val2);
24520   result = (Hex::NewShape *)(arg1)->getShape(arg2);
24521   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 |  0 );
24522   return resultobj;
24523 fail:
24524   return NULL;
24525 }
24526
24527
24528 SWIGINTERN PyObject *_wrap_Document_getGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24529   PyObject *resultobj = 0;
24530   Hex::Document *arg1 = (Hex::Document *) 0 ;
24531   int arg2 ;
24532   Hex::Group *result = 0 ;
24533   void *argp1 = 0 ;
24534   int res1 = 0 ;
24535   int val2 ;
24536   int ecode2 = 0 ;
24537   PyObject * obj0 = 0 ;
24538   PyObject * obj1 = 0 ;
24539
24540   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getGroup",&obj0,&obj1)) SWIG_fail;
24541   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24542   if (!SWIG_IsOK(res1)) {
24543     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getGroup" "', argument " "1"" of type '" "Hex::Document *""'");
24544   }
24545   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24546   ecode2 = SWIG_AsVal_int(obj1, &val2);
24547   if (!SWIG_IsOK(ecode2)) {
24548     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getGroup" "', argument " "2"" of type '" "int""'");
24549   }
24550   arg2 = static_cast< int >(val2);
24551   result = (Hex::Group *)(arg1)->getGroup(arg2);
24552   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
24553   return resultobj;
24554 fail:
24555   return NULL;
24556 }
24557
24558
24559 SWIGINTERN PyObject *_wrap_Document_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24560   PyObject *resultobj = 0;
24561   Hex::Document *arg1 = (Hex::Document *) 0 ;
24562   int arg2 ;
24563   Hex::Law *result = 0 ;
24564   void *argp1 = 0 ;
24565   int res1 = 0 ;
24566   int val2 ;
24567   int ecode2 = 0 ;
24568   PyObject * obj0 = 0 ;
24569   PyObject * obj1 = 0 ;
24570
24571   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getLaw",&obj0,&obj1)) SWIG_fail;
24572   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24573   if (!SWIG_IsOK(res1)) {
24574     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getLaw" "', argument " "1"" of type '" "Hex::Document *""'");
24575   }
24576   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24577   ecode2 = SWIG_AsVal_int(obj1, &val2);
24578   if (!SWIG_IsOK(ecode2)) {
24579     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getLaw" "', argument " "2"" of type '" "int""'");
24580   }
24581   arg2 = static_cast< int >(val2);
24582   result = (Hex::Law *)(arg1)->getLaw(arg2);
24583   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
24584   return resultobj;
24585 fail:
24586   return NULL;
24587 }
24588
24589
24590 SWIGINTERN PyObject *_wrap_Document_getPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24591   PyObject *resultobj = 0;
24592   Hex::Document *arg1 = (Hex::Document *) 0 ;
24593   int arg2 ;
24594   Hex::Propagation *result = 0 ;
24595   void *argp1 = 0 ;
24596   int res1 = 0 ;
24597   int val2 ;
24598   int ecode2 = 0 ;
24599   PyObject * obj0 = 0 ;
24600   PyObject * obj1 = 0 ;
24601
24602   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getPropagation",&obj0,&obj1)) SWIG_fail;
24603   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24604   if (!SWIG_IsOK(res1)) {
24605     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
24606   }
24607   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24608   ecode2 = SWIG_AsVal_int(obj1, &val2);
24609   if (!SWIG_IsOK(ecode2)) {
24610     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getPropagation" "', argument " "2"" of type '" "int""'");
24611   }
24612   arg2 = static_cast< int >(val2);
24613   result = (Hex::Propagation *)(arg1)->getPropagation(arg2);
24614   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, 0 |  0 );
24615   return resultobj;
24616 fail:
24617   return NULL;
24618 }
24619
24620
24621 SWIGINTERN PyObject *_wrap_Document_getFirstExplicitShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24622   PyObject *resultobj = 0;
24623   Hex::Document *arg1 = (Hex::Document *) 0 ;
24624   cpchar result;
24625   void *argp1 = 0 ;
24626   int res1 = 0 ;
24627   PyObject * obj0 = 0 ;
24628
24629   if (!PyArg_ParseTuple(args,(char *)"O:Document_getFirstExplicitShape",&obj0)) SWIG_fail;
24630   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24631   if (!SWIG_IsOK(res1)) {
24632     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getFirstExplicitShape" "', argument " "1"" of type '" "Hex::Document *""'");
24633   }
24634   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24635   result = (cpchar)(arg1)->getFirstExplicitShape();
24636   resultobj = SWIG_FromCharPtr((const char *)result);
24637   return resultobj;
24638 fail:
24639   return NULL;
24640 }
24641
24642
24643 SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24644   PyObject *resultobj = 0;
24645   Hex::Document *arg1 = (Hex::Document *) 0 ;
24646   double arg2 ;
24647   double arg3 ;
24648   double arg4 ;
24649   Hex::Vertex *result = 0 ;
24650   void *argp1 = 0 ;
24651   int res1 = 0 ;
24652   double val2 ;
24653   int ecode2 = 0 ;
24654   double val3 ;
24655   int ecode3 = 0 ;
24656   double val4 ;
24657   int ecode4 = 0 ;
24658   PyObject * obj0 = 0 ;
24659   PyObject * obj1 = 0 ;
24660   PyObject * obj2 = 0 ;
24661   PyObject * obj3 = 0 ;
24662
24663   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_findVertex",&obj0,&obj1,&obj2,&obj3)) 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_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24667   }
24668   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24669   ecode2 = SWIG_AsVal_double(obj1, &val2);
24670   if (!SWIG_IsOK(ecode2)) {
24671     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "double""'");
24672   }
24673   arg2 = static_cast< double >(val2);
24674   ecode3 = SWIG_AsVal_double(obj2, &val3);
24675   if (!SWIG_IsOK(ecode3)) {
24676     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_findVertex" "', argument " "3"" of type '" "double""'");
24677   }
24678   arg3 = static_cast< double >(val3);
24679   ecode4 = SWIG_AsVal_double(obj3, &val4);
24680   if (!SWIG_IsOK(ecode4)) {
24681     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_findVertex" "', argument " "4"" of type '" "double""'");
24682   }
24683   arg4 = static_cast< double >(val4);
24684   result = (Hex::Vertex *)(arg1)->findVertex(arg2,arg3,arg4);
24685   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24686   return resultobj;
24687 fail:
24688   return NULL;
24689 }
24690
24691
24692 SWIGINTERN PyObject *_wrap_Document_findEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24693   PyObject *resultobj = 0;
24694   Hex::Document *arg1 = (Hex::Document *) 0 ;
24695   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24696   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24697   Hex::Edge *result = 0 ;
24698   void *argp1 = 0 ;
24699   int res1 = 0 ;
24700   void *argp2 = 0 ;
24701   int res2 = 0 ;
24702   void *argp3 = 0 ;
24703   int res3 = 0 ;
24704   PyObject * obj0 = 0 ;
24705   PyObject * obj1 = 0 ;
24706   PyObject * obj2 = 0 ;
24707
24708   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findEdge",&obj0,&obj1,&obj2)) SWIG_fail;
24709   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24710   if (!SWIG_IsOK(res1)) {
24711     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24712   }
24713   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24714   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24715   if (!SWIG_IsOK(res2)) {
24716     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findEdge" "', argument " "2"" of type '" "Hex::Vertex *""'");
24717   }
24718   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24719   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24720   if (!SWIG_IsOK(res3)) {
24721     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findEdge" "', argument " "3"" of type '" "Hex::Vertex *""'");
24722   }
24723   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24724   result = (Hex::Edge *)(arg1)->findEdge(arg2,arg3);
24725   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
24726   return resultobj;
24727 fail:
24728   return NULL;
24729 }
24730
24731
24732 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24733   PyObject *resultobj = 0;
24734   Hex::Document *arg1 = (Hex::Document *) 0 ;
24735   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24736   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24737   Hex::Quad *result = 0 ;
24738   void *argp1 = 0 ;
24739   int res1 = 0 ;
24740   void *argp2 = 0 ;
24741   int res2 = 0 ;
24742   void *argp3 = 0 ;
24743   int res3 = 0 ;
24744   PyObject * obj0 = 0 ;
24745   PyObject * obj1 = 0 ;
24746   PyObject * obj2 = 0 ;
24747
24748   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
24749   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24750   if (!SWIG_IsOK(res1)) {
24751     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24752   }
24753   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24754   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24755   if (!SWIG_IsOK(res2)) {
24756     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Vertex *""'");
24757   }
24758   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24759   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24760   if (!SWIG_IsOK(res3)) {
24761     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
24762   }
24763   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24764   result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
24765   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
24766   return resultobj;
24767 fail:
24768   return NULL;
24769 }
24770
24771
24772 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24773   PyObject *resultobj = 0;
24774   Hex::Document *arg1 = (Hex::Document *) 0 ;
24775   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
24776   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
24777   Hex::Quad *result = 0 ;
24778   void *argp1 = 0 ;
24779   int res1 = 0 ;
24780   void *argp2 = 0 ;
24781   int res2 = 0 ;
24782   void *argp3 = 0 ;
24783   int res3 = 0 ;
24784   PyObject * obj0 = 0 ;
24785   PyObject * obj1 = 0 ;
24786   PyObject * obj2 = 0 ;
24787
24788   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
24789   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24790   if (!SWIG_IsOK(res1)) {
24791     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24792   }
24793   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24794   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
24795   if (!SWIG_IsOK(res2)) {
24796     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Edge *""'");
24797   }
24798   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
24799   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
24800   if (!SWIG_IsOK(res3)) {
24801     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Edge *""'");
24802   }
24803   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
24804   result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
24805   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
24806   return resultobj;
24807 fail:
24808   return NULL;
24809 }
24810
24811
24812 SWIGINTERN PyObject *_wrap_Document_findQuad(PyObject *self, PyObject *args) {
24813   int argc;
24814   PyObject *argv[4];
24815   int ii;
24816
24817   if (!PyTuple_Check(args)) SWIG_fail;
24818   argc = PyObject_Length(args);
24819   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
24820     argv[ii] = PyTuple_GET_ITEM(args,ii);
24821   }
24822   if (argc == 3) {
24823     int _v;
24824     void *vptr = 0;
24825     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24826     _v = SWIG_CheckState(res);
24827     if (_v) {
24828       void *vptr = 0;
24829       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
24830       _v = SWIG_CheckState(res);
24831       if (_v) {
24832         void *vptr = 0;
24833         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
24834         _v = SWIG_CheckState(res);
24835         if (_v) {
24836           return _wrap_Document_findQuad__SWIG_0(self, args);
24837         }
24838       }
24839     }
24840   }
24841   if (argc == 3) {
24842     int _v;
24843     void *vptr = 0;
24844     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24845     _v = SWIG_CheckState(res);
24846     if (_v) {
24847       void *vptr = 0;
24848       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Edge, 0);
24849       _v = SWIG_CheckState(res);
24850       if (_v) {
24851         void *vptr = 0;
24852         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
24853         _v = SWIG_CheckState(res);
24854         if (_v) {
24855           return _wrap_Document_findQuad__SWIG_1(self, args);
24856         }
24857       }
24858     }
24859   }
24860
24861 fail:
24862   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_findQuad'.\n  Possible C/C++ prototypes are:\n    findQuad(Hex::Vertex *,Hex::Vertex *)\n    findQuad(Hex::Edge *,Hex::Edge *)\n");
24863   return NULL;
24864 }
24865
24866
24867 SWIGINTERN PyObject *_wrap_Document_findHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24868   PyObject *resultobj = 0;
24869   Hex::Document *arg1 = (Hex::Document *) 0 ;
24870   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24871   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24872   Hex::Hexa *result = 0 ;
24873   void *argp1 = 0 ;
24874   int res1 = 0 ;
24875   void *argp2 = 0 ;
24876   int res2 = 0 ;
24877   void *argp3 = 0 ;
24878   int res3 = 0 ;
24879   PyObject * obj0 = 0 ;
24880   PyObject * obj1 = 0 ;
24881   PyObject * obj2 = 0 ;
24882
24883   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findHexa",&obj0,&obj1,&obj2)) SWIG_fail;
24884   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24885   if (!SWIG_IsOK(res1)) {
24886     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findHexa" "', argument " "1"" of type '" "Hex::Document *""'");
24887   }
24888   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24889   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24890   if (!SWIG_IsOK(res2)) {
24891     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findHexa" "', argument " "2"" of type '" "Hex::Vertex *""'");
24892   }
24893   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24894   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24895   if (!SWIG_IsOK(res3)) {
24896     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findHexa" "', argument " "3"" of type '" "Hex::Vertex *""'");
24897   }
24898   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24899   result = (Hex::Hexa *)(arg1)->findHexa(arg2,arg3);
24900   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
24901   return resultobj;
24902 fail:
24903   return NULL;
24904 }
24905
24906
24907 SWIGINTERN PyObject *_wrap_Document_findGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24908   PyObject *resultobj = 0;
24909   Hex::Document *arg1 = (Hex::Document *) 0 ;
24910   cpchar arg2 = (cpchar) 0 ;
24911   Hex::Group *result = 0 ;
24912   void *argp1 = 0 ;
24913   int res1 = 0 ;
24914   int res2 ;
24915   char *buf2 = 0 ;
24916   int alloc2 = 0 ;
24917   PyObject * obj0 = 0 ;
24918   PyObject * obj1 = 0 ;
24919
24920   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findGroup",&obj0,&obj1)) SWIG_fail;
24921   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24922   if (!SWIG_IsOK(res1)) {
24923     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findGroup" "', argument " "1"" of type '" "Hex::Document *""'");
24924   }
24925   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24926   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24927   if (!SWIG_IsOK(res2)) {
24928     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findGroup" "', argument " "2"" of type '" "cpchar""'");
24929   }
24930   arg2 = reinterpret_cast< cpchar >(buf2);
24931   result = (Hex::Group *)(arg1)->findGroup(arg2);
24932   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
24933   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24934   return resultobj;
24935 fail:
24936   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24937   return NULL;
24938 }
24939
24940
24941 SWIGINTERN PyObject *_wrap_Document_findLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24942   PyObject *resultobj = 0;
24943   Hex::Document *arg1 = (Hex::Document *) 0 ;
24944   cpchar arg2 = (cpchar) 0 ;
24945   Hex::Law *result = 0 ;
24946   void *argp1 = 0 ;
24947   int res1 = 0 ;
24948   int res2 ;
24949   char *buf2 = 0 ;
24950   int alloc2 = 0 ;
24951   PyObject * obj0 = 0 ;
24952   PyObject * obj1 = 0 ;
24953
24954   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findLaw",&obj0,&obj1)) SWIG_fail;
24955   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24956   if (!SWIG_IsOK(res1)) {
24957     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findLaw" "', argument " "1"" of type '" "Hex::Document *""'");
24958   }
24959   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24960   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24961   if (!SWIG_IsOK(res2)) {
24962     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findLaw" "', argument " "2"" of type '" "cpchar""'");
24963   }
24964   arg2 = reinterpret_cast< cpchar >(buf2);
24965   result = (Hex::Law *)(arg1)->findLaw(arg2);
24966   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
24967   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24968   return resultobj;
24969 fail:
24970   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24971   return NULL;
24972 }
24973
24974
24975 SWIGINTERN PyObject *_wrap_Document_findPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24976   PyObject *resultobj = 0;
24977   Hex::Document *arg1 = (Hex::Document *) 0 ;
24978   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
24979   Hex::Propagation *result = 0 ;
24980   void *argp1 = 0 ;
24981   int res1 = 0 ;
24982   void *argp2 = 0 ;
24983   int res2 = 0 ;
24984   PyObject * obj0 = 0 ;
24985   PyObject * obj1 = 0 ;
24986
24987   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findPropagation",&obj0,&obj1)) SWIG_fail;
24988   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24989   if (!SWIG_IsOK(res1)) {
24990     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
24991   }
24992   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24993   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
24994   if (!SWIG_IsOK(res2)) {
24995     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findPropagation" "', argument " "2"" of type '" "Hex::Edge *""'");
24996   }
24997   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
24998   result = (Hex::Propagation *)(arg1)->findPropagation(arg2);
24999   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, 0 |  0 );
25000   return resultobj;
25001 fail:
25002   return NULL;
25003 }
25004
25005
25006 SWIGINTERN PyObject *_wrap_Document_removeHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25007   PyObject *resultobj = 0;
25008   Hex::Document *arg1 = (Hex::Document *) 0 ;
25009   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
25010   int result;
25011   void *argp1 = 0 ;
25012   int res1 = 0 ;
25013   void *argp2 = 0 ;
25014   int res2 = 0 ;
25015   PyObject * obj0 = 0 ;
25016   PyObject * obj1 = 0 ;
25017
25018   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeHexa",&obj0,&obj1)) SWIG_fail;
25019   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25020   if (!SWIG_IsOK(res1)) {
25021     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25022   }
25023   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25024   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25025   if (!SWIG_IsOK(res2)) {
25026     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
25027   }
25028   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
25029   result = (int)(arg1)->removeHexa(arg2);
25030   resultobj = SWIG_From_int(static_cast< int >(result));
25031   return resultobj;
25032 fail:
25033   return NULL;
25034 }
25035
25036
25037 SWIGINTERN PyObject *_wrap_Document_removeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25038   PyObject *resultobj = 0;
25039   Hex::Document *arg1 = (Hex::Document *) 0 ;
25040   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25041   int result;
25042   void *argp1 = 0 ;
25043   int res1 = 0 ;
25044   void *argp2 = 0 ;
25045   int res2 = 0 ;
25046   PyObject * obj0 = 0 ;
25047   PyObject * obj1 = 0 ;
25048
25049   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeQuad",&obj0,&obj1)) 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_removeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
25053   }
25054   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25055   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25056   if (!SWIG_IsOK(res2)) {
25057     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
25058   }
25059   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25060   result = (int)(arg1)->removeQuad(arg2);
25061   resultobj = SWIG_From_int(static_cast< int >(result));
25062   return resultobj;
25063 fail:
25064   return NULL;
25065 }
25066
25067
25068 SWIGINTERN PyObject *_wrap_Document_removeConnectedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25069   PyObject *resultobj = 0;
25070   Hex::Document *arg1 = (Hex::Document *) 0 ;
25071   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
25072   int result;
25073   void *argp1 = 0 ;
25074   int res1 = 0 ;
25075   void *argp2 = 0 ;
25076   int res2 = 0 ;
25077   PyObject * obj0 = 0 ;
25078   PyObject * obj1 = 0 ;
25079
25080   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeConnectedHexa",&obj0,&obj1)) SWIG_fail;
25081   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25082   if (!SWIG_IsOK(res1)) {
25083     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeConnectedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25084   }
25085   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25086   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25087   if (!SWIG_IsOK(res2)) {
25088     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeConnectedHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
25089   }
25090   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
25091   result = (int)(arg1)->removeConnectedHexa(arg2);
25092   resultobj = SWIG_From_int(static_cast< int >(result));
25093   return resultobj;
25094 fail:
25095   return NULL;
25096 }
25097
25098
25099 SWIGINTERN PyObject *_wrap_Document_removeElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25100   PyObject *resultobj = 0;
25101   Hex::Document *arg1 = (Hex::Document *) 0 ;
25102   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
25103   int result;
25104   void *argp1 = 0 ;
25105   int res1 = 0 ;
25106   void *argp2 = 0 ;
25107   int res2 = 0 ;
25108   PyObject * obj0 = 0 ;
25109   PyObject * obj1 = 0 ;
25110
25111   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeElements",&obj0,&obj1)) SWIG_fail;
25112   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25113   if (!SWIG_IsOK(res1)) {
25114     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeElements" "', argument " "1"" of type '" "Hex::Document *""'");
25115   }
25116   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25117   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
25118   if (!SWIG_IsOK(res2)) {
25119     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeElements" "', argument " "2"" of type '" "Hex::Elements *""'");
25120   }
25121   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
25122   result = (int)(arg1)->removeElements(arg2);
25123   resultobj = SWIG_From_int(static_cast< int >(result));
25124   return resultobj;
25125 fail:
25126   return NULL;
25127 }
25128
25129
25130 SWIGINTERN PyObject *_wrap_Document_removeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25131   PyObject *resultobj = 0;
25132   Hex::Document *arg1 = (Hex::Document *) 0 ;
25133   Hex::Group *arg2 = (Hex::Group *) 0 ;
25134   int result;
25135   void *argp1 = 0 ;
25136   int res1 = 0 ;
25137   void *argp2 = 0 ;
25138   int res2 = 0 ;
25139   PyObject * obj0 = 0 ;
25140   PyObject * obj1 = 0 ;
25141
25142   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeGroup",&obj0,&obj1)) SWIG_fail;
25143   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25144   if (!SWIG_IsOK(res1)) {
25145     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
25146   }
25147   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25148   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Group, 0 |  0 );
25149   if (!SWIG_IsOK(res2)) {
25150     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeGroup" "', argument " "2"" of type '" "Hex::Group *""'");
25151   }
25152   arg2 = reinterpret_cast< Hex::Group * >(argp2);
25153   result = (int)(arg1)->removeGroup(arg2);
25154   resultobj = SWIG_From_int(static_cast< int >(result));
25155   return resultobj;
25156 fail:
25157   return NULL;
25158 }
25159
25160
25161 SWIGINTERN PyObject *_wrap_Document_removeLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25162   PyObject *resultobj = 0;
25163   Hex::Document *arg1 = (Hex::Document *) 0 ;
25164   Hex::Law *arg2 = (Hex::Law *) 0 ;
25165   int result;
25166   void *argp1 = 0 ;
25167   int res1 = 0 ;
25168   void *argp2 = 0 ;
25169   int res2 = 0 ;
25170   PyObject * obj0 = 0 ;
25171   PyObject * obj1 = 0 ;
25172
25173   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeLaw",&obj0,&obj1)) SWIG_fail;
25174   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25175   if (!SWIG_IsOK(res1)) {
25176     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeLaw" "', argument " "1"" of type '" "Hex::Document *""'");
25177   }
25178   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25179   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
25180   if (!SWIG_IsOK(res2)) {
25181     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeLaw" "', argument " "2"" of type '" "Hex::Law *""'");
25182   }
25183   arg2 = reinterpret_cast< Hex::Law * >(argp2);
25184   result = (int)(arg1)->removeLaw(arg2);
25185   resultobj = SWIG_From_int(static_cast< int >(result));
25186   return resultobj;
25187 fail:
25188   return NULL;
25189 }
25190
25191
25192 SWIGINTERN PyObject *_wrap_Document_makeCartesianTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25193   PyObject *resultobj = 0;
25194   Hex::Document *arg1 = (Hex::Document *) 0 ;
25195   int arg2 ;
25196   int arg3 ;
25197   int arg4 ;
25198   Hex::Elements *result = 0 ;
25199   void *argp1 = 0 ;
25200   int res1 = 0 ;
25201   int val2 ;
25202   int ecode2 = 0 ;
25203   int val3 ;
25204   int ecode3 = 0 ;
25205   int val4 ;
25206   int ecode4 = 0 ;
25207   PyObject * obj0 = 0 ;
25208   PyObject * obj1 = 0 ;
25209   PyObject * obj2 = 0 ;
25210   PyObject * obj3 = 0 ;
25211
25212   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCartesianTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25213   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25214   if (!SWIG_IsOK(res1)) {
25215     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianTop" "', argument " "1"" of type '" "Hex::Document *""'");
25216   }
25217   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25218   ecode2 = SWIG_AsVal_int(obj1, &val2);
25219   if (!SWIG_IsOK(ecode2)) {
25220     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCartesianTop" "', argument " "2"" of type '" "int""'");
25221   }
25222   arg2 = static_cast< int >(val2);
25223   ecode3 = SWIG_AsVal_int(obj2, &val3);
25224   if (!SWIG_IsOK(ecode3)) {
25225     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCartesianTop" "', argument " "3"" of type '" "int""'");
25226   }
25227   arg3 = static_cast< int >(val3);
25228   ecode4 = SWIG_AsVal_int(obj3, &val4);
25229   if (!SWIG_IsOK(ecode4)) {
25230     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCartesianTop" "', argument " "4"" of type '" "int""'");
25231   }
25232   arg4 = static_cast< int >(val4);
25233   result = (Hex::Elements *)(arg1)->makeCartesianTop(arg2,arg3,arg4);
25234   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25235   return resultobj;
25236 fail:
25237   return NULL;
25238 }
25239
25240
25241 SWIGINTERN PyObject *_wrap_Document_makeCartesianUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25242   PyObject *resultobj = 0;
25243   Hex::Document *arg1 = (Hex::Document *) 0 ;
25244   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25245   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25246   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25247   Hex::Vector *arg5 = (Hex::Vector *) 0 ;
25248   double arg6 ;
25249   double arg7 ;
25250   double arg8 ;
25251   int arg9 ;
25252   int arg10 ;
25253   int arg11 ;
25254   Hex::Elements *result = 0 ;
25255   void *argp1 = 0 ;
25256   int res1 = 0 ;
25257   void *argp2 = 0 ;
25258   int res2 = 0 ;
25259   void *argp3 = 0 ;
25260   int res3 = 0 ;
25261   void *argp4 = 0 ;
25262   int res4 = 0 ;
25263   void *argp5 = 0 ;
25264   int res5 = 0 ;
25265   double val6 ;
25266   int ecode6 = 0 ;
25267   double val7 ;
25268   int ecode7 = 0 ;
25269   double val8 ;
25270   int ecode8 = 0 ;
25271   int val9 ;
25272   int ecode9 = 0 ;
25273   int val10 ;
25274   int ecode10 = 0 ;
25275   int val11 ;
25276   int ecode11 = 0 ;
25277   PyObject * obj0 = 0 ;
25278   PyObject * obj1 = 0 ;
25279   PyObject * obj2 = 0 ;
25280   PyObject * obj3 = 0 ;
25281   PyObject * obj4 = 0 ;
25282   PyObject * obj5 = 0 ;
25283   PyObject * obj6 = 0 ;
25284   PyObject * obj7 = 0 ;
25285   PyObject * obj8 = 0 ;
25286   PyObject * obj9 = 0 ;
25287   PyObject * obj10 = 0 ;
25288
25289   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCartesianUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
25290   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25291   if (!SWIG_IsOK(res1)) {
25292     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianUni" "', argument " "1"" of type '" "Hex::Document *""'");
25293   }
25294   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25295   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25296   if (!SWIG_IsOK(res2)) {
25297     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesianUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
25298   }
25299   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25300   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25301   if (!SWIG_IsOK(res3)) {
25302     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesianUni" "', argument " "3"" of type '" "Hex::Vector *""'");
25303   }
25304   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25305   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25306   if (!SWIG_IsOK(res4)) {
25307     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesianUni" "', argument " "4"" of type '" "Hex::Vector *""'");
25308   }
25309   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25310   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25311   if (!SWIG_IsOK(res5)) {
25312     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesianUni" "', argument " "5"" of type '" "Hex::Vector *""'");
25313   }
25314   arg5 = reinterpret_cast< Hex::Vector * >(argp5);
25315   ecode6 = SWIG_AsVal_double(obj5, &val6);
25316   if (!SWIG_IsOK(ecode6)) {
25317     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCartesianUni" "', argument " "6"" of type '" "double""'");
25318   }
25319   arg6 = static_cast< double >(val6);
25320   ecode7 = SWIG_AsVal_double(obj6, &val7);
25321   if (!SWIG_IsOK(ecode7)) {
25322     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCartesianUni" "', argument " "7"" of type '" "double""'");
25323   }
25324   arg7 = static_cast< double >(val7);
25325   ecode8 = SWIG_AsVal_double(obj7, &val8);
25326   if (!SWIG_IsOK(ecode8)) {
25327     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCartesianUni" "', argument " "8"" of type '" "double""'");
25328   }
25329   arg8 = static_cast< double >(val8);
25330   ecode9 = SWIG_AsVal_int(obj8, &val9);
25331   if (!SWIG_IsOK(ecode9)) {
25332     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCartesianUni" "', argument " "9"" of type '" "int""'");
25333   }
25334   arg9 = static_cast< int >(val9);
25335   ecode10 = SWIG_AsVal_int(obj9, &val10);
25336   if (!SWIG_IsOK(ecode10)) {
25337     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCartesianUni" "', argument " "10"" of type '" "int""'");
25338   }
25339   arg10 = static_cast< int >(val10);
25340   ecode11 = SWIG_AsVal_int(obj10, &val11);
25341   if (!SWIG_IsOK(ecode11)) {
25342     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCartesianUni" "', argument " "11"" of type '" "int""'");
25343   }
25344   arg11 = static_cast< int >(val11);
25345   result = (Hex::Elements *)(arg1)->makeCartesianUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25346   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25347   return resultobj;
25348 fail:
25349   return NULL;
25350 }
25351
25352
25353 SWIGINTERN PyObject *_wrap_Document_makeCartesian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25354   PyObject *resultobj = 0;
25355   Hex::Document *arg1 = (Hex::Document *) 0 ;
25356   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25357   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25358   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25359   Hex::Vector *arg5 = (Hex::Vector *) 0 ;
25360   Hex::RealVector arg6 ;
25361   Hex::RealVector arg7 ;
25362   Hex::RealVector arg8 ;
25363   Hex::Elements *result = 0 ;
25364   void *argp1 = 0 ;
25365   int res1 = 0 ;
25366   void *argp2 = 0 ;
25367   int res2 = 0 ;
25368   void *argp3 = 0 ;
25369   int res3 = 0 ;
25370   void *argp4 = 0 ;
25371   int res4 = 0 ;
25372   void *argp5 = 0 ;
25373   int res5 = 0 ;
25374   PyObject * obj0 = 0 ;
25375   PyObject * obj1 = 0 ;
25376   PyObject * obj2 = 0 ;
25377   PyObject * obj3 = 0 ;
25378   PyObject * obj4 = 0 ;
25379   PyObject * obj5 = 0 ;
25380   PyObject * obj6 = 0 ;
25381   PyObject * obj7 = 0 ;
25382
25383   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_makeCartesian",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
25384   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25385   if (!SWIG_IsOK(res1)) {
25386     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesian" "', argument " "1"" of type '" "Hex::Document *""'");
25387   }
25388   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25389   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25390   if (!SWIG_IsOK(res2)) {
25391     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesian" "', argument " "2"" of type '" "Hex::Vertex *""'");
25392   }
25393   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25394   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25395   if (!SWIG_IsOK(res3)) {
25396     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesian" "', argument " "3"" of type '" "Hex::Vector *""'");
25397   }
25398   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25399   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25400   if (!SWIG_IsOK(res4)) {
25401     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesian" "', argument " "4"" of type '" "Hex::Vector *""'");
25402   }
25403   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25404   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25405   if (!SWIG_IsOK(res5)) {
25406     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesian" "', argument " "5"" of type '" "Hex::Vector *""'");
25407   }
25408   arg5 = reinterpret_cast< Hex::Vector * >(argp5);
25409   {
25410     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25411     int res = swig::asptr(obj5, &ptr);
25412     if (!SWIG_IsOK(res) || !ptr) {
25413       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "6"" of type '" "Hex::RealVector""'");
25414     }
25415     arg6 = *ptr;
25416     if (SWIG_IsNewObj(res)) delete ptr;
25417   }
25418   {
25419     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25420     int res = swig::asptr(obj6, &ptr);
25421     if (!SWIG_IsOK(res) || !ptr) {
25422       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "7"" of type '" "Hex::RealVector""'");
25423     }
25424     arg7 = *ptr;
25425     if (SWIG_IsNewObj(res)) delete ptr;
25426   }
25427   {
25428     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25429     int res = swig::asptr(obj7, &ptr);
25430     if (!SWIG_IsOK(res) || !ptr) {
25431       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "8"" of type '" "Hex::RealVector""'");
25432     }
25433     arg8 = *ptr;
25434     if (SWIG_IsNewObj(res)) delete ptr;
25435   }
25436   result = (Hex::Elements *)(arg1)->makeCartesian(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
25437   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25438   return resultobj;
25439 fail:
25440   return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *_wrap_Document_makeCylinderTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25445   PyObject *resultobj = 0;
25446   Hex::Document *arg1 = (Hex::Document *) 0 ;
25447   int arg2 ;
25448   int arg3 ;
25449   int arg4 ;
25450   Hex::Elements *result = 0 ;
25451   void *argp1 = 0 ;
25452   int res1 = 0 ;
25453   int val2 ;
25454   int ecode2 = 0 ;
25455   int val3 ;
25456   int ecode3 = 0 ;
25457   int val4 ;
25458   int ecode4 = 0 ;
25459   PyObject * obj0 = 0 ;
25460   PyObject * obj1 = 0 ;
25461   PyObject * obj2 = 0 ;
25462   PyObject * obj3 = 0 ;
25463
25464   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCylinderTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25465   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25466   if (!SWIG_IsOK(res1)) {
25467     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderTop" "', argument " "1"" of type '" "Hex::Document *""'");
25468   }
25469   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25470   ecode2 = SWIG_AsVal_int(obj1, &val2);
25471   if (!SWIG_IsOK(ecode2)) {
25472     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCylinderTop" "', argument " "2"" of type '" "int""'");
25473   }
25474   arg2 = static_cast< int >(val2);
25475   ecode3 = SWIG_AsVal_int(obj2, &val3);
25476   if (!SWIG_IsOK(ecode3)) {
25477     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCylinderTop" "', argument " "3"" of type '" "int""'");
25478   }
25479   arg3 = static_cast< int >(val3);
25480   ecode4 = SWIG_AsVal_int(obj3, &val4);
25481   if (!SWIG_IsOK(ecode4)) {
25482     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinderTop" "', argument " "4"" of type '" "int""'");
25483   }
25484   arg4 = static_cast< int >(val4);
25485   result = (Hex::Elements *)(arg1)->makeCylinderTop(arg2,arg3,arg4);
25486   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25487   return resultobj;
25488 fail:
25489   return NULL;
25490 }
25491
25492
25493 SWIGINTERN PyObject *_wrap_Document_makeCylinderUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25494   PyObject *resultobj = 0;
25495   Hex::Document *arg1 = (Hex::Document *) 0 ;
25496   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25497   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25498   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25499   double arg5 ;
25500   double arg6 ;
25501   double arg7 ;
25502   double arg8 ;
25503   int arg9 ;
25504   int arg10 ;
25505   int arg11 ;
25506   Hex::Elements *result = 0 ;
25507   void *argp1 = 0 ;
25508   int res1 = 0 ;
25509   void *argp2 = 0 ;
25510   int res2 = 0 ;
25511   void *argp3 = 0 ;
25512   int res3 = 0 ;
25513   void *argp4 = 0 ;
25514   int res4 = 0 ;
25515   double val5 ;
25516   int ecode5 = 0 ;
25517   double val6 ;
25518   int ecode6 = 0 ;
25519   double val7 ;
25520   int ecode7 = 0 ;
25521   double val8 ;
25522   int ecode8 = 0 ;
25523   int val9 ;
25524   int ecode9 = 0 ;
25525   int val10 ;
25526   int ecode10 = 0 ;
25527   int val11 ;
25528   int ecode11 = 0 ;
25529   PyObject * obj0 = 0 ;
25530   PyObject * obj1 = 0 ;
25531   PyObject * obj2 = 0 ;
25532   PyObject * obj3 = 0 ;
25533   PyObject * obj4 = 0 ;
25534   PyObject * obj5 = 0 ;
25535   PyObject * obj6 = 0 ;
25536   PyObject * obj7 = 0 ;
25537   PyObject * obj8 = 0 ;
25538   PyObject * obj9 = 0 ;
25539   PyObject * obj10 = 0 ;
25540
25541   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCylinderUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
25542   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25543   if (!SWIG_IsOK(res1)) {
25544     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderUni" "', argument " "1"" of type '" "Hex::Document *""'");
25545   }
25546   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25547   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25548   if (!SWIG_IsOK(res2)) {
25549     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinderUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
25550   }
25551   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25552   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25553   if (!SWIG_IsOK(res3)) {
25554     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinderUni" "', argument " "3"" of type '" "Hex::Vector *""'");
25555   }
25556   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25557   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25558   if (!SWIG_IsOK(res4)) {
25559     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinderUni" "', argument " "4"" of type '" "Hex::Vector *""'");
25560   }
25561   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25562   ecode5 = SWIG_AsVal_double(obj4, &val5);
25563   if (!SWIG_IsOK(ecode5)) {
25564     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinderUni" "', argument " "5"" of type '" "double""'");
25565   }
25566   arg5 = static_cast< double >(val5);
25567   ecode6 = SWIG_AsVal_double(obj5, &val6);
25568   if (!SWIG_IsOK(ecode6)) {
25569     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCylinderUni" "', argument " "6"" of type '" "double""'");
25570   }
25571   arg6 = static_cast< double >(val6);
25572   ecode7 = SWIG_AsVal_double(obj6, &val7);
25573   if (!SWIG_IsOK(ecode7)) {
25574     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCylinderUni" "', argument " "7"" of type '" "double""'");
25575   }
25576   arg7 = static_cast< double >(val7);
25577   ecode8 = SWIG_AsVal_double(obj7, &val8);
25578   if (!SWIG_IsOK(ecode8)) {
25579     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinderUni" "', argument " "8"" of type '" "double""'");
25580   }
25581   arg8 = static_cast< double >(val8);
25582   ecode9 = SWIG_AsVal_int(obj8, &val9);
25583   if (!SWIG_IsOK(ecode9)) {
25584     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinderUni" "', argument " "9"" of type '" "int""'");
25585   }
25586   arg9 = static_cast< int >(val9);
25587   ecode10 = SWIG_AsVal_int(obj9, &val10);
25588   if (!SWIG_IsOK(ecode10)) {
25589     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCylinderUni" "', argument " "10"" of type '" "int""'");
25590   }
25591   arg10 = static_cast< int >(val10);
25592   ecode11 = SWIG_AsVal_int(obj10, &val11);
25593   if (!SWIG_IsOK(ecode11)) {
25594     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCylinderUni" "', argument " "11"" of type '" "int""'");
25595   }
25596   arg11 = static_cast< int >(val11);
25597   result = (Hex::Elements *)(arg1)->makeCylinderUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25598   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25599   return resultobj;
25600 fail:
25601   return NULL;
25602 }
25603
25604
25605 SWIGINTERN PyObject *_wrap_Document_makeCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25606   PyObject *resultobj = 0;
25607   Hex::Document *arg1 = (Hex::Document *) 0 ;
25608   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25609   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25610   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25611   Hex::RealVector arg5 ;
25612   Hex::RealVector arg6 ;
25613   Hex::RealVector arg7 ;
25614   Hex::Elements *result = 0 ;
25615   void *argp1 = 0 ;
25616   int res1 = 0 ;
25617   void *argp2 = 0 ;
25618   int res2 = 0 ;
25619   void *argp3 = 0 ;
25620   int res3 = 0 ;
25621   void *argp4 = 0 ;
25622   int res4 = 0 ;
25623   PyObject * obj0 = 0 ;
25624   PyObject * obj1 = 0 ;
25625   PyObject * obj2 = 0 ;
25626   PyObject * obj3 = 0 ;
25627   PyObject * obj4 = 0 ;
25628   PyObject * obj5 = 0 ;
25629   PyObject * obj6 = 0 ;
25630
25631   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeCylinder",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25632   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25633   if (!SWIG_IsOK(res1)) {
25634     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
25635   }
25636   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25637   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25638   if (!SWIG_IsOK(res2)) {
25639     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinder" "', argument " "2"" of type '" "Hex::Vertex *""'");
25640   }
25641   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25642   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25643   if (!SWIG_IsOK(res3)) {
25644     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinder" "', argument " "3"" of type '" "Hex::Vector *""'");
25645   }
25646   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25647   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25648   if (!SWIG_IsOK(res4)) {
25649     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinder" "', argument " "4"" of type '" "Hex::Vector *""'");
25650   }
25651   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25652   {
25653     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25654     int res = swig::asptr(obj4, &ptr);
25655     if (!SWIG_IsOK(res) || !ptr) {
25656       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "5"" of type '" "Hex::RealVector""'");
25657     }
25658     arg5 = *ptr;
25659     if (SWIG_IsNewObj(res)) delete ptr;
25660   }
25661   {
25662     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25663     int res = swig::asptr(obj5, &ptr);
25664     if (!SWIG_IsOK(res) || !ptr) {
25665       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "6"" of type '" "Hex::RealVector""'");
25666     }
25667     arg6 = *ptr;
25668     if (SWIG_IsNewObj(res)) delete ptr;
25669   }
25670   {
25671     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25672     int res = swig::asptr(obj6, &ptr);
25673     if (!SWIG_IsOK(res) || !ptr) {
25674       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "7"" of type '" "Hex::RealVector""'");
25675     }
25676     arg7 = *ptr;
25677     if (SWIG_IsNewObj(res)) delete ptr;
25678   }
25679   result = (Hex::Elements *)(arg1)->makeCylinder(arg2,arg3,arg4,arg5,arg6,arg7);
25680   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25681   return resultobj;
25682 fail:
25683   return NULL;
25684 }
25685
25686
25687 SWIGINTERN PyObject *_wrap_Document_makePipeTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25688   PyObject *resultobj = 0;
25689   Hex::Document *arg1 = (Hex::Document *) 0 ;
25690   int arg2 ;
25691   int arg3 ;
25692   int arg4 ;
25693   Hex::Elements *result = 0 ;
25694   void *argp1 = 0 ;
25695   int res1 = 0 ;
25696   int val2 ;
25697   int ecode2 = 0 ;
25698   int val3 ;
25699   int ecode3 = 0 ;
25700   int val4 ;
25701   int ecode4 = 0 ;
25702   PyObject * obj0 = 0 ;
25703   PyObject * obj1 = 0 ;
25704   PyObject * obj2 = 0 ;
25705   PyObject * obj3 = 0 ;
25706
25707   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makePipeTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25708   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25709   if (!SWIG_IsOK(res1)) {
25710     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeTop" "', argument " "1"" of type '" "Hex::Document *""'");
25711   }
25712   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25713   ecode2 = SWIG_AsVal_int(obj1, &val2);
25714   if (!SWIG_IsOK(ecode2)) {
25715     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makePipeTop" "', argument " "2"" of type '" "int""'");
25716   }
25717   arg2 = static_cast< int >(val2);
25718   ecode3 = SWIG_AsVal_int(obj2, &val3);
25719   if (!SWIG_IsOK(ecode3)) {
25720     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makePipeTop" "', argument " "3"" of type '" "int""'");
25721   }
25722   arg3 = static_cast< int >(val3);
25723   ecode4 = SWIG_AsVal_int(obj3, &val4);
25724   if (!SWIG_IsOK(ecode4)) {
25725     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipeTop" "', argument " "4"" of type '" "int""'");
25726   }
25727   arg4 = static_cast< int >(val4);
25728   result = (Hex::Elements *)(arg1)->makePipeTop(arg2,arg3,arg4);
25729   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25730   return resultobj;
25731 fail:
25732   return NULL;
25733 }
25734
25735
25736 SWIGINTERN PyObject *_wrap_Document_makePipeUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25737   PyObject *resultobj = 0;
25738   Hex::Document *arg1 = (Hex::Document *) 0 ;
25739   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25740   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25741   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25742   double arg5 ;
25743   double arg6 ;
25744   double arg7 ;
25745   double arg8 ;
25746   int arg9 ;
25747   int arg10 ;
25748   int arg11 ;
25749   Hex::Elements *result = 0 ;
25750   void *argp1 = 0 ;
25751   int res1 = 0 ;
25752   void *argp2 = 0 ;
25753   int res2 = 0 ;
25754   void *argp3 = 0 ;
25755   int res3 = 0 ;
25756   void *argp4 = 0 ;
25757   int res4 = 0 ;
25758   double val5 ;
25759   int ecode5 = 0 ;
25760   double val6 ;
25761   int ecode6 = 0 ;
25762   double val7 ;
25763   int ecode7 = 0 ;
25764   double val8 ;
25765   int ecode8 = 0 ;
25766   int val9 ;
25767   int ecode9 = 0 ;
25768   int val10 ;
25769   int ecode10 = 0 ;
25770   int val11 ;
25771   int ecode11 = 0 ;
25772   PyObject * obj0 = 0 ;
25773   PyObject * obj1 = 0 ;
25774   PyObject * obj2 = 0 ;
25775   PyObject * obj3 = 0 ;
25776   PyObject * obj4 = 0 ;
25777   PyObject * obj5 = 0 ;
25778   PyObject * obj6 = 0 ;
25779   PyObject * obj7 = 0 ;
25780   PyObject * obj8 = 0 ;
25781   PyObject * obj9 = 0 ;
25782   PyObject * obj10 = 0 ;
25783
25784   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipeUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
25785   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25786   if (!SWIG_IsOK(res1)) {
25787     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeUni" "', argument " "1"" of type '" "Hex::Document *""'");
25788   }
25789   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25790   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25791   if (!SWIG_IsOK(res2)) {
25792     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipeUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
25793   }
25794   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25795   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25796   if (!SWIG_IsOK(res3)) {
25797     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipeUni" "', argument " "3"" of type '" "Hex::Vector *""'");
25798   }
25799   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25800   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25801   if (!SWIG_IsOK(res4)) {
25802     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipeUni" "', argument " "4"" of type '" "Hex::Vector *""'");
25803   }
25804   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25805   ecode5 = SWIG_AsVal_double(obj4, &val5);
25806   if (!SWIG_IsOK(ecode5)) {
25807     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipeUni" "', argument " "5"" of type '" "double""'");
25808   }
25809   arg5 = static_cast< double >(val5);
25810   ecode6 = SWIG_AsVal_double(obj5, &val6);
25811   if (!SWIG_IsOK(ecode6)) {
25812     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipeUni" "', argument " "6"" of type '" "double""'");
25813   }
25814   arg6 = static_cast< double >(val6);
25815   ecode7 = SWIG_AsVal_double(obj6, &val7);
25816   if (!SWIG_IsOK(ecode7)) {
25817     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makePipeUni" "', argument " "7"" of type '" "double""'");
25818   }
25819   arg7 = static_cast< double >(val7);
25820   ecode8 = SWIG_AsVal_double(obj7, &val8);
25821   if (!SWIG_IsOK(ecode8)) {
25822     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makePipeUni" "', argument " "8"" of type '" "double""'");
25823   }
25824   arg8 = static_cast< double >(val8);
25825   ecode9 = SWIG_AsVal_int(obj8, &val9);
25826   if (!SWIG_IsOK(ecode9)) {
25827     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipeUni" "', argument " "9"" of type '" "int""'");
25828   }
25829   arg9 = static_cast< int >(val9);
25830   ecode10 = SWIG_AsVal_int(obj9, &val10);
25831   if (!SWIG_IsOK(ecode10)) {
25832     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipeUni" "', argument " "10"" of type '" "int""'");
25833   }
25834   arg10 = static_cast< int >(val10);
25835   ecode11 = SWIG_AsVal_int(obj10, &val11);
25836   if (!SWIG_IsOK(ecode11)) {
25837     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipeUni" "', argument " "11"" of type '" "int""'");
25838   }
25839   arg11 = static_cast< int >(val11);
25840   result = (Hex::Elements *)(arg1)->makePipeUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25841   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25842   return resultobj;
25843 fail:
25844   return NULL;
25845 }
25846
25847
25848 SWIGINTERN PyObject *_wrap_Document_makePipe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25849   PyObject *resultobj = 0;
25850   Hex::Document *arg1 = (Hex::Document *) 0 ;
25851   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25852   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25853   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25854   Hex::RealVector arg5 ;
25855   Hex::RealVector arg6 ;
25856   Hex::RealVector arg7 ;
25857   Hex::Elements *result = 0 ;
25858   void *argp1 = 0 ;
25859   int res1 = 0 ;
25860   void *argp2 = 0 ;
25861   int res2 = 0 ;
25862   void *argp3 = 0 ;
25863   int res3 = 0 ;
25864   void *argp4 = 0 ;
25865   int res4 = 0 ;
25866   PyObject * obj0 = 0 ;
25867   PyObject * obj1 = 0 ;
25868   PyObject * obj2 = 0 ;
25869   PyObject * obj3 = 0 ;
25870   PyObject * obj4 = 0 ;
25871   PyObject * obj5 = 0 ;
25872   PyObject * obj6 = 0 ;
25873
25874   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makePipe",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25875   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25876   if (!SWIG_IsOK(res1)) {
25877     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipe" "', argument " "1"" of type '" "Hex::Document *""'");
25878   }
25879   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25880   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25881   if (!SWIG_IsOK(res2)) {
25882     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipe" "', argument " "2"" of type '" "Hex::Vertex *""'");
25883   }
25884   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25885   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25886   if (!SWIG_IsOK(res3)) {
25887     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipe" "', argument " "3"" of type '" "Hex::Vector *""'");
25888   }
25889   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25890   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25891   if (!SWIG_IsOK(res4)) {
25892     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipe" "', argument " "4"" of type '" "Hex::Vector *""'");
25893   }
25894   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25895   {
25896     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25897     int res = swig::asptr(obj4, &ptr);
25898     if (!SWIG_IsOK(res) || !ptr) {
25899       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "5"" of type '" "Hex::RealVector""'");
25900     }
25901     arg5 = *ptr;
25902     if (SWIG_IsNewObj(res)) delete ptr;
25903   }
25904   {
25905     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25906     int res = swig::asptr(obj5, &ptr);
25907     if (!SWIG_IsOK(res) || !ptr) {
25908       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "6"" of type '" "Hex::RealVector""'");
25909     }
25910     arg6 = *ptr;
25911     if (SWIG_IsNewObj(res)) delete ptr;
25912   }
25913   {
25914     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25915     int res = swig::asptr(obj6, &ptr);
25916     if (!SWIG_IsOK(res) || !ptr) {
25917       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "7"" of type '" "Hex::RealVector""'");
25918     }
25919     arg7 = *ptr;
25920     if (SWIG_IsNewObj(res)) delete ptr;
25921   }
25922   result = (Hex::Elements *)(arg1)->makePipe(arg2,arg3,arg4,arg5,arg6,arg7);
25923   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25924   return resultobj;
25925 fail:
25926   return NULL;
25927 }
25928
25929
25930 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25931   PyObject *resultobj = 0;
25932   Hex::Document *arg1 = (Hex::Document *) 0 ;
25933   int arg2 ;
25934   int arg3 ;
25935   Hex::Elements *result = 0 ;
25936   void *argp1 = 0 ;
25937   int res1 = 0 ;
25938   int val2 ;
25939   int ecode2 = 0 ;
25940   int val3 ;
25941   int ecode3 = 0 ;
25942   PyObject * obj0 = 0 ;
25943   PyObject * obj1 = 0 ;
25944   PyObject * obj2 = 0 ;
25945
25946   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSphericalTop",&obj0,&obj1,&obj2)) SWIG_fail;
25947   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25948   if (!SWIG_IsOK(res1)) {
25949     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
25950   }
25951   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25952   ecode2 = SWIG_AsVal_int(obj1, &val2);
25953   if (!SWIG_IsOK(ecode2)) {
25954     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
25955   }
25956   arg2 = static_cast< int >(val2);
25957   ecode3 = SWIG_AsVal_int(obj2, &val3);
25958   if (!SWIG_IsOK(ecode3)) {
25959     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphericalTop" "', argument " "3"" of type '" "int""'");
25960   }
25961   arg3 = static_cast< int >(val3);
25962   result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2,arg3);
25963   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25964   return resultobj;
25965 fail:
25966   return NULL;
25967 }
25968
25969
25970 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25971   PyObject *resultobj = 0;
25972   Hex::Document *arg1 = (Hex::Document *) 0 ;
25973   int arg2 ;
25974   Hex::Elements *result = 0 ;
25975   void *argp1 = 0 ;
25976   int res1 = 0 ;
25977   int val2 ;
25978   int ecode2 = 0 ;
25979   PyObject * obj0 = 0 ;
25980   PyObject * obj1 = 0 ;
25981
25982   if (!PyArg_ParseTuple(args,(char *)"OO:Document_makeSphericalTop",&obj0,&obj1)) SWIG_fail;
25983   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25984   if (!SWIG_IsOK(res1)) {
25985     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
25986   }
25987   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25988   ecode2 = SWIG_AsVal_int(obj1, &val2);
25989   if (!SWIG_IsOK(ecode2)) {
25990     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
25991   }
25992   arg2 = static_cast< int >(val2);
25993   result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2);
25994   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25995   return resultobj;
25996 fail:
25997   return NULL;
25998 }
25999
26000
26001 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop(PyObject *self, PyObject *args) {
26002   int argc;
26003   PyObject *argv[4];
26004   int ii;
26005
26006   if (!PyTuple_Check(args)) SWIG_fail;
26007   argc = PyObject_Length(args);
26008   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
26009     argv[ii] = PyTuple_GET_ITEM(args,ii);
26010   }
26011   if (argc == 2) {
26012     int _v;
26013     void *vptr = 0;
26014     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26015     _v = SWIG_CheckState(res);
26016     if (_v) {
26017       {
26018         int res = SWIG_AsVal_int(argv[1], NULL);
26019         _v = SWIG_CheckState(res);
26020       }
26021       if (_v) {
26022         return _wrap_Document_makeSphericalTop__SWIG_1(self, args);
26023       }
26024     }
26025   }
26026   if (argc == 3) {
26027     int _v;
26028     void *vptr = 0;
26029     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26030     _v = SWIG_CheckState(res);
26031     if (_v) {
26032       {
26033         int res = SWIG_AsVal_int(argv[1], NULL);
26034         _v = SWIG_CheckState(res);
26035       }
26036       if (_v) {
26037         {
26038           int res = SWIG_AsVal_int(argv[2], NULL);
26039           _v = SWIG_CheckState(res);
26040         }
26041         if (_v) {
26042           return _wrap_Document_makeSphericalTop__SWIG_0(self, args);
26043         }
26044       }
26045     }
26046   }
26047
26048 fail:
26049   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSphericalTop'.\n  Possible C/C++ prototypes are:\n    makeSphericalTop(int,int)\n    makeSphericalTop(int)\n");
26050   return NULL;
26051 }
26052
26053
26054 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26055   PyObject *resultobj = 0;
26056   Hex::Document *arg1 = (Hex::Document *) 0 ;
26057   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26058   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26059   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26060   double arg5 ;
26061   int arg6 ;
26062   int arg7 ;
26063   Hex::Elements *result = 0 ;
26064   void *argp1 = 0 ;
26065   int res1 = 0 ;
26066   void *argp2 = 0 ;
26067   int res2 = 0 ;
26068   void *argp3 = 0 ;
26069   int res3 = 0 ;
26070   void *argp4 = 0 ;
26071   int res4 = 0 ;
26072   double val5 ;
26073   int ecode5 = 0 ;
26074   int val6 ;
26075   int ecode6 = 0 ;
26076   int val7 ;
26077   int ecode7 = 0 ;
26078   PyObject * obj0 = 0 ;
26079   PyObject * obj1 = 0 ;
26080   PyObject * obj2 = 0 ;
26081   PyObject * obj3 = 0 ;
26082   PyObject * obj4 = 0 ;
26083   PyObject * obj5 = 0 ;
26084   PyObject * obj6 = 0 ;
26085
26086   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
26090   }
26091   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26092   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26093   if (!SWIG_IsOK(res2)) {
26094     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26095   }
26096   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26097   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26098   if (!SWIG_IsOK(res3)) {
26099     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26100   }
26101   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26102   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26103   if (!SWIG_IsOK(res4)) {
26104     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26105   }
26106   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26107   ecode5 = SWIG_AsVal_double(obj4, &val5);
26108   if (!SWIG_IsOK(ecode5)) {
26109     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
26110   }
26111   arg5 = static_cast< double >(val5);
26112   ecode6 = SWIG_AsVal_int(obj5, &val6);
26113   if (!SWIG_IsOK(ecode6)) {
26114     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
26115   }
26116   arg6 = static_cast< int >(val6);
26117   ecode7 = SWIG_AsVal_int(obj6, &val7);
26118   if (!SWIG_IsOK(ecode7)) {
26119     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphericalUni" "', argument " "7"" of type '" "int""'");
26120   }
26121   arg7 = static_cast< int >(val7);
26122   result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6,arg7);
26123   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26124   return resultobj;
26125 fail:
26126   return NULL;
26127 }
26128
26129
26130 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26131   PyObject *resultobj = 0;
26132   Hex::Document *arg1 = (Hex::Document *) 0 ;
26133   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26134   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26135   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26136   double arg5 ;
26137   int arg6 ;
26138   Hex::Elements *result = 0 ;
26139   void *argp1 = 0 ;
26140   int res1 = 0 ;
26141   void *argp2 = 0 ;
26142   int res2 = 0 ;
26143   void *argp3 = 0 ;
26144   int res3 = 0 ;
26145   void *argp4 = 0 ;
26146   int res4 = 0 ;
26147   double val5 ;
26148   int ecode5 = 0 ;
26149   int val6 ;
26150   int ecode6 = 0 ;
26151   PyObject * obj0 = 0 ;
26152   PyObject * obj1 = 0 ;
26153   PyObject * obj2 = 0 ;
26154   PyObject * obj3 = 0 ;
26155   PyObject * obj4 = 0 ;
26156   PyObject * obj5 = 0 ;
26157
26158   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
26159   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26160   if (!SWIG_IsOK(res1)) {
26161     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
26162   }
26163   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26164   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26165   if (!SWIG_IsOK(res2)) {
26166     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26167   }
26168   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26169   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26170   if (!SWIG_IsOK(res3)) {
26171     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26172   }
26173   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26174   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26175   if (!SWIG_IsOK(res4)) {
26176     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26177   }
26178   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26179   ecode5 = SWIG_AsVal_double(obj4, &val5);
26180   if (!SWIG_IsOK(ecode5)) {
26181     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
26182   }
26183   arg5 = static_cast< double >(val5);
26184   ecode6 = SWIG_AsVal_int(obj5, &val6);
26185   if (!SWIG_IsOK(ecode6)) {
26186     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
26187   }
26188   arg6 = static_cast< int >(val6);
26189   result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6);
26190   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26191   return resultobj;
26192 fail:
26193   return NULL;
26194 }
26195
26196
26197 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni(PyObject *self, PyObject *args) {
26198   int argc;
26199   PyObject *argv[8];
26200   int ii;
26201
26202   if (!PyTuple_Check(args)) SWIG_fail;
26203   argc = PyObject_Length(args);
26204   for (ii = 0; (ii < argc) && (ii < 7); ii++) {
26205     argv[ii] = PyTuple_GET_ITEM(args,ii);
26206   }
26207   if (argc == 6) {
26208     int _v;
26209     void *vptr = 0;
26210     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26211     _v = SWIG_CheckState(res);
26212     if (_v) {
26213       void *vptr = 0;
26214       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26215       _v = SWIG_CheckState(res);
26216       if (_v) {
26217         void *vptr = 0;
26218         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26219         _v = SWIG_CheckState(res);
26220         if (_v) {
26221           void *vptr = 0;
26222           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26223           _v = SWIG_CheckState(res);
26224           if (_v) {
26225             {
26226               int res = SWIG_AsVal_double(argv[4], NULL);
26227               _v = SWIG_CheckState(res);
26228             }
26229             if (_v) {
26230               {
26231                 int res = SWIG_AsVal_int(argv[5], NULL);
26232                 _v = SWIG_CheckState(res);
26233               }
26234               if (_v) {
26235                 return _wrap_Document_makeSphericalUni__SWIG_1(self, args);
26236               }
26237             }
26238           }
26239         }
26240       }
26241     }
26242   }
26243   if (argc == 7) {
26244     int _v;
26245     void *vptr = 0;
26246     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26247     _v = SWIG_CheckState(res);
26248     if (_v) {
26249       void *vptr = 0;
26250       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26251       _v = SWIG_CheckState(res);
26252       if (_v) {
26253         void *vptr = 0;
26254         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26255         _v = SWIG_CheckState(res);
26256         if (_v) {
26257           void *vptr = 0;
26258           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26259           _v = SWIG_CheckState(res);
26260           if (_v) {
26261             {
26262               int res = SWIG_AsVal_double(argv[4], NULL);
26263               _v = SWIG_CheckState(res);
26264             }
26265             if (_v) {
26266               {
26267                 int res = SWIG_AsVal_int(argv[5], NULL);
26268                 _v = SWIG_CheckState(res);
26269               }
26270               if (_v) {
26271                 {
26272                   int res = SWIG_AsVal_int(argv[6], NULL);
26273                   _v = SWIG_CheckState(res);
26274                 }
26275                 if (_v) {
26276                   return _wrap_Document_makeSphericalUni__SWIG_0(self, args);
26277                 }
26278               }
26279             }
26280           }
26281         }
26282       }
26283     }
26284   }
26285
26286 fail:
26287   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSphericalUni'.\n  Possible C/C++ prototypes are:\n    makeSphericalUni(Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int,int)\n    makeSphericalUni(Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int)\n");
26288   return NULL;
26289 }
26290
26291
26292 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26293   PyObject *resultobj = 0;
26294   Hex::Document *arg1 = (Hex::Document *) 0 ;
26295   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26296   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26297   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26298   Hex::RealVector arg5 ;
26299   int arg6 ;
26300   Hex::Elements *result = 0 ;
26301   void *argp1 = 0 ;
26302   int res1 = 0 ;
26303   void *argp2 = 0 ;
26304   int res2 = 0 ;
26305   void *argp3 = 0 ;
26306   int res3 = 0 ;
26307   void *argp4 = 0 ;
26308   int res4 = 0 ;
26309   int val6 ;
26310   int ecode6 = 0 ;
26311   PyObject * obj0 = 0 ;
26312   PyObject * obj1 = 0 ;
26313   PyObject * obj2 = 0 ;
26314   PyObject * obj3 = 0 ;
26315   PyObject * obj4 = 0 ;
26316   PyObject * obj5 = 0 ;
26317
26318   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
26319   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26320   if (!SWIG_IsOK(res1)) {
26321     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
26322   }
26323   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26324   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26325   if (!SWIG_IsOK(res2)) {
26326     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
26327   }
26328   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26329   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26330   if (!SWIG_IsOK(res3)) {
26331     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
26332   }
26333   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26334   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26335   if (!SWIG_IsOK(res4)) {
26336     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
26337   }
26338   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26339   {
26340     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26341     int res = swig::asptr(obj4, &ptr);
26342     if (!SWIG_IsOK(res) || !ptr) {
26343       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
26344     }
26345     arg5 = *ptr;
26346     if (SWIG_IsNewObj(res)) delete ptr;
26347   }
26348   ecode6 = SWIG_AsVal_int(obj5, &val6);
26349   if (!SWIG_IsOK(ecode6)) {
26350     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSpherical" "', argument " "6"" of type '" "int""'");
26351   }
26352   arg6 = static_cast< int >(val6);
26353   result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5,arg6);
26354   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26355   return resultobj;
26356 fail:
26357   return NULL;
26358 }
26359
26360
26361 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26362   PyObject *resultobj = 0;
26363   Hex::Document *arg1 = (Hex::Document *) 0 ;
26364   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26365   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26366   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26367   Hex::RealVector arg5 ;
26368   Hex::Elements *result = 0 ;
26369   void *argp1 = 0 ;
26370   int res1 = 0 ;
26371   void *argp2 = 0 ;
26372   int res2 = 0 ;
26373   void *argp3 = 0 ;
26374   int res3 = 0 ;
26375   void *argp4 = 0 ;
26376   int res4 = 0 ;
26377   PyObject * obj0 = 0 ;
26378   PyObject * obj1 = 0 ;
26379   PyObject * obj2 = 0 ;
26380   PyObject * obj3 = 0 ;
26381   PyObject * obj4 = 0 ;
26382
26383   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26384   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26385   if (!SWIG_IsOK(res1)) {
26386     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
26387   }
26388   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26389   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26390   if (!SWIG_IsOK(res2)) {
26391     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
26392   }
26393   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26394   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26395   if (!SWIG_IsOK(res3)) {
26396     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
26397   }
26398   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26399   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26400   if (!SWIG_IsOK(res4)) {
26401     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
26402   }
26403   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26404   {
26405     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26406     int res = swig::asptr(obj4, &ptr);
26407     if (!SWIG_IsOK(res) || !ptr) {
26408       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
26409     }
26410     arg5 = *ptr;
26411     if (SWIG_IsNewObj(res)) delete ptr;
26412   }
26413   result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5);
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_makeSpherical(PyObject *self, PyObject *args) {
26422   int argc;
26423   PyObject *argv[7];
26424   int ii;
26425
26426   if (!PyTuple_Check(args)) SWIG_fail;
26427   argc = PyObject_Length(args);
26428   for (ii = 0; (ii < argc) && (ii < 6); ii++) {
26429     argv[ii] = PyTuple_GET_ITEM(args,ii);
26430   }
26431   if (argc == 5) {
26432     int _v;
26433     void *vptr = 0;
26434     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26435     _v = SWIG_CheckState(res);
26436     if (_v) {
26437       void *vptr = 0;
26438       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26439       _v = SWIG_CheckState(res);
26440       if (_v) {
26441         void *vptr = 0;
26442         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26443         _v = SWIG_CheckState(res);
26444         if (_v) {
26445           void *vptr = 0;
26446           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26447           _v = SWIG_CheckState(res);
26448           if (_v) {
26449             int res = swig::asptr(argv[4], (std::vector<double,std::allocator<double > >**)(0));
26450             _v = SWIG_CheckState(res);
26451             if (_v) {
26452               return _wrap_Document_makeSpherical__SWIG_1(self, args);
26453             }
26454           }
26455         }
26456       }
26457     }
26458   }
26459   if (argc == 6) {
26460     int _v;
26461     void *vptr = 0;
26462     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26463     _v = SWIG_CheckState(res);
26464     if (_v) {
26465       void *vptr = 0;
26466       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26467       _v = SWIG_CheckState(res);
26468       if (_v) {
26469         void *vptr = 0;
26470         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26471         _v = SWIG_CheckState(res);
26472         if (_v) {
26473           void *vptr = 0;
26474           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26475           _v = SWIG_CheckState(res);
26476           if (_v) {
26477             int res = swig::asptr(argv[4], (std::vector<double,std::allocator<double > >**)(0));
26478             _v = SWIG_CheckState(res);
26479             if (_v) {
26480               {
26481                 int res = SWIG_AsVal_int(argv[5], NULL);
26482                 _v = SWIG_CheckState(res);
26483               }
26484               if (_v) {
26485                 return _wrap_Document_makeSpherical__SWIG_0(self, args);
26486               }
26487             }
26488           }
26489         }
26490       }
26491     }
26492   }
26493
26494 fail:
26495   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_makeSpherical'.\n  Possible C/C++ prototypes are:\n    makeSpherical(Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector,int)\n    makeSpherical(Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector)\n");
26496   return NULL;
26497 }
26498
26499
26500 SWIGINTERN PyObject *_wrap_Document_makeSphereTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26501   PyObject *resultobj = 0;
26502   Hex::Document *arg1 = (Hex::Document *) 0 ;
26503   int arg2 ;
26504   int arg3 ;
26505   int arg4 ;
26506   Hex::Elements *result = 0 ;
26507   void *argp1 = 0 ;
26508   int res1 = 0 ;
26509   int val2 ;
26510   int ecode2 = 0 ;
26511   int val3 ;
26512   int ecode3 = 0 ;
26513   int val4 ;
26514   int ecode4 = 0 ;
26515   PyObject * obj0 = 0 ;
26516   PyObject * obj1 = 0 ;
26517   PyObject * obj2 = 0 ;
26518   PyObject * obj3 = 0 ;
26519
26520   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSphereTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26521   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26522   if (!SWIG_IsOK(res1)) {
26523     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereTop" "', argument " "1"" of type '" "Hex::Document *""'");
26524   }
26525   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26526   ecode2 = SWIG_AsVal_int(obj1, &val2);
26527   if (!SWIG_IsOK(ecode2)) {
26528     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphereTop" "', argument " "2"" of type '" "int""'");
26529   }
26530   arg2 = static_cast< int >(val2);
26531   ecode3 = SWIG_AsVal_int(obj2, &val3);
26532   if (!SWIG_IsOK(ecode3)) {
26533     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphereTop" "', argument " "3"" of type '" "int""'");
26534   }
26535   arg3 = static_cast< int >(val3);
26536   ecode4 = SWIG_AsVal_int(obj3, &val4);
26537   if (!SWIG_IsOK(ecode4)) {
26538     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeSphereTop" "', argument " "4"" of type '" "int""'");
26539   }
26540   arg4 = static_cast< int >(val4);
26541   result = (Hex::Elements *)(arg1)->makeSphereTop(arg2,arg3,arg4);
26542   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26543   return resultobj;
26544 fail:
26545   return NULL;
26546 }
26547
26548
26549 SWIGINTERN PyObject *_wrap_Document_makeSphereUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26550   PyObject *resultobj = 0;
26551   Hex::Document *arg1 = (Hex::Document *) 0 ;
26552   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26553   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26554   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26555   double arg5 ;
26556   double arg6 ;
26557   double arg7 ;
26558   Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
26559   int arg9 ;
26560   int arg10 ;
26561   int arg11 ;
26562   Hex::Elements *result = 0 ;
26563   void *argp1 = 0 ;
26564   int res1 = 0 ;
26565   void *argp2 = 0 ;
26566   int res2 = 0 ;
26567   void *argp3 = 0 ;
26568   int res3 = 0 ;
26569   void *argp4 = 0 ;
26570   int res4 = 0 ;
26571   double val5 ;
26572   int ecode5 = 0 ;
26573   double val6 ;
26574   int ecode6 = 0 ;
26575   double val7 ;
26576   int ecode7 = 0 ;
26577   void *argp8 = 0 ;
26578   int res8 = 0 ;
26579   int val9 ;
26580   int ecode9 = 0 ;
26581   int val10 ;
26582   int ecode10 = 0 ;
26583   int val11 ;
26584   int ecode11 = 0 ;
26585   PyObject * obj0 = 0 ;
26586   PyObject * obj1 = 0 ;
26587   PyObject * obj2 = 0 ;
26588   PyObject * obj3 = 0 ;
26589   PyObject * obj4 = 0 ;
26590   PyObject * obj5 = 0 ;
26591   PyObject * obj6 = 0 ;
26592   PyObject * obj7 = 0 ;
26593   PyObject * obj8 = 0 ;
26594   PyObject * obj9 = 0 ;
26595   PyObject * obj10 = 0 ;
26596
26597   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeSphereUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
26598   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26599   if (!SWIG_IsOK(res1)) {
26600     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereUni" "', argument " "1"" of type '" "Hex::Document *""'");
26601   }
26602   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26603   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26604   if (!SWIG_IsOK(res2)) {
26605     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphereUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26606   }
26607   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26608   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26609   if (!SWIG_IsOK(res3)) {
26610     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphereUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26611   }
26612   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26613   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26614   if (!SWIG_IsOK(res4)) {
26615     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphereUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26616   }
26617   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26618   ecode5 = SWIG_AsVal_double(obj4, &val5);
26619   if (!SWIG_IsOK(ecode5)) {
26620     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphereUni" "', argument " "5"" of type '" "double""'");
26621   }
26622   arg5 = static_cast< double >(val5);
26623   ecode6 = SWIG_AsVal_double(obj5, &val6);
26624   if (!SWIG_IsOK(ecode6)) {
26625     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphereUni" "', argument " "6"" of type '" "double""'");
26626   }
26627   arg6 = static_cast< double >(val6);
26628   ecode7 = SWIG_AsVal_double(obj6, &val7);
26629   if (!SWIG_IsOK(ecode7)) {
26630     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphereUni" "', argument " "7"" of type '" "double""'");
26631   }
26632   arg7 = static_cast< double >(val7);
26633   res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26634   if (!SWIG_IsOK(res8)) {
26635     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makeSphereUni" "', argument " "8"" of type '" "Hex::Vertex *""'");
26636   }
26637   arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
26638   ecode9 = SWIG_AsVal_int(obj8, &val9);
26639   if (!SWIG_IsOK(ecode9)) {
26640     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeSphereUni" "', argument " "9"" of type '" "int""'");
26641   }
26642   arg9 = static_cast< int >(val9);
26643   ecode10 = SWIG_AsVal_int(obj9, &val10);
26644   if (!SWIG_IsOK(ecode10)) {
26645     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeSphereUni" "', argument " "10"" of type '" "int""'");
26646   }
26647   arg10 = static_cast< int >(val10);
26648   ecode11 = SWIG_AsVal_int(obj10, &val11);
26649   if (!SWIG_IsOK(ecode11)) {
26650     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeSphereUni" "', argument " "11"" of type '" "int""'");
26651   }
26652   arg11 = static_cast< int >(val11);
26653   result = (Hex::Elements *)(arg1)->makeSphereUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26654   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26655   return resultobj;
26656 fail:
26657   return NULL;
26658 }
26659
26660
26661 SWIGINTERN PyObject *_wrap_Document_makeSphere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26662   PyObject *resultobj = 0;
26663   Hex::Document *arg1 = (Hex::Document *) 0 ;
26664   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26665   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26666   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26667   Hex::RealVector arg5 ;
26668   Hex::RealVector arg6 ;
26669   Hex::RealVector arg7 ;
26670   Hex::Elements *result = 0 ;
26671   void *argp1 = 0 ;
26672   int res1 = 0 ;
26673   void *argp2 = 0 ;
26674   int res2 = 0 ;
26675   void *argp3 = 0 ;
26676   int res3 = 0 ;
26677   void *argp4 = 0 ;
26678   int res4 = 0 ;
26679   PyObject * obj0 = 0 ;
26680   PyObject * obj1 = 0 ;
26681   PyObject * obj2 = 0 ;
26682   PyObject * obj3 = 0 ;
26683   PyObject * obj4 = 0 ;
26684   PyObject * obj5 = 0 ;
26685   PyObject * obj6 = 0 ;
26686
26687   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphere",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26688   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26689   if (!SWIG_IsOK(res1)) {
26690     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphere" "', argument " "1"" of type '" "Hex::Document *""'");
26691   }
26692   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26693   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26694   if (!SWIG_IsOK(res2)) {
26695     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphere" "', argument " "2"" of type '" "Hex::Vertex *""'");
26696   }
26697   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26698   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26699   if (!SWIG_IsOK(res3)) {
26700     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphere" "', argument " "3"" of type '" "Hex::Vector *""'");
26701   }
26702   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26703   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26704   if (!SWIG_IsOK(res4)) {
26705     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphere" "', argument " "4"" of type '" "Hex::Vector *""'");
26706   }
26707   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26708   {
26709     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26710     int res = swig::asptr(obj4, &ptr);
26711     if (!SWIG_IsOK(res) || !ptr) {
26712       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "5"" of type '" "Hex::RealVector""'");
26713     }
26714     arg5 = *ptr;
26715     if (SWIG_IsNewObj(res)) delete ptr;
26716   }
26717   {
26718     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26719     int res = swig::asptr(obj5, &ptr);
26720     if (!SWIG_IsOK(res) || !ptr) {
26721       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "6"" of type '" "Hex::RealVector""'");
26722     }
26723     arg6 = *ptr;
26724     if (SWIG_IsNewObj(res)) delete ptr;
26725   }
26726   {
26727     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26728     int res = swig::asptr(obj6, &ptr);
26729     if (!SWIG_IsOK(res) || !ptr) {
26730       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "7"" of type '" "Hex::RealVector""'");
26731     }
26732     arg7 = *ptr;
26733     if (SWIG_IsNewObj(res)) delete ptr;
26734   }
26735   result = (Hex::Elements *)(arg1)->makeSphere(arg2,arg3,arg4,arg5,arg6,arg7);
26736   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26737   return resultobj;
26738 fail:
26739   return NULL;
26740 }
26741
26742
26743 SWIGINTERN PyObject *_wrap_Document_makeRindTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26744   PyObject *resultobj = 0;
26745   Hex::Document *arg1 = (Hex::Document *) 0 ;
26746   int arg2 ;
26747   int arg3 ;
26748   int arg4 ;
26749   Hex::Elements *result = 0 ;
26750   void *argp1 = 0 ;
26751   int res1 = 0 ;
26752   int val2 ;
26753   int ecode2 = 0 ;
26754   int val3 ;
26755   int ecode3 = 0 ;
26756   int val4 ;
26757   int ecode4 = 0 ;
26758   PyObject * obj0 = 0 ;
26759   PyObject * obj1 = 0 ;
26760   PyObject * obj2 = 0 ;
26761   PyObject * obj3 = 0 ;
26762
26763   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeRindTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26764   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26765   if (!SWIG_IsOK(res1)) {
26766     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindTop" "', argument " "1"" of type '" "Hex::Document *""'");
26767   }
26768   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26769   ecode2 = SWIG_AsVal_int(obj1, &val2);
26770   if (!SWIG_IsOK(ecode2)) {
26771     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeRindTop" "', argument " "2"" of type '" "int""'");
26772   }
26773   arg2 = static_cast< int >(val2);
26774   ecode3 = SWIG_AsVal_int(obj2, &val3);
26775   if (!SWIG_IsOK(ecode3)) {
26776     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeRindTop" "', argument " "3"" of type '" "int""'");
26777   }
26778   arg3 = static_cast< int >(val3);
26779   ecode4 = SWIG_AsVal_int(obj3, &val4);
26780   if (!SWIG_IsOK(ecode4)) {
26781     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeRindTop" "', argument " "4"" of type '" "int""'");
26782   }
26783   arg4 = static_cast< int >(val4);
26784   result = (Hex::Elements *)(arg1)->makeRindTop(arg2,arg3,arg4);
26785   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26786   return resultobj;
26787 fail:
26788   return NULL;
26789 }
26790
26791
26792 SWIGINTERN PyObject *_wrap_Document_makeRindUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26793   PyObject *resultobj = 0;
26794   Hex::Document *arg1 = (Hex::Document *) 0 ;
26795   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26796   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26797   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26798   double arg5 ;
26799   double arg6 ;
26800   double arg7 ;
26801   double arg8 ;
26802   Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
26803   int arg10 ;
26804   int arg11 ;
26805   int arg12 ;
26806   Hex::Elements *result = 0 ;
26807   void *argp1 = 0 ;
26808   int res1 = 0 ;
26809   void *argp2 = 0 ;
26810   int res2 = 0 ;
26811   void *argp3 = 0 ;
26812   int res3 = 0 ;
26813   void *argp4 = 0 ;
26814   int res4 = 0 ;
26815   double val5 ;
26816   int ecode5 = 0 ;
26817   double val6 ;
26818   int ecode6 = 0 ;
26819   double val7 ;
26820   int ecode7 = 0 ;
26821   double val8 ;
26822   int ecode8 = 0 ;
26823   void *argp9 = 0 ;
26824   int res9 = 0 ;
26825   int val10 ;
26826   int ecode10 = 0 ;
26827   int val11 ;
26828   int ecode11 = 0 ;
26829   int val12 ;
26830   int ecode12 = 0 ;
26831   PyObject * obj0 = 0 ;
26832   PyObject * obj1 = 0 ;
26833   PyObject * obj2 = 0 ;
26834   PyObject * obj3 = 0 ;
26835   PyObject * obj4 = 0 ;
26836   PyObject * obj5 = 0 ;
26837   PyObject * obj6 = 0 ;
26838   PyObject * obj7 = 0 ;
26839   PyObject * obj8 = 0 ;
26840   PyObject * obj9 = 0 ;
26841   PyObject * obj10 = 0 ;
26842   PyObject * obj11 = 0 ;
26843
26844   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Document_makeRindUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
26845   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26846   if (!SWIG_IsOK(res1)) {
26847     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindUni" "', argument " "1"" of type '" "Hex::Document *""'");
26848   }
26849   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26850   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26851   if (!SWIG_IsOK(res2)) {
26852     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRindUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26853   }
26854   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26855   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26856   if (!SWIG_IsOK(res3)) {
26857     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRindUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26858   }
26859   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26860   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26861   if (!SWIG_IsOK(res4)) {
26862     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRindUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26863   }
26864   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26865   ecode5 = SWIG_AsVal_double(obj4, &val5);
26866   if (!SWIG_IsOK(ecode5)) {
26867     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeRindUni" "', argument " "5"" of type '" "double""'");
26868   }
26869   arg5 = static_cast< double >(val5);
26870   ecode6 = SWIG_AsVal_double(obj5, &val6);
26871   if (!SWIG_IsOK(ecode6)) {
26872     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeRindUni" "', argument " "6"" of type '" "double""'");
26873   }
26874   arg6 = static_cast< double >(val6);
26875   ecode7 = SWIG_AsVal_double(obj6, &val7);
26876   if (!SWIG_IsOK(ecode7)) {
26877     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeRindUni" "', argument " "7"" of type '" "double""'");
26878   }
26879   arg7 = static_cast< double >(val7);
26880   ecode8 = SWIG_AsVal_double(obj7, &val8);
26881   if (!SWIG_IsOK(ecode8)) {
26882     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeRindUni" "', argument " "8"" of type '" "double""'");
26883   }
26884   arg8 = static_cast< double >(val8);
26885   res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26886   if (!SWIG_IsOK(res9)) {
26887     SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Document_makeRindUni" "', argument " "9"" of type '" "Hex::Vertex *""'");
26888   }
26889   arg9 = reinterpret_cast< Hex::Vertex * >(argp9);
26890   ecode10 = SWIG_AsVal_int(obj9, &val10);
26891   if (!SWIG_IsOK(ecode10)) {
26892     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeRindUni" "', argument " "10"" of type '" "int""'");
26893   }
26894   arg10 = static_cast< int >(val10);
26895   ecode11 = SWIG_AsVal_int(obj10, &val11);
26896   if (!SWIG_IsOK(ecode11)) {
26897     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeRindUni" "', argument " "11"" of type '" "int""'");
26898   }
26899   arg11 = static_cast< int >(val11);
26900   ecode12 = SWIG_AsVal_int(obj11, &val12);
26901   if (!SWIG_IsOK(ecode12)) {
26902     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Document_makeRindUni" "', argument " "12"" of type '" "int""'");
26903   }
26904   arg12 = static_cast< int >(val12);
26905   result = (Hex::Elements *)(arg1)->makeRindUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
26906   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26907   return resultobj;
26908 fail:
26909   return NULL;
26910 }
26911
26912
26913 SWIGINTERN PyObject *_wrap_Document_makeRind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26914   PyObject *resultobj = 0;
26915   Hex::Document *arg1 = (Hex::Document *) 0 ;
26916   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26917   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26918   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26919   Hex::RealVector arg5 ;
26920   Hex::RealVector arg6 ;
26921   Hex::RealVector arg7 ;
26922   Hex::Elements *result = 0 ;
26923   void *argp1 = 0 ;
26924   int res1 = 0 ;
26925   void *argp2 = 0 ;
26926   int res2 = 0 ;
26927   void *argp3 = 0 ;
26928   int res3 = 0 ;
26929   void *argp4 = 0 ;
26930   int res4 = 0 ;
26931   PyObject * obj0 = 0 ;
26932   PyObject * obj1 = 0 ;
26933   PyObject * obj2 = 0 ;
26934   PyObject * obj3 = 0 ;
26935   PyObject * obj4 = 0 ;
26936   PyObject * obj5 = 0 ;
26937   PyObject * obj6 = 0 ;
26938
26939   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeRind",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26940   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26941   if (!SWIG_IsOK(res1)) {
26942     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRind" "', argument " "1"" of type '" "Hex::Document *""'");
26943   }
26944   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26945   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26946   if (!SWIG_IsOK(res2)) {
26947     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRind" "', argument " "2"" of type '" "Hex::Vertex *""'");
26948   }
26949   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26950   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26951   if (!SWIG_IsOK(res3)) {
26952     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRind" "', argument " "3"" of type '" "Hex::Vector *""'");
26953   }
26954   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26955   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26956   if (!SWIG_IsOK(res4)) {
26957     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRind" "', argument " "4"" of type '" "Hex::Vector *""'");
26958   }
26959   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26960   {
26961     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26962     int res = swig::asptr(obj4, &ptr);
26963     if (!SWIG_IsOK(res) || !ptr) {
26964       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "5"" of type '" "Hex::RealVector""'");
26965     }
26966     arg5 = *ptr;
26967     if (SWIG_IsNewObj(res)) delete ptr;
26968   }
26969   {
26970     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26971     int res = swig::asptr(obj5, &ptr);
26972     if (!SWIG_IsOK(res) || !ptr) {
26973       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "6"" of type '" "Hex::RealVector""'");
26974     }
26975     arg6 = *ptr;
26976     if (SWIG_IsNewObj(res)) delete ptr;
26977   }
26978   {
26979     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26980     int res = swig::asptr(obj6, &ptr);
26981     if (!SWIG_IsOK(res) || !ptr) {
26982       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "7"" of type '" "Hex::RealVector""'");
26983     }
26984     arg7 = *ptr;
26985     if (SWIG_IsNewObj(res)) delete ptr;
26986   }
26987   result = (Hex::Elements *)(arg1)->makeRind(arg2,arg3,arg4,arg5,arg6,arg7);
26988   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26989   return resultobj;
26990 fail:
26991   return NULL;
26992 }
26993
26994
26995 SWIGINTERN PyObject *_wrap_Document_makeCylinders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26996   PyObject *resultobj = 0;
26997   Hex::Document *arg1 = (Hex::Document *) 0 ;
26998   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26999   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27000   double arg4 ;
27001   double arg5 ;
27002   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27003   Hex::Vector *arg7 = (Hex::Vector *) 0 ;
27004   double arg8 ;
27005   double arg9 ;
27006   Hex::BiCylinder *result = 0 ;
27007   void *argp1 = 0 ;
27008   int res1 = 0 ;
27009   void *argp2 = 0 ;
27010   int res2 = 0 ;
27011   void *argp3 = 0 ;
27012   int res3 = 0 ;
27013   double val4 ;
27014   int ecode4 = 0 ;
27015   double val5 ;
27016   int ecode5 = 0 ;
27017   void *argp6 = 0 ;
27018   int res6 = 0 ;
27019   void *argp7 = 0 ;
27020   int res7 = 0 ;
27021   double val8 ;
27022   int ecode8 = 0 ;
27023   double val9 ;
27024   int ecode9 = 0 ;
27025   PyObject * obj0 = 0 ;
27026   PyObject * obj1 = 0 ;
27027   PyObject * obj2 = 0 ;
27028   PyObject * obj3 = 0 ;
27029   PyObject * obj4 = 0 ;
27030   PyObject * obj5 = 0 ;
27031   PyObject * obj6 = 0 ;
27032   PyObject * obj7 = 0 ;
27033   PyObject * obj8 = 0 ;
27034
27035   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_makeCylinders",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
27036   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27037   if (!SWIG_IsOK(res1)) {
27038     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinders" "', argument " "1"" of type '" "Hex::Document *""'");
27039   }
27040   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27041   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27042   if (!SWIG_IsOK(res2)) {
27043     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinders" "', argument " "2"" of type '" "Hex::Vertex *""'");
27044   }
27045   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27046   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27047   if (!SWIG_IsOK(res3)) {
27048     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinders" "', argument " "3"" of type '" "Hex::Vector *""'");
27049   }
27050   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27051   ecode4 = SWIG_AsVal_double(obj3, &val4);
27052   if (!SWIG_IsOK(ecode4)) {
27053     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinders" "', argument " "4"" of type '" "double""'");
27054   }
27055   arg4 = static_cast< double >(val4);
27056   ecode5 = SWIG_AsVal_double(obj4, &val5);
27057   if (!SWIG_IsOK(ecode5)) {
27058     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinders" "', argument " "5"" of type '" "double""'");
27059   }
27060   arg5 = static_cast< double >(val5);
27061   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27062   if (!SWIG_IsOK(res6)) {
27063     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_makeCylinders" "', argument " "6"" of type '" "Hex::Vertex *""'");
27064   }
27065   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27066   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27067   if (!SWIG_IsOK(res7)) {
27068     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makeCylinders" "', argument " "7"" of type '" "Hex::Vector *""'");
27069   }
27070   arg7 = reinterpret_cast< Hex::Vector * >(argp7);
27071   ecode8 = SWIG_AsVal_double(obj7, &val8);
27072   if (!SWIG_IsOK(ecode8)) {
27073     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinders" "', argument " "8"" of type '" "double""'");
27074   }
27075   arg8 = static_cast< double >(val8);
27076   ecode9 = SWIG_AsVal_double(obj8, &val9);
27077   if (!SWIG_IsOK(ecode9)) {
27078     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinders" "', argument " "9"" of type '" "double""'");
27079   }
27080   arg9 = static_cast< double >(val9);
27081   result = (Hex::BiCylinder *)(arg1)->makeCylinders(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
27082   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
27083   return resultobj;
27084 fail:
27085   return NULL;
27086 }
27087
27088
27089 SWIGINTERN PyObject *_wrap_Document_makePipes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27090   PyObject *resultobj = 0;
27091   Hex::Document *arg1 = (Hex::Document *) 0 ;
27092   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27093   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27094   double arg4 ;
27095   double arg5 ;
27096   double arg6 ;
27097   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27098   Hex::Vector *arg8 = (Hex::Vector *) 0 ;
27099   double arg9 ;
27100   double arg10 ;
27101   double arg11 ;
27102   Hex::BiCylinder *result = 0 ;
27103   void *argp1 = 0 ;
27104   int res1 = 0 ;
27105   void *argp2 = 0 ;
27106   int res2 = 0 ;
27107   void *argp3 = 0 ;
27108   int res3 = 0 ;
27109   double val4 ;
27110   int ecode4 = 0 ;
27111   double val5 ;
27112   int ecode5 = 0 ;
27113   double val6 ;
27114   int ecode6 = 0 ;
27115   void *argp7 = 0 ;
27116   int res7 = 0 ;
27117   void *argp8 = 0 ;
27118   int res8 = 0 ;
27119   double val9 ;
27120   int ecode9 = 0 ;
27121   double val10 ;
27122   int ecode10 = 0 ;
27123   double val11 ;
27124   int ecode11 = 0 ;
27125   PyObject * obj0 = 0 ;
27126   PyObject * obj1 = 0 ;
27127   PyObject * obj2 = 0 ;
27128   PyObject * obj3 = 0 ;
27129   PyObject * obj4 = 0 ;
27130   PyObject * obj5 = 0 ;
27131   PyObject * obj6 = 0 ;
27132   PyObject * obj7 = 0 ;
27133   PyObject * obj8 = 0 ;
27134   PyObject * obj9 = 0 ;
27135   PyObject * obj10 = 0 ;
27136
27137   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
27138   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27139   if (!SWIG_IsOK(res1)) {
27140     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipes" "', argument " "1"" of type '" "Hex::Document *""'");
27141   }
27142   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27143   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27144   if (!SWIG_IsOK(res2)) {
27145     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipes" "', argument " "2"" of type '" "Hex::Vertex *""'");
27146   }
27147   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27148   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27149   if (!SWIG_IsOK(res3)) {
27150     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipes" "', argument " "3"" of type '" "Hex::Vector *""'");
27151   }
27152   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27153   ecode4 = SWIG_AsVal_double(obj3, &val4);
27154   if (!SWIG_IsOK(ecode4)) {
27155     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipes" "', argument " "4"" of type '" "double""'");
27156   }
27157   arg4 = static_cast< double >(val4);
27158   ecode5 = SWIG_AsVal_double(obj4, &val5);
27159   if (!SWIG_IsOK(ecode5)) {
27160     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipes" "', argument " "5"" of type '" "double""'");
27161   }
27162   arg5 = static_cast< double >(val5);
27163   ecode6 = SWIG_AsVal_double(obj5, &val6);
27164   if (!SWIG_IsOK(ecode6)) {
27165     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipes" "', argument " "6"" of type '" "double""'");
27166   }
27167   arg6 = static_cast< double >(val6);
27168   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27169   if (!SWIG_IsOK(res7)) {
27170     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makePipes" "', argument " "7"" of type '" "Hex::Vertex *""'");
27171   }
27172   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27173   res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27174   if (!SWIG_IsOK(res8)) {
27175     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makePipes" "', argument " "8"" of type '" "Hex::Vector *""'");
27176   }
27177   arg8 = reinterpret_cast< Hex::Vector * >(argp8);
27178   ecode9 = SWIG_AsVal_double(obj8, &val9);
27179   if (!SWIG_IsOK(ecode9)) {
27180     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipes" "', argument " "9"" of type '" "double""'");
27181   }
27182   arg9 = static_cast< double >(val9);
27183   ecode10 = SWIG_AsVal_double(obj9, &val10);
27184   if (!SWIG_IsOK(ecode10)) {
27185     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipes" "', argument " "10"" of type '" "double""'");
27186   }
27187   arg10 = static_cast< double >(val10);
27188   ecode11 = SWIG_AsVal_double(obj10, &val11);
27189   if (!SWIG_IsOK(ecode11)) {
27190     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipes" "', argument " "11"" of type '" "double""'");
27191   }
27192   arg11 = static_cast< double >(val11);
27193   result = (Hex::BiCylinder *)(arg1)->makePipes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
27194   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
27195   return resultobj;
27196 fail:
27197   return NULL;
27198 }
27199
27200
27201 SWIGINTERN PyObject *_wrap_Document_extrudeQuadTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27202   PyObject *resultobj = 0;
27203   Hex::Document *arg1 = (Hex::Document *) 0 ;
27204   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27205   int arg3 ;
27206   Hex::Elements *result = 0 ;
27207   void *argp1 = 0 ;
27208   int res1 = 0 ;
27209   void *argp2 = 0 ;
27210   int res2 = 0 ;
27211   int val3 ;
27212   int ecode3 = 0 ;
27213   PyObject * obj0 = 0 ;
27214   PyObject * obj1 = 0 ;
27215   PyObject * obj2 = 0 ;
27216
27217   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadTop",&obj0,&obj1,&obj2)) SWIG_fail;
27218   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27219   if (!SWIG_IsOK(res1)) {
27220     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadTop" "', argument " "1"" of type '" "Hex::Document *""'");
27221   }
27222   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27223   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27224   if (!SWIG_IsOK(res2)) {
27225     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadTop" "', argument " "2"" of type '" "Hex::Quad *""'");
27226   }
27227   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27228   ecode3 = SWIG_AsVal_int(obj2, &val3);
27229   if (!SWIG_IsOK(ecode3)) {
27230     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadTop" "', argument " "3"" of type '" "int""'");
27231   }
27232   arg3 = static_cast< int >(val3);
27233   result = (Hex::Elements *)(arg1)->extrudeQuadTop(arg2,arg3);
27234   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27235   return resultobj;
27236 fail:
27237   return NULL;
27238 }
27239
27240
27241 SWIGINTERN PyObject *_wrap_Document_extrudeQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27242   PyObject *resultobj = 0;
27243   Hex::Document *arg1 = (Hex::Document *) 0 ;
27244   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27245   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27246   double arg4 ;
27247   int arg5 ;
27248   Hex::Elements *result = 0 ;
27249   void *argp1 = 0 ;
27250   int res1 = 0 ;
27251   void *argp2 = 0 ;
27252   int res2 = 0 ;
27253   void *argp3 = 0 ;
27254   int res3 = 0 ;
27255   double val4 ;
27256   int ecode4 = 0 ;
27257   int val5 ;
27258   int ecode5 = 0 ;
27259   PyObject * obj0 = 0 ;
27260   PyObject * obj1 = 0 ;
27261   PyObject * obj2 = 0 ;
27262   PyObject * obj3 = 0 ;
27263   PyObject * obj4 = 0 ;
27264
27265   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27266   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27267   if (!SWIG_IsOK(res1)) {
27268     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
27269   }
27270   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27271   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27272   if (!SWIG_IsOK(res2)) {
27273     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
27274   }
27275   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27276   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27277   if (!SWIG_IsOK(res3)) {
27278     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadUni" "', argument " "3"" of type '" "Hex::Vector *""'");
27279   }
27280   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27281   ecode4 = SWIG_AsVal_double(obj3, &val4);
27282   if (!SWIG_IsOK(ecode4)) {
27283     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadUni" "', argument " "4"" of type '" "double""'");
27284   }
27285   arg4 = static_cast< double >(val4);
27286   ecode5 = SWIG_AsVal_int(obj4, &val5);
27287   if (!SWIG_IsOK(ecode5)) {
27288     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadUni" "', argument " "5"" of type '" "int""'");
27289   }
27290   arg5 = static_cast< int >(val5);
27291   result = (Hex::Elements *)(arg1)->extrudeQuadUni(arg2,arg3,arg4,arg5);
27292   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27293   return resultobj;
27294 fail:
27295   return NULL;
27296 }
27297
27298
27299 SWIGINTERN PyObject *_wrap_Document_extrudeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27300   PyObject *resultobj = 0;
27301   Hex::Document *arg1 = (Hex::Document *) 0 ;
27302   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27303   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27304   Hex::RealVector arg4 ;
27305   Hex::Elements *result = 0 ;
27306   void *argp1 = 0 ;
27307   int res1 = 0 ;
27308   void *argp2 = 0 ;
27309   int res2 = 0 ;
27310   void *argp3 = 0 ;
27311   int res3 = 0 ;
27312   PyObject * obj0 = 0 ;
27313   PyObject * obj1 = 0 ;
27314   PyObject * obj2 = 0 ;
27315   PyObject * obj3 = 0 ;
27316
27317   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27318   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27319   if (!SWIG_IsOK(res1)) {
27320     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27321   }
27322   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27323   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27324   if (!SWIG_IsOK(res2)) {
27325     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
27326   }
27327   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27328   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27329   if (!SWIG_IsOK(res3)) {
27330     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuad" "', argument " "3"" of type '" "Hex::Vector *""'");
27331   }
27332   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27333   {
27334     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27335     int res = swig::asptr(obj3, &ptr);
27336     if (!SWIG_IsOK(res) || !ptr) {
27337       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuad" "', argument " "4"" of type '" "Hex::RealVector""'");
27338     }
27339     arg4 = *ptr;
27340     if (SWIG_IsNewObj(res)) delete ptr;
27341   }
27342   result = (Hex::Elements *)(arg1)->extrudeQuad(arg2,arg3,arg4);
27343   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27344   return resultobj;
27345 fail:
27346   return NULL;
27347 }
27348
27349
27350 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27351   PyObject *resultobj = 0;
27352   Hex::Document *arg1 = (Hex::Document *) 0 ;
27353   Hex::Quads arg2 ;
27354   int arg3 ;
27355   Hex::Elements *result = 0 ;
27356   void *argp1 = 0 ;
27357   int res1 = 0 ;
27358   int val3 ;
27359   int ecode3 = 0 ;
27360   PyObject * obj0 = 0 ;
27361   PyObject * obj1 = 0 ;
27362   PyObject * obj2 = 0 ;
27363
27364   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadsTop",&obj0,&obj1,&obj2)) SWIG_fail;
27365   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27366   if (!SWIG_IsOK(res1)) {
27367     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsTop" "', argument " "1"" of type '" "Hex::Document *""'");
27368   }
27369   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27370   {
27371     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27372     int res = swig::asptr(obj1, &ptr);
27373     if (!SWIG_IsOK(res) || !ptr) {
27374       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsTop" "', argument " "2"" of type '" "Hex::Quads""'");
27375     }
27376     arg2 = *ptr;
27377     if (SWIG_IsNewObj(res)) delete ptr;
27378   }
27379   ecode3 = SWIG_AsVal_int(obj2, &val3);
27380   if (!SWIG_IsOK(ecode3)) {
27381     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadsTop" "', argument " "3"" of type '" "int""'");
27382   }
27383   arg3 = static_cast< int >(val3);
27384   result = (Hex::Elements *)(arg1)->extrudeQuadsTop(arg2,arg3);
27385   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27386   return resultobj;
27387 fail:
27388   return NULL;
27389 }
27390
27391
27392 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27393   PyObject *resultobj = 0;
27394   Hex::Document *arg1 = (Hex::Document *) 0 ;
27395   Hex::Quads arg2 ;
27396   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27397   double arg4 ;
27398   int arg5 ;
27399   Hex::Elements *result = 0 ;
27400   void *argp1 = 0 ;
27401   int res1 = 0 ;
27402   void *argp3 = 0 ;
27403   int res3 = 0 ;
27404   double val4 ;
27405   int ecode4 = 0 ;
27406   int val5 ;
27407   int ecode5 = 0 ;
27408   PyObject * obj0 = 0 ;
27409   PyObject * obj1 = 0 ;
27410   PyObject * obj2 = 0 ;
27411   PyObject * obj3 = 0 ;
27412   PyObject * obj4 = 0 ;
27413
27414   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27415   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27416   if (!SWIG_IsOK(res1)) {
27417     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
27418   }
27419   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27420   {
27421     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27422     int res = swig::asptr(obj1, &ptr);
27423     if (!SWIG_IsOK(res) || !ptr) {
27424       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
27425     }
27426     arg2 = *ptr;
27427     if (SWIG_IsNewObj(res)) delete ptr;
27428   }
27429   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27430   if (!SWIG_IsOK(res3)) {
27431     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadsUni" "', argument " "3"" of type '" "Hex::Vector *""'");
27432   }
27433   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27434   ecode4 = SWIG_AsVal_double(obj3, &val4);
27435   if (!SWIG_IsOK(ecode4)) {
27436     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadsUni" "', argument " "4"" of type '" "double""'");
27437   }
27438   arg4 = static_cast< double >(val4);
27439   ecode5 = SWIG_AsVal_int(obj4, &val5);
27440   if (!SWIG_IsOK(ecode5)) {
27441     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadsUni" "', argument " "5"" of type '" "int""'");
27442   }
27443   arg5 = static_cast< int >(val5);
27444   result = (Hex::Elements *)(arg1)->extrudeQuadsUni(arg2,arg3,arg4,arg5);
27445   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27446   return resultobj;
27447 fail:
27448   return NULL;
27449 }
27450
27451
27452 SWIGINTERN PyObject *_wrap_Document_extrudeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27453   PyObject *resultobj = 0;
27454   Hex::Document *arg1 = (Hex::Document *) 0 ;
27455   Hex::Quads arg2 ;
27456   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27457   Hex::RealVector arg4 ;
27458   Hex::Elements *result = 0 ;
27459   void *argp1 = 0 ;
27460   int res1 = 0 ;
27461   void *argp3 = 0 ;
27462   int res3 = 0 ;
27463   PyObject * obj0 = 0 ;
27464   PyObject * obj1 = 0 ;
27465   PyObject * obj2 = 0 ;
27466   PyObject * obj3 = 0 ;
27467
27468   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27469   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27470   if (!SWIG_IsOK(res1)) {
27471     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
27472   }
27473   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27474   {
27475     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27476     int res = swig::asptr(obj1, &ptr);
27477     if (!SWIG_IsOK(res) || !ptr) {
27478       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "2"" of type '" "Hex::Quads""'");
27479     }
27480     arg2 = *ptr;
27481     if (SWIG_IsNewObj(res)) delete ptr;
27482   }
27483   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27484   if (!SWIG_IsOK(res3)) {
27485     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuads" "', argument " "3"" of type '" "Hex::Vector *""'");
27486   }
27487   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27488   {
27489     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27490     int res = swig::asptr(obj3, &ptr);
27491     if (!SWIG_IsOK(res) || !ptr) {
27492       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "4"" of type '" "Hex::RealVector""'");
27493     }
27494     arg4 = *ptr;
27495     if (SWIG_IsNewObj(res)) delete ptr;
27496   }
27497   result = (Hex::Elements *)(arg1)->extrudeQuads(arg2,arg3,arg4);
27498   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27499   return resultobj;
27500 fail:
27501   return NULL;
27502 }
27503
27504
27505 SWIGINTERN PyObject *_wrap_Document_revolutionQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27506   PyObject *resultobj = 0;
27507   Hex::Document *arg1 = (Hex::Document *) 0 ;
27508   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27509   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27510   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27511   double arg5 ;
27512   int arg6 ;
27513   Hex::Elements *result = 0 ;
27514   void *argp1 = 0 ;
27515   int res1 = 0 ;
27516   void *argp2 = 0 ;
27517   int res2 = 0 ;
27518   void *argp3 = 0 ;
27519   int res3 = 0 ;
27520   void *argp4 = 0 ;
27521   int res4 = 0 ;
27522   double val5 ;
27523   int ecode5 = 0 ;
27524   int val6 ;
27525   int ecode6 = 0 ;
27526   PyObject * obj0 = 0 ;
27527   PyObject * obj1 = 0 ;
27528   PyObject * obj2 = 0 ;
27529   PyObject * obj3 = 0 ;
27530   PyObject * obj4 = 0 ;
27531   PyObject * obj5 = 0 ;
27532
27533   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27534   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27535   if (!SWIG_IsOK(res1)) {
27536     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
27537   }
27538   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27539   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27540   if (!SWIG_IsOK(res2)) {
27541     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
27542   }
27543   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27544   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27545   if (!SWIG_IsOK(res3)) {
27546     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
27547   }
27548   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27549   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27550   if (!SWIG_IsOK(res4)) {
27551     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadUni" "', argument " "4"" of type '" "Hex::Vector *""'");
27552   }
27553   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27554   ecode5 = SWIG_AsVal_double(obj4, &val5);
27555   if (!SWIG_IsOK(ecode5)) {
27556     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadUni" "', argument " "5"" of type '" "double""'");
27557   }
27558   arg5 = static_cast< double >(val5);
27559   ecode6 = SWIG_AsVal_int(obj5, &val6);
27560   if (!SWIG_IsOK(ecode6)) {
27561     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadUni" "', argument " "6"" of type '" "int""'");
27562   }
27563   arg6 = static_cast< int >(val6);
27564   result = (Hex::Elements *)(arg1)->revolutionQuadUni(arg2,arg3,arg4,arg5,arg6);
27565   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27566   return resultobj;
27567 fail:
27568   return NULL;
27569 }
27570
27571
27572 SWIGINTERN PyObject *_wrap_Document_revolutionQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27573   PyObject *resultobj = 0;
27574   Hex::Document *arg1 = (Hex::Document *) 0 ;
27575   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27576   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27577   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27578   Hex::RealVector arg5 ;
27579   Hex::Elements *result = 0 ;
27580   void *argp1 = 0 ;
27581   int res1 = 0 ;
27582   void *argp2 = 0 ;
27583   int res2 = 0 ;
27584   void *argp3 = 0 ;
27585   int res3 = 0 ;
27586   void *argp4 = 0 ;
27587   int res4 = 0 ;
27588   PyObject * obj0 = 0 ;
27589   PyObject * obj1 = 0 ;
27590   PyObject * obj2 = 0 ;
27591   PyObject * obj3 = 0 ;
27592   PyObject * obj4 = 0 ;
27593
27594   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27595   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27596   if (!SWIG_IsOK(res1)) {
27597     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27598   }
27599   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27600   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27601   if (!SWIG_IsOK(res2)) {
27602     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
27603   }
27604   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27605   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27606   if (!SWIG_IsOK(res3)) {
27607     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
27608   }
27609   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27610   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27611   if (!SWIG_IsOK(res4)) {
27612     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuad" "', argument " "4"" of type '" "Hex::Vector *""'");
27613   }
27614   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27615   {
27616     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27617     int res = swig::asptr(obj4, &ptr);
27618     if (!SWIG_IsOK(res) || !ptr) {
27619       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuad" "', argument " "5"" of type '" "Hex::RealVector""'");
27620     }
27621     arg5 = *ptr;
27622     if (SWIG_IsNewObj(res)) delete ptr;
27623   }
27624   result = (Hex::Elements *)(arg1)->revolutionQuad(arg2,arg3,arg4,arg5);
27625   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27626   return resultobj;
27627 fail:
27628   return NULL;
27629 }
27630
27631
27632 SWIGINTERN PyObject *_wrap_Document_revolutionQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27633   PyObject *resultobj = 0;
27634   Hex::Document *arg1 = (Hex::Document *) 0 ;
27635   Hex::Quads arg2 ;
27636   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27637   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27638   double arg5 ;
27639   int arg6 ;
27640   Hex::Elements *result = 0 ;
27641   void *argp1 = 0 ;
27642   int res1 = 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   int val6 ;
27650   int ecode6 = 0 ;
27651   PyObject * obj0 = 0 ;
27652   PyObject * obj1 = 0 ;
27653   PyObject * obj2 = 0 ;
27654   PyObject * obj3 = 0 ;
27655   PyObject * obj4 = 0 ;
27656   PyObject * obj5 = 0 ;
27657
27658   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27659   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27660   if (!SWIG_IsOK(res1)) {
27661     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
27662   }
27663   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27664   {
27665     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27666     int res = swig::asptr(obj1, &ptr);
27667     if (!SWIG_IsOK(res) || !ptr) {
27668       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
27669     }
27670     arg2 = *ptr;
27671     if (SWIG_IsNewObj(res)) delete ptr;
27672   }
27673   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27674   if (!SWIG_IsOK(res3)) {
27675     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadsUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
27676   }
27677   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27678   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27679   if (!SWIG_IsOK(res4)) {
27680     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadsUni" "', argument " "4"" of type '" "Hex::Vector *""'");
27681   }
27682   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27683   ecode5 = SWIG_AsVal_double(obj4, &val5);
27684   if (!SWIG_IsOK(ecode5)) {
27685     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadsUni" "', argument " "5"" of type '" "double""'");
27686   }
27687   arg5 = static_cast< double >(val5);
27688   ecode6 = SWIG_AsVal_int(obj5, &val6);
27689   if (!SWIG_IsOK(ecode6)) {
27690     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadsUni" "', argument " "6"" of type '" "int""'");
27691   }
27692   arg6 = static_cast< int >(val6);
27693   result = (Hex::Elements *)(arg1)->revolutionQuadsUni(arg2,arg3,arg4,arg5,arg6);
27694   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27695   return resultobj;
27696 fail:
27697   return NULL;
27698 }
27699
27700
27701 SWIGINTERN PyObject *_wrap_Document_revolutionQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27702   PyObject *resultobj = 0;
27703   Hex::Document *arg1 = (Hex::Document *) 0 ;
27704   Hex::Quads arg2 ;
27705   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27706   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27707   Hex::RealVector arg5 ;
27708   Hex::Elements *result = 0 ;
27709   void *argp1 = 0 ;
27710   int res1 = 0 ;
27711   void *argp3 = 0 ;
27712   int res3 = 0 ;
27713   void *argp4 = 0 ;
27714   int res4 = 0 ;
27715   PyObject * obj0 = 0 ;
27716   PyObject * obj1 = 0 ;
27717   PyObject * obj2 = 0 ;
27718   PyObject * obj3 = 0 ;
27719   PyObject * obj4 = 0 ;
27720
27721   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27722   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27723   if (!SWIG_IsOK(res1)) {
27724     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuads" "', argument " "1"" of type '" "Hex::Document *""'");
27725   }
27726   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27727   {
27728     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27729     int res = swig::asptr(obj1, &ptr);
27730     if (!SWIG_IsOK(res) || !ptr) {
27731       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "2"" of type '" "Hex::Quads""'");
27732     }
27733     arg2 = *ptr;
27734     if (SWIG_IsNewObj(res)) delete ptr;
27735   }
27736   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27737   if (!SWIG_IsOK(res3)) {
27738     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuads" "', argument " "3"" of type '" "Hex::Vertex *""'");
27739   }
27740   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27741   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27742   if (!SWIG_IsOK(res4)) {
27743     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuads" "', argument " "4"" of type '" "Hex::Vector *""'");
27744   }
27745   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27746   {
27747     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27748     int res = swig::asptr(obj4, &ptr);
27749     if (!SWIG_IsOK(res) || !ptr) {
27750       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "5"" of type '" "Hex::RealVector""'");
27751     }
27752     arg5 = *ptr;
27753     if (SWIG_IsNewObj(res)) delete ptr;
27754   }
27755   result = (Hex::Elements *)(arg1)->revolutionQuads(arg2,arg3,arg4,arg5);
27756   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27757   return resultobj;
27758 fail:
27759   return NULL;
27760 }
27761
27762
27763 SWIGINTERN PyObject *_wrap_Document_joinQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27764   PyObject *resultobj = 0;
27765   Hex::Document *arg1 = (Hex::Document *) 0 ;
27766   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27767   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
27768   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27769   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27770   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27771   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27772   int arg8 ;
27773   Hex::Elements *result = 0 ;
27774   void *argp1 = 0 ;
27775   int res1 = 0 ;
27776   void *argp2 = 0 ;
27777   int res2 = 0 ;
27778   void *argp3 = 0 ;
27779   int res3 = 0 ;
27780   void *argp4 = 0 ;
27781   int res4 = 0 ;
27782   void *argp5 = 0 ;
27783   int res5 = 0 ;
27784   void *argp6 = 0 ;
27785   int res6 = 0 ;
27786   void *argp7 = 0 ;
27787   int res7 = 0 ;
27788   int val8 ;
27789   int ecode8 = 0 ;
27790   PyObject * obj0 = 0 ;
27791   PyObject * obj1 = 0 ;
27792   PyObject * obj2 = 0 ;
27793   PyObject * obj3 = 0 ;
27794   PyObject * obj4 = 0 ;
27795   PyObject * obj5 = 0 ;
27796   PyObject * obj6 = 0 ;
27797   PyObject * obj7 = 0 ;
27798
27799   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
27800   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27801   if (!SWIG_IsOK(res1)) {
27802     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
27803   }
27804   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27805   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27806   if (!SWIG_IsOK(res2)) {
27807     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
27808   }
27809   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27810   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27811   if (!SWIG_IsOK(res3)) {
27812     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadUni" "', argument " "3"" of type '" "Hex::Quad *""'");
27813   }
27814   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
27815   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27816   if (!SWIG_IsOK(res4)) {
27817     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
27818   }
27819   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27820   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27821   if (!SWIG_IsOK(res5)) {
27822     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
27823   }
27824   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27825   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27826   if (!SWIG_IsOK(res6)) {
27827     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
27828   }
27829   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27830   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27831   if (!SWIG_IsOK(res7)) {
27832     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
27833   }
27834   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27835   ecode8 = SWIG_AsVal_int(obj7, &val8);
27836   if (!SWIG_IsOK(ecode8)) {
27837     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadUni" "', argument " "8"" of type '" "int""'");
27838   }
27839   arg8 = static_cast< int >(val8);
27840   result = (Hex::Elements *)(arg1)->joinQuadUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
27841   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27842   return resultobj;
27843 fail:
27844   return NULL;
27845 }
27846
27847
27848 SWIGINTERN PyObject *_wrap_Document_joinQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27849   PyObject *resultobj = 0;
27850   Hex::Document *arg1 = (Hex::Document *) 0 ;
27851   Hex::Quads arg2 ;
27852   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
27853   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27854   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27855   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27856   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27857   int arg8 ;
27858   Hex::Elements *result = 0 ;
27859   void *argp1 = 0 ;
27860   int res1 = 0 ;
27861   void *argp3 = 0 ;
27862   int res3 = 0 ;
27863   void *argp4 = 0 ;
27864   int res4 = 0 ;
27865   void *argp5 = 0 ;
27866   int res5 = 0 ;
27867   void *argp6 = 0 ;
27868   int res6 = 0 ;
27869   void *argp7 = 0 ;
27870   int res7 = 0 ;
27871   int val8 ;
27872   int ecode8 = 0 ;
27873   PyObject * obj0 = 0 ;
27874   PyObject * obj1 = 0 ;
27875   PyObject * obj2 = 0 ;
27876   PyObject * obj3 = 0 ;
27877   PyObject * obj4 = 0 ;
27878   PyObject * obj5 = 0 ;
27879   PyObject * obj6 = 0 ;
27880   PyObject * obj7 = 0 ;
27881
27882   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
27883   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27884   if (!SWIG_IsOK(res1)) {
27885     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
27886   }
27887   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27888   {
27889     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27890     int res = swig::asptr(obj1, &ptr);
27891     if (!SWIG_IsOK(res) || !ptr) {
27892       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
27893     }
27894     arg2 = *ptr;
27895     if (SWIG_IsNewObj(res)) delete ptr;
27896   }
27897   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27898   if (!SWIG_IsOK(res3)) {
27899     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadsUni" "', argument " "3"" of type '" "Hex::Quad *""'");
27900   }
27901   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
27902   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27903   if (!SWIG_IsOK(res4)) {
27904     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadsUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
27905   }
27906   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27907   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27908   if (!SWIG_IsOK(res5)) {
27909     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadsUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
27910   }
27911   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27912   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27913   if (!SWIG_IsOK(res6)) {
27914     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadsUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
27915   }
27916   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27917   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27918   if (!SWIG_IsOK(res7)) {
27919     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadsUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
27920   }
27921   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27922   ecode8 = SWIG_AsVal_int(obj7, &val8);
27923   if (!SWIG_IsOK(ecode8)) {
27924     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadsUni" "', argument " "8"" of type '" "int""'");
27925   }
27926   arg8 = static_cast< int >(val8);
27927   result = (Hex::Elements *)(arg1)->joinQuadsUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
27928   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27929   return resultobj;
27930 fail:
27931   return NULL;
27932 }
27933
27934
27935 SWIGINTERN PyObject *_wrap_Document_joinQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27936   PyObject *resultobj = 0;
27937   Hex::Document *arg1 = (Hex::Document *) 0 ;
27938   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27939   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
27940   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27941   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27942   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27943   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27944   Hex::RealVector *arg8 = 0 ;
27945   Hex::Elements *result = 0 ;
27946   void *argp1 = 0 ;
27947   int res1 = 0 ;
27948   void *argp2 = 0 ;
27949   int res2 = 0 ;
27950   void *argp3 = 0 ;
27951   int res3 = 0 ;
27952   void *argp4 = 0 ;
27953   int res4 = 0 ;
27954   void *argp5 = 0 ;
27955   int res5 = 0 ;
27956   void *argp6 = 0 ;
27957   int res6 = 0 ;
27958   void *argp7 = 0 ;
27959   int res7 = 0 ;
27960   void *argp8 = 0 ;
27961   int res8 = 0 ;
27962   PyObject * obj0 = 0 ;
27963   PyObject * obj1 = 0 ;
27964   PyObject * obj2 = 0 ;
27965   PyObject * obj3 = 0 ;
27966   PyObject * obj4 = 0 ;
27967   PyObject * obj5 = 0 ;
27968   PyObject * obj6 = 0 ;
27969   PyObject * obj7 = 0 ;
27970
27971   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuad",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
27972   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27973   if (!SWIG_IsOK(res1)) {
27974     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27975   }
27976   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27977   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27978   if (!SWIG_IsOK(res2)) {
27979     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
27980   }
27981   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27982   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27983   if (!SWIG_IsOK(res3)) {
27984     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuad" "', argument " "3"" of type '" "Hex::Quad *""'");
27985   }
27986   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
27987   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27988   if (!SWIG_IsOK(res4)) {
27989     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuad" "', argument " "4"" of type '" "Hex::Vertex *""'");
27990   }
27991   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27992   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27993   if (!SWIG_IsOK(res5)) {
27994     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuad" "', argument " "5"" of type '" "Hex::Vertex *""'");
27995   }
27996   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27997   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27998   if (!SWIG_IsOK(res6)) {
27999     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuad" "', argument " "6"" of type '" "Hex::Vertex *""'");
28000   }
28001   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
28002   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28003   if (!SWIG_IsOK(res7)) {
28004     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuad" "', argument " "7"" of type '" "Hex::Vertex *""'");
28005   }
28006   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
28007   res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t,  0 );
28008   if (!SWIG_IsOK(res8)) {
28009     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
28010   }
28011   if (!argp8) {
28012     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
28013   }
28014   arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
28015   result = (Hex::Elements *)(arg1)->joinQuad(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
28016   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28017   return resultobj;
28018 fail:
28019   return NULL;
28020 }
28021
28022
28023 SWIGINTERN PyObject *_wrap_Document_joinQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28024   PyObject *resultobj = 0;
28025   Hex::Document *arg1 = (Hex::Document *) 0 ;
28026   Hex::Quads arg2 ;
28027   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
28028   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
28029   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
28030   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
28031   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
28032   Hex::RealVector *arg8 = 0 ;
28033   Hex::Elements *result = 0 ;
28034   void *argp1 = 0 ;
28035   int res1 = 0 ;
28036   void *argp3 = 0 ;
28037   int res3 = 0 ;
28038   void *argp4 = 0 ;
28039   int res4 = 0 ;
28040   void *argp5 = 0 ;
28041   int res5 = 0 ;
28042   void *argp6 = 0 ;
28043   int res6 = 0 ;
28044   void *argp7 = 0 ;
28045   int res7 = 0 ;
28046   void *argp8 = 0 ;
28047   int res8 = 0 ;
28048   PyObject * obj0 = 0 ;
28049   PyObject * obj1 = 0 ;
28050   PyObject * obj2 = 0 ;
28051   PyObject * obj3 = 0 ;
28052   PyObject * obj4 = 0 ;
28053   PyObject * obj5 = 0 ;
28054   PyObject * obj6 = 0 ;
28055   PyObject * obj7 = 0 ;
28056
28057   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
28058   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28059   if (!SWIG_IsOK(res1)) {
28060     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuads" "', argument " "1"" of type '" "Hex::Document *""'");
28061   }
28062   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28063   {
28064     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
28065     int res = swig::asptr(obj1, &ptr);
28066     if (!SWIG_IsOK(res) || !ptr) {
28067       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuads" "', argument " "2"" of type '" "Hex::Quads""'");
28068     }
28069     arg2 = *ptr;
28070     if (SWIG_IsNewObj(res)) delete ptr;
28071   }
28072   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28073   if (!SWIG_IsOK(res3)) {
28074     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
28075   }
28076   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
28077   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28078   if (!SWIG_IsOK(res4)) {
28079     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuads" "', argument " "4"" of type '" "Hex::Vertex *""'");
28080   }
28081   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
28082   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28083   if (!SWIG_IsOK(res5)) {
28084     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuads" "', argument " "5"" of type '" "Hex::Vertex *""'");
28085   }
28086   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
28087   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28088   if (!SWIG_IsOK(res6)) {
28089     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuads" "', argument " "6"" of type '" "Hex::Vertex *""'");
28090   }
28091   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
28092   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28093   if (!SWIG_IsOK(res7)) {
28094     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
28095   }
28096   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
28097   res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t,  0 );
28098   if (!SWIG_IsOK(res8)) {
28099     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
28100   }
28101   if (!argp8) {
28102     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
28103   }
28104   arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
28105   result = (Hex::Elements *)(arg1)->joinQuads(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
28106   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28107   return resultobj;
28108 fail:
28109   return NULL;
28110 }
28111
28112
28113 SWIGINTERN PyObject *_wrap_Document_cutUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28114   PyObject *resultobj = 0;
28115   Hex::Document *arg1 = (Hex::Document *) 0 ;
28116   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28117   int arg3 ;
28118   Hex::Elements *result = 0 ;
28119   void *argp1 = 0 ;
28120   int res1 = 0 ;
28121   void *argp2 = 0 ;
28122   int res2 = 0 ;
28123   int val3 ;
28124   int ecode3 = 0 ;
28125   PyObject * obj0 = 0 ;
28126   PyObject * obj1 = 0 ;
28127   PyObject * obj2 = 0 ;
28128
28129   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cutUni",&obj0,&obj1,&obj2)) SWIG_fail;
28130   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28131   if (!SWIG_IsOK(res1)) {
28132     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cutUni" "', argument " "1"" of type '" "Hex::Document *""'");
28133   }
28134   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28135   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
28136   if (!SWIG_IsOK(res2)) {
28137     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cutUni" "', argument " "2"" of type '" "Hex::Edge *""'");
28138   }
28139   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28140   ecode3 = SWIG_AsVal_int(obj2, &val3);
28141   if (!SWIG_IsOK(ecode3)) {
28142     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_cutUni" "', argument " "3"" of type '" "int""'");
28143   }
28144   arg3 = static_cast< int >(val3);
28145   result = (Hex::Elements *)(arg1)->cutUni(arg2,arg3);
28146   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28147   return resultobj;
28148 fail:
28149   return NULL;
28150 }
28151
28152
28153 SWIGINTERN PyObject *_wrap_Document_cut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28154   PyObject *resultobj = 0;
28155   Hex::Document *arg1 = (Hex::Document *) 0 ;
28156   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28157   Hex::RealVector *arg3 = 0 ;
28158   Hex::Elements *result = 0 ;
28159   void *argp1 = 0 ;
28160   int res1 = 0 ;
28161   void *argp2 = 0 ;
28162   int res2 = 0 ;
28163   void *argp3 = 0 ;
28164   int res3 = 0 ;
28165   PyObject * obj0 = 0 ;
28166   PyObject * obj1 = 0 ;
28167   PyObject * obj2 = 0 ;
28168
28169   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cut",&obj0,&obj1,&obj2)) SWIG_fail;
28170   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28171   if (!SWIG_IsOK(res1)) {
28172     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cut" "', argument " "1"" of type '" "Hex::Document *""'");
28173   }
28174   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28175   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
28176   if (!SWIG_IsOK(res2)) {
28177     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cut" "', argument " "2"" of type '" "Hex::Edge *""'");
28178   }
28179   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28180   res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t,  0 );
28181   if (!SWIG_IsOK(res3)) {
28182     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
28183   }
28184   if (!argp3) {
28185     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
28186   }
28187   arg3 = reinterpret_cast< Hex::RealVector * >(argp3);
28188   result = (Hex::Elements *)(arg1)->cut(arg2,*arg3);
28189   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28190   return resultobj;
28191 fail:
28192   return NULL;
28193 }
28194
28195
28196 SWIGINTERN PyObject *_wrap_Document_addGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28197   PyObject *resultobj = 0;
28198   Hex::Document *arg1 = (Hex::Document *) 0 ;
28199   cpchar arg2 = (cpchar) 0 ;
28200   Hex::EnumGroup arg3 ;
28201   Hex::Group *result = 0 ;
28202   void *argp1 = 0 ;
28203   int res1 = 0 ;
28204   int res2 ;
28205   char *buf2 = 0 ;
28206   int alloc2 = 0 ;
28207   int val3 ;
28208   int ecode3 = 0 ;
28209   PyObject * obj0 = 0 ;
28210   PyObject * obj1 = 0 ;
28211   PyObject * obj2 = 0 ;
28212
28213   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addGroup",&obj0,&obj1,&obj2)) SWIG_fail;
28214   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28215   if (!SWIG_IsOK(res1)) {
28216     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addGroup" "', argument " "1"" of type '" "Hex::Document *""'");
28217   }
28218   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28219   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28220   if (!SWIG_IsOK(res2)) {
28221     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addGroup" "', argument " "2"" of type '" "cpchar""'");
28222   }
28223   arg2 = reinterpret_cast< cpchar >(buf2);
28224   ecode3 = SWIG_AsVal_int(obj2, &val3);
28225   if (!SWIG_IsOK(ecode3)) {
28226     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addGroup" "', argument " "3"" of type '" "Hex::EnumGroup""'");
28227   }
28228   arg3 = static_cast< Hex::EnumGroup >(val3);
28229   result = (Hex::Group *)(arg1)->addGroup(arg2,arg3);
28230   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
28231   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28232   return resultobj;
28233 fail:
28234   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28235   return NULL;
28236 }
28237
28238
28239 SWIGINTERN PyObject *_wrap_Document_isSaved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28240   PyObject *resultobj = 0;
28241   Hex::Document *arg1 = (Hex::Document *) 0 ;
28242   bool result;
28243   void *argp1 = 0 ;
28244   int res1 = 0 ;
28245   PyObject * obj0 = 0 ;
28246
28247   if (!PyArg_ParseTuple(args,(char *)"O:Document_isSaved",&obj0)) SWIG_fail;
28248   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28249   if (!SWIG_IsOK(res1)) {
28250     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_isSaved" "', argument " "1"" of type '" "Hex::Document *""'");
28251   }
28252   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28253   result = (bool)(arg1)->isSaved();
28254   resultobj = SWIG_From_bool(static_cast< bool >(result));
28255   return resultobj;
28256 fail:
28257   return NULL;
28258 }
28259
28260
28261 SWIGINTERN PyObject *_wrap_Document_appendXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28262   PyObject *resultobj = 0;
28263   Hex::Document *arg1 = (Hex::Document *) 0 ;
28264   pfile arg2 = (pfile) 0 ;
28265   int result;
28266   void *argp1 = 0 ;
28267   int res1 = 0 ;
28268   void *argp2 = 0 ;
28269   int res2 = 0 ;
28270   PyObject * obj0 = 0 ;
28271   PyObject * obj1 = 0 ;
28272
28273   if (!PyArg_ParseTuple(args,(char *)"OO:Document_appendXml",&obj0,&obj1)) SWIG_fail;
28274   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28275   if (!SWIG_IsOK(res1)) {
28276     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_appendXml" "', argument " "1"" of type '" "Hex::Document *""'");
28277   }
28278   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28279   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
28280   if (!SWIG_IsOK(res2)) {
28281     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_appendXml" "', argument " "2"" of type '" "pfile""'");
28282   }
28283   arg2 = reinterpret_cast< pfile >(argp2);
28284   result = (int)(arg1)->appendXml(arg2);
28285   resultobj = SWIG_From_int(static_cast< int >(result));
28286   return resultobj;
28287 fail:
28288   return NULL;
28289 }
28290
28291
28292 SWIGINTERN PyObject *_wrap_Document_getXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28293   PyObject *resultobj = 0;
28294   Hex::Document *arg1 = (Hex::Document *) 0 ;
28295   cpchar result;
28296   void *argp1 = 0 ;
28297   int res1 = 0 ;
28298   PyObject * obj0 = 0 ;
28299
28300   if (!PyArg_ParseTuple(args,(char *)"O:Document_getXml",&obj0)) SWIG_fail;
28301   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28302   if (!SWIG_IsOK(res1)) {
28303     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getXml" "', argument " "1"" of type '" "Hex::Document *""'");
28304   }
28305   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28306   result = (cpchar)(arg1)->getXml();
28307   resultobj = SWIG_FromCharPtr((const char *)result);
28308   return resultobj;
28309 fail:
28310   return NULL;
28311 }
28312
28313
28314 SWIGINTERN PyObject *_wrap_Document_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28315   PyObject *resultobj = 0;
28316   Hex::Document *arg1 = (Hex::Document *) 0 ;
28317   int result;
28318   void *argp1 = 0 ;
28319   int res1 = 0 ;
28320   PyObject * obj0 = 0 ;
28321
28322   if (!PyArg_ParseTuple(args,(char *)"O:Document_getLevel",&obj0)) SWIG_fail;
28323   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28324   if (!SWIG_IsOK(res1)) {
28325     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getLevel" "', argument " "1"" of type '" "Hex::Document *""'");
28326   }
28327   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28328   result = (int)(arg1)->getLevel();
28329   resultobj = SWIG_From_int(static_cast< int >(result));
28330   return resultobj;
28331 fail:
28332   return NULL;
28333 }
28334
28335
28336 SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28337   PyObject *resultobj = 0;
28338   Hex::Document *arg1 = (Hex::Document *) 0 ;
28339   int arg2 ;
28340   Hex::Vertex *result = 0 ;
28341   void *argp1 = 0 ;
28342   int res1 = 0 ;
28343   int val2 ;
28344   int ecode2 = 0 ;
28345   PyObject * obj0 = 0 ;
28346   PyObject * obj1 = 0 ;
28347
28348   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findVertex",&obj0,&obj1)) SWIG_fail;
28349   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28350   if (!SWIG_IsOK(res1)) {
28351     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
28352   }
28353   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28354   ecode2 = SWIG_AsVal_int(obj1, &val2);
28355   if (!SWIG_IsOK(ecode2)) {
28356     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "int""'");
28357   }
28358   arg2 = static_cast< int >(val2);
28359   result = (Hex::Vertex *)(arg1)->findVertex(arg2);
28360   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28361   return resultobj;
28362 fail:
28363   return NULL;
28364 }
28365
28366
28367 SWIGINTERN PyObject *_wrap_Document_findVertex(PyObject *self, PyObject *args) {
28368   int argc;
28369   PyObject *argv[5];
28370   int ii;
28371
28372   if (!PyTuple_Check(args)) SWIG_fail;
28373   argc = PyObject_Length(args);
28374   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
28375     argv[ii] = PyTuple_GET_ITEM(args,ii);
28376   }
28377   if (argc == 2) {
28378     int _v;
28379     void *vptr = 0;
28380     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28381     _v = SWIG_CheckState(res);
28382     if (_v) {
28383       {
28384         int res = SWIG_AsVal_int(argv[1], NULL);
28385         _v = SWIG_CheckState(res);
28386       }
28387       if (_v) {
28388         return _wrap_Document_findVertex__SWIG_1(self, args);
28389       }
28390     }
28391   }
28392   if (argc == 4) {
28393     int _v;
28394     void *vptr = 0;
28395     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28396     _v = SWIG_CheckState(res);
28397     if (_v) {
28398       {
28399         int res = SWIG_AsVal_double(argv[1], NULL);
28400         _v = SWIG_CheckState(res);
28401       }
28402       if (_v) {
28403         {
28404           int res = SWIG_AsVal_double(argv[2], NULL);
28405           _v = SWIG_CheckState(res);
28406         }
28407         if (_v) {
28408           {
28409             int res = SWIG_AsVal_double(argv[3], NULL);
28410             _v = SWIG_CheckState(res);
28411           }
28412           if (_v) {
28413             return _wrap_Document_findVertex__SWIG_0(self, args);
28414           }
28415         }
28416       }
28417     }
28418   }
28419
28420 fail:
28421   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_findVertex'.\n  Possible C/C++ prototypes are:\n    findVertex(double,double,double)\n    findVertex(int)\n");
28422   return NULL;
28423 }
28424
28425
28426 SWIGINTERN PyObject *_wrap_Document_closeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28427   PyObject *resultobj = 0;
28428   Hex::Document *arg1 = (Hex::Document *) 0 ;
28429   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
28430   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
28431   int result;
28432   void *argp1 = 0 ;
28433   int res1 = 0 ;
28434   void *argp2 = 0 ;
28435   int res2 = 0 ;
28436   void *argp3 = 0 ;
28437   int res3 = 0 ;
28438   PyObject * obj0 = 0 ;
28439   PyObject * obj1 = 0 ;
28440   PyObject * obj2 = 0 ;
28441
28442   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_closeQuads",&obj0,&obj1,&obj2)) SWIG_fail;
28443   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28444   if (!SWIG_IsOK(res1)) {
28445     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_closeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
28446   }
28447   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28448   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28449   if (!SWIG_IsOK(res2)) {
28450     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_closeQuads" "', argument " "2"" of type '" "Hex::Quad *""'");
28451   }
28452   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
28453   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28454   if (!SWIG_IsOK(res3)) {
28455     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_closeQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
28456   }
28457   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
28458   result = (int)(arg1)->closeQuads(arg2,arg3);
28459   resultobj = SWIG_From_int(static_cast< int >(result));
28460   return resultobj;
28461 fail:
28462   return NULL;
28463 }
28464
28465
28466 SWIGINTERN PyObject *_wrap_Document_addLaw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28467   PyObject *resultobj = 0;
28468   Hex::Document *arg1 = (Hex::Document *) 0 ;
28469   Hex::Law *arg2 = (Hex::Law *) 0 ;
28470   Hex::Law *result = 0 ;
28471   void *argp1 = 0 ;
28472   int res1 = 0 ;
28473   void *argp2 = 0 ;
28474   int res2 = 0 ;
28475   PyObject * obj0 = 0 ;
28476   PyObject * obj1 = 0 ;
28477
28478   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaw",&obj0,&obj1)) SWIG_fail;
28479   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28480   if (!SWIG_IsOK(res1)) {
28481     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaw" "', argument " "1"" of type '" "Hex::Document *""'");
28482   }
28483   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28484   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
28485   if (!SWIG_IsOK(res2)) {
28486     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addLaw" "', argument " "2"" of type '" "Hex::Law *""'");
28487   }
28488   arg2 = reinterpret_cast< Hex::Law * >(argp2);
28489   result = (Hex::Law *)(arg1)->addLaw(arg2);
28490   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
28491   return resultobj;
28492 fail:
28493   return NULL;
28494 }
28495
28496
28497 SWIGINTERN PyObject *_wrap_Document_addLaw(PyObject *self, PyObject *args) {
28498   int argc;
28499   PyObject *argv[4];
28500   int ii;
28501
28502   if (!PyTuple_Check(args)) SWIG_fail;
28503   argc = PyObject_Length(args);
28504   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
28505     argv[ii] = PyTuple_GET_ITEM(args,ii);
28506   }
28507   if (argc == 2) {
28508     int _v;
28509     void *vptr = 0;
28510     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28511     _v = SWIG_CheckState(res);
28512     if (_v) {
28513       void *vptr = 0;
28514       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Law, 0);
28515       _v = SWIG_CheckState(res);
28516       if (_v) {
28517         return _wrap_Document_addLaw__SWIG_1(self, args);
28518       }
28519     }
28520   }
28521   if (argc == 3) {
28522     int _v;
28523     void *vptr = 0;
28524     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28525     _v = SWIG_CheckState(res);
28526     if (_v) {
28527       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
28528       _v = SWIG_CheckState(res);
28529       if (_v) {
28530         {
28531           int res = SWIG_AsVal_int(argv[2], NULL);
28532           _v = SWIG_CheckState(res);
28533         }
28534         if (_v) {
28535           return _wrap_Document_addLaw__SWIG_0(self, args);
28536         }
28537       }
28538     }
28539   }
28540
28541 fail:
28542   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Document_addLaw'.\n  Possible C/C++ prototypes are:\n    addLaw(char const *,int)\n    addLaw(Hex::Law *)\n");
28543   return NULL;
28544 }
28545
28546
28547 SWIGINTERN PyObject *_wrap_Document_checkAssociations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28548   PyObject *resultobj = 0;
28549   Hex::Document *arg1 = (Hex::Document *) 0 ;
28550   int result;
28551   void *argp1 = 0 ;
28552   int res1 = 0 ;
28553   PyObject * obj0 = 0 ;
28554
28555   if (!PyArg_ParseTuple(args,(char *)"O:Document_checkAssociations",&obj0)) SWIG_fail;
28556   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28557   if (!SWIG_IsOK(res1)) {
28558     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_checkAssociations" "', argument " "1"" of type '" "Hex::Document *""'");
28559   }
28560   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28561   result = (int)(arg1)->checkAssociations();
28562   resultobj = SWIG_From_int(static_cast< int >(result));
28563   return resultobj;
28564 fail:
28565   return NULL;
28566 }
28567
28568
28569 SWIGINTERN PyObject *_wrap_Document_addShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28570   PyObject *resultobj = 0;
28571   Hex::Document *arg1 = (Hex::Document *) 0 ;
28572   long arg2 ;
28573   char *arg3 = (char *) 0 ;
28574   Hex::NewShape *result = 0 ;
28575   void *argp1 = 0 ;
28576   int res1 = 0 ;
28577   long val2 ;
28578   int ecode2 = 0 ;
28579   int res3 ;
28580   char *buf3 = 0 ;
28581   int alloc3 = 0 ;
28582   PyObject * obj0 = 0 ;
28583   PyObject * obj1 = 0 ;
28584   PyObject * obj2 = 0 ;
28585
28586   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addShape",&obj0,&obj1,&obj2)) SWIG_fail;
28587   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28588   if (!SWIG_IsOK(res1)) {
28589     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addShape" "', argument " "1"" of type '" "Hex::Document *""'");
28590   }
28591   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28592   ecode2 = SWIG_AsVal_long(obj1, &val2);
28593   if (!SWIG_IsOK(ecode2)) {
28594     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addShape" "', argument " "2"" of type '" "long""'");
28595   }
28596   arg2 = static_cast< long >(val2);
28597   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
28598   if (!SWIG_IsOK(res3)) {
28599     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addShape" "', argument " "3"" of type '" "char const *""'");
28600   }
28601   arg3 = reinterpret_cast< char * >(buf3);
28602   result = (Hex::NewShape *)(arg1)->addShape(arg2,(char const *)arg3);
28603   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 |  0 );
28604   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
28605   return resultobj;
28606 fail:
28607   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
28608   return NULL;
28609 }
28610
28611
28612 SWIGINTERN PyObject *_wrap_delete_Document(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28613   PyObject *resultobj = 0;
28614   Hex::Document *arg1 = (Hex::Document *) 0 ;
28615   void *argp1 = 0 ;
28616   int res1 = 0 ;
28617   PyObject * obj0 = 0 ;
28618
28619   if (!PyArg_ParseTuple(args,(char *)"O:delete_Document",&obj0)) SWIG_fail;
28620   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, SWIG_POINTER_DISOWN |  0 );
28621   if (!SWIG_IsOK(res1)) {
28622     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Document" "', argument " "1"" of type '" "Hex::Document *""'");
28623   }
28624   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28625   delete arg1;
28626
28627   resultobj = SWIG_Py_Void();
28628   return resultobj;
28629 fail:
28630   return NULL;
28631 }
28632
28633
28634 SWIGINTERN PyObject *Document_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28635   PyObject *obj;
28636   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
28637   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Document, SWIG_NewClientData(obj));
28638   return SWIG_Py_Void();
28639 }
28640
28641 SWIGINTERN PyObject *_wrap_Propagation_getEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28642   PyObject *resultobj = 0;
28643   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28644   Hex::Edges *result = 0 ;
28645   void *argp1 = 0 ;
28646   int res1 = 0 ;
28647   PyObject * obj0 = 0 ;
28648
28649   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getEdges",&obj0)) SWIG_fail;
28650   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28651   if (!SWIG_IsOK(res1)) {
28652     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getEdges" "', argument " "1"" of type '" "Hex::Propagation *""'");
28653   }
28654   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28655   {
28656     Hex::Edges const &_result_ref = (arg1)->getEdges();
28657     result = (Hex::Edges *) &_result_ref;
28658   }
28659   resultobj = swig::from(static_cast< std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > >(*result));
28660   return resultobj;
28661 fail:
28662   return NULL;
28663 }
28664
28665
28666 SWIGINTERN PyObject *_wrap_Propagation_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28667   PyObject *resultobj = 0;
28668   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28669   Hex::Law *result = 0 ;
28670   void *argp1 = 0 ;
28671   int res1 = 0 ;
28672   PyObject * obj0 = 0 ;
28673
28674   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getLaw",&obj0)) SWIG_fail;
28675   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28676   if (!SWIG_IsOK(res1)) {
28677     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
28678   }
28679   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28680   result = (Hex::Law *)(arg1)->getLaw();
28681   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
28682   return resultobj;
28683 fail:
28684   return NULL;
28685 }
28686
28687
28688 SWIGINTERN PyObject *_wrap_Propagation_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28689   PyObject *resultobj = 0;
28690   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28691   bool result;
28692   void *argp1 = 0 ;
28693   int res1 = 0 ;
28694   PyObject * obj0 = 0 ;
28695
28696   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getWay",&obj0)) SWIG_fail;
28697   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28698   if (!SWIG_IsOK(res1)) {
28699     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
28700   }
28701   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28702   result = (bool)(arg1)->getWay();
28703   resultobj = SWIG_From_bool(static_cast< bool >(result));
28704   return resultobj;
28705 fail:
28706   return NULL;
28707 }
28708
28709
28710 SWIGINTERN PyObject *_wrap_Propagation_setWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28711   PyObject *resultobj = 0;
28712   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28713   bool arg2 ;
28714   void *argp1 = 0 ;
28715   int res1 = 0 ;
28716   bool val2 ;
28717   int ecode2 = 0 ;
28718   PyObject * obj0 = 0 ;
28719   PyObject * obj1 = 0 ;
28720
28721   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setWay",&obj0,&obj1)) SWIG_fail;
28722   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28723   if (!SWIG_IsOK(res1)) {
28724     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
28725   }
28726   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28727   ecode2 = SWIG_AsVal_bool(obj1, &val2);
28728   if (!SWIG_IsOK(ecode2)) {
28729     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Propagation_setWay" "', argument " "2"" of type '" "bool""'");
28730   }
28731   arg2 = static_cast< bool >(val2);
28732   (arg1)->setWay(arg2);
28733   resultobj = SWIG_Py_Void();
28734   return resultobj;
28735 fail:
28736   return NULL;
28737 }
28738
28739
28740 SWIGINTERN PyObject *_wrap_Propagation_setLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28741   PyObject *resultobj = 0;
28742   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28743   Hex::Law *arg2 = (Hex::Law *) 0 ;
28744   int result;
28745   void *argp1 = 0 ;
28746   int res1 = 0 ;
28747   void *argp2 = 0 ;
28748   int res2 = 0 ;
28749   PyObject * obj0 = 0 ;
28750   PyObject * obj1 = 0 ;
28751
28752   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setLaw",&obj0,&obj1)) SWIG_fail;
28753   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28754   if (!SWIG_IsOK(res1)) {
28755     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
28756   }
28757   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28758   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
28759   if (!SWIG_IsOK(res2)) {
28760     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_setLaw" "', argument " "2"" of type '" "Hex::Law *""'");
28761   }
28762   arg2 = reinterpret_cast< Hex::Law * >(argp2);
28763   result = (int)(arg1)->setLaw(arg2);
28764   resultobj = SWIG_From_int(static_cast< int >(result));
28765   return resultobj;
28766 fail:
28767   return NULL;
28768 }
28769
28770
28771 SWIGINTERN PyObject *_wrap_new_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28772   PyObject *resultobj = 0;
28773   Hex::Document *arg1 = (Hex::Document *) 0 ;
28774   Hex::Propagation *result = 0 ;
28775   void *argp1 = 0 ;
28776   int res1 = 0 ;
28777   PyObject * obj0 = 0 ;
28778
28779   if (!PyArg_ParseTuple(args,(char *)"O:new_Propagation",&obj0)) SWIG_fail;
28780   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28781   if (!SWIG_IsOK(res1)) {
28782     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Propagation" "', argument " "1"" of type '" "Hex::Document *""'");
28783   }
28784   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28785   result = (Hex::Propagation *)new Hex::Propagation(arg1);
28786   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_NEW |  0 );
28787   return resultobj;
28788 fail:
28789   return NULL;
28790 }
28791
28792
28793 SWIGINTERN PyObject *_wrap_Propagation_saveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28794   PyObject *resultobj = 0;
28795   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28796   Hex::XmlWriter *arg2 = (Hex::XmlWriter *) 0 ;
28797   void *argp1 = 0 ;
28798   int res1 = 0 ;
28799   void *argp2 = 0 ;
28800   int res2 = 0 ;
28801   PyObject * obj0 = 0 ;
28802   PyObject * obj1 = 0 ;
28803
28804   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_saveXml",&obj0,&obj1)) SWIG_fail;
28805   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28806   if (!SWIG_IsOK(res1)) {
28807     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_saveXml" "', argument " "1"" of type '" "Hex::Propagation *""'");
28808   }
28809   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28810   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__XmlWriter, 0 |  0 );
28811   if (!SWIG_IsOK(res2)) {
28812     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_saveXml" "', argument " "2"" of type '" "Hex::XmlWriter *""'");
28813   }
28814   arg2 = reinterpret_cast< Hex::XmlWriter * >(argp2);
28815   (arg1)->saveXml(arg2);
28816   resultobj = SWIG_Py_Void();
28817   return resultobj;
28818 fail:
28819   return NULL;
28820 }
28821
28822
28823 SWIGINTERN PyObject *_wrap_Propagation_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28824   PyObject *resultobj = 0;
28825   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28826   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28827   void *argp1 = 0 ;
28828   int res1 = 0 ;
28829   void *argp2 = 0 ;
28830   int res2 = 0 ;
28831   PyObject * obj0 = 0 ;
28832   PyObject * obj1 = 0 ;
28833
28834   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_addEdge",&obj0,&obj1)) SWIG_fail;
28835   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28836   if (!SWIG_IsOK(res1)) {
28837     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_addEdge" "', argument " "1"" of type '" "Hex::Propagation *""'");
28838   }
28839   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28840   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
28841   if (!SWIG_IsOK(res2)) {
28842     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_addEdge" "', argument " "2"" of type '" "Hex::Edge *""'");
28843   }
28844   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28845   (arg1)->addEdge(arg2);
28846   resultobj = SWIG_Py_Void();
28847   return resultobj;
28848 fail:
28849   return NULL;
28850 }
28851
28852
28853 SWIGINTERN PyObject *_wrap_Propagation_majLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28854   PyObject *resultobj = 0;
28855   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28856   void *argp1 = 0 ;
28857   int res1 = 0 ;
28858   PyObject * obj0 = 0 ;
28859
28860   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_majLaw",&obj0)) SWIG_fail;
28861   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28862   if (!SWIG_IsOK(res1)) {
28863     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_majLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
28864   }
28865   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28866   (arg1)->majLaw();
28867   resultobj = SWIG_Py_Void();
28868   return resultobj;
28869 fail:
28870   return NULL;
28871 }
28872
28873
28874 SWIGINTERN PyObject *_wrap_delete_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28875   PyObject *resultobj = 0;
28876   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28877   void *argp1 = 0 ;
28878   int res1 = 0 ;
28879   PyObject * obj0 = 0 ;
28880
28881   if (!PyArg_ParseTuple(args,(char *)"O:delete_Propagation",&obj0)) SWIG_fail;
28882   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_DISOWN |  0 );
28883   if (!SWIG_IsOK(res1)) {
28884     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Propagation" "', argument " "1"" of type '" "Hex::Propagation *""'");
28885   }
28886   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28887   delete arg1;
28888
28889   resultobj = SWIG_Py_Void();
28890   return resultobj;
28891 fail:
28892   return NULL;
28893 }
28894
28895
28896 SWIGINTERN PyObject *Propagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28897   PyObject *obj;
28898   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
28899   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Propagation, SWIG_NewClientData(obj));
28900   return SWIG_Py_Void();
28901 }
28902
28903 SWIGINTERN PyObject *_wrap_hex_instance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28904   PyObject *resultobj = 0;
28905   Hex::Hex *result = 0 ;
28906
28907   if (!PyArg_ParseTuple(args,(char *)":hex_instance")) SWIG_fail;
28908   result = (Hex::Hex *)Hex::hex_instance();
28909   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 |  0 );
28910   return resultobj;
28911 fail:
28912   return NULL;
28913 }
28914
28915
28916 SWIGINTERN PyObject *_wrap_Hex_getInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28917   PyObject *resultobj = 0;
28918   Hex::Hex *result = 0 ;
28919
28920   if (!PyArg_ParseTuple(args,(char *)":Hex_getInstance")) SWIG_fail;
28921   result = (Hex::Hex *)Hex::Hex::getInstance();
28922   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 |  0 );
28923   return resultobj;
28924 fail:
28925   return NULL;
28926 }
28927
28928
28929 SWIGINTERN PyObject *_wrap_Hex_countDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28930   PyObject *resultobj = 0;
28931   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
28932   int result;
28933   void *argp1 = 0 ;
28934   int res1 = 0 ;
28935   PyObject * obj0 = 0 ;
28936
28937   if (!PyArg_ParseTuple(args,(char *)"O:Hex_countDocument",&obj0)) SWIG_fail;
28938   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
28939   if (!SWIG_IsOK(res1)) {
28940     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_countDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
28941   }
28942   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
28943   result = (int)(arg1)->countDocument();
28944   resultobj = SWIG_From_int(static_cast< int >(result));
28945   return resultobj;
28946 fail:
28947   return NULL;
28948 }
28949
28950
28951 SWIGINTERN PyObject *_wrap_Hex_getDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28952   PyObject *resultobj = 0;
28953   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
28954   int arg2 ;
28955   Hex::Document *result = 0 ;
28956   void *argp1 = 0 ;
28957   int res1 = 0 ;
28958   int val2 ;
28959   int ecode2 = 0 ;
28960   PyObject * obj0 = 0 ;
28961   PyObject * obj1 = 0 ;
28962
28963   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getDocument",&obj0,&obj1)) SWIG_fail;
28964   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
28965   if (!SWIG_IsOK(res1)) {
28966     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
28967   }
28968   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
28969   ecode2 = SWIG_AsVal_int(obj1, &val2);
28970   if (!SWIG_IsOK(ecode2)) {
28971     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getDocument" "', argument " "2"" of type '" "int""'");
28972   }
28973   arg2 = static_cast< int >(val2);
28974   result = (Hex::Document *)(arg1)->getDocument(arg2);
28975   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
28976   return resultobj;
28977 fail:
28978   return NULL;
28979 }
28980
28981
28982 SWIGINTERN PyObject *_wrap_Hex_removeDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28983   PyObject *resultobj = 0;
28984   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
28985   Hex::Document *arg2 = (Hex::Document *) 0 ;
28986   void *argp1 = 0 ;
28987   int res1 = 0 ;
28988   void *argp2 = 0 ;
28989   int res2 = 0 ;
28990   PyObject * obj0 = 0 ;
28991   PyObject * obj1 = 0 ;
28992
28993   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_removeDocument",&obj0,&obj1)) SWIG_fail;
28994   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
28995   if (!SWIG_IsOK(res1)) {
28996     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_removeDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
28997   }
28998   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
28999   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Document, 0 |  0 );
29000   if (!SWIG_IsOK(res2)) {
29001     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_removeDocument" "', argument " "2"" of type '" "Hex::Document *""'");
29002   }
29003   arg2 = reinterpret_cast< Hex::Document * >(argp2);
29004   (arg1)->removeDocument(arg2);
29005   resultobj = SWIG_Py_Void();
29006   return resultobj;
29007 fail:
29008   return NULL;
29009 }
29010
29011
29012 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29013   PyObject *resultobj = 0;
29014   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29015   cpchar arg2 = (cpchar) 0 ;
29016   Hex::Document *result = 0 ;
29017   void *argp1 = 0 ;
29018   int res1 = 0 ;
29019   int res2 ;
29020   char *buf2 = 0 ;
29021   int alloc2 = 0 ;
29022   PyObject * obj0 = 0 ;
29023   PyObject * obj1 = 0 ;
29024
29025   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_addDocument",&obj0,&obj1)) SWIG_fail;
29026   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29027   if (!SWIG_IsOK(res1)) {
29028     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29029   }
29030   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29031   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29032   if (!SWIG_IsOK(res2)) {
29033     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_addDocument" "', argument " "2"" of type '" "cpchar""'");
29034   }
29035   arg2 = reinterpret_cast< cpchar >(buf2);
29036   result = (Hex::Document *)(arg1)->addDocument(arg2);
29037   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
29038   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29039   return resultobj;
29040 fail:
29041   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29042   return NULL;
29043 }
29044
29045
29046 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29047   PyObject *resultobj = 0;
29048   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29049   Hex::Document *result = 0 ;
29050   void *argp1 = 0 ;
29051   int res1 = 0 ;
29052   PyObject * obj0 = 0 ;
29053
29054   if (!PyArg_ParseTuple(args,(char *)"O:Hex_addDocument",&obj0)) SWIG_fail;
29055   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29056   if (!SWIG_IsOK(res1)) {
29057     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29058   }
29059   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29060   result = (Hex::Document *)(arg1)->addDocument();
29061   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
29062   return resultobj;
29063 fail:
29064   return NULL;
29065 }
29066
29067
29068 SWIGINTERN PyObject *_wrap_Hex_addDocument(PyObject *self, PyObject *args) {
29069   int argc;
29070   PyObject *argv[3];
29071   int ii;
29072
29073   if (!PyTuple_Check(args)) SWIG_fail;
29074   argc = PyObject_Length(args);
29075   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29076     argv[ii] = PyTuple_GET_ITEM(args,ii);
29077   }
29078   if (argc == 1) {
29079     int _v;
29080     void *vptr = 0;
29081     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29082     _v = SWIG_CheckState(res);
29083     if (_v) {
29084       return _wrap_Hex_addDocument__SWIG_1(self, args);
29085     }
29086   }
29087   if (argc == 2) {
29088     int _v;
29089     void *vptr = 0;
29090     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29091     _v = SWIG_CheckState(res);
29092     if (_v) {
29093       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
29094       _v = SWIG_CheckState(res);
29095       if (_v) {
29096         return _wrap_Hex_addDocument__SWIG_0(self, args);
29097       }
29098     }
29099   }
29100
29101 fail:
29102   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Hex_addDocument'.\n  Possible C/C++ prototypes are:\n    addDocument(cpchar)\n    addDocument()\n");
29103   return NULL;
29104 }
29105
29106
29107 SWIGINTERN PyObject *_wrap_Hex_loadDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108   PyObject *resultobj = 0;
29109   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29110   cpchar arg2 = (cpchar) 0 ;
29111   Hex::Document *result = 0 ;
29112   void *argp1 = 0 ;
29113   int res1 = 0 ;
29114   int res2 ;
29115   char *buf2 = 0 ;
29116   int alloc2 = 0 ;
29117   PyObject * obj0 = 0 ;
29118   PyObject * obj1 = 0 ;
29119
29120   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_loadDocument",&obj0,&obj1)) SWIG_fail;
29121   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29122   if (!SWIG_IsOK(res1)) {
29123     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_loadDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29124   }
29125   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29126   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29127   if (!SWIG_IsOK(res2)) {
29128     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_loadDocument" "', argument " "2"" of type '" "cpchar""'");
29129   }
29130   arg2 = reinterpret_cast< cpchar >(buf2);
29131   result = (Hex::Document *)(arg1)->loadDocument(arg2);
29132   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
29133   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29134   return resultobj;
29135 fail:
29136   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29137   return NULL;
29138 }
29139
29140
29141 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29142   PyObject *resultobj = 0;
29143   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29144   cpchar arg2 = (cpchar) 0 ;
29145   Hex::Document *result = 0 ;
29146   void *argp1 = 0 ;
29147   int res1 = 0 ;
29148   int res2 ;
29149   char *buf2 = 0 ;
29150   int alloc2 = 0 ;
29151   PyObject * obj0 = 0 ;
29152   PyObject * obj1 = 0 ;
29153
29154   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
29155   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29156   if (!SWIG_IsOK(res1)) {
29157     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29158   }
29159   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29160   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29161   if (!SWIG_IsOK(res2)) {
29162     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "cpchar""'");
29163   }
29164   arg2 = reinterpret_cast< cpchar >(buf2);
29165   result = (Hex::Document *)(arg1)->findDocument(arg2);
29166   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
29167   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29168   return resultobj;
29169 fail:
29170   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29171   return NULL;
29172 }
29173
29174
29175 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29176   PyObject *resultobj = 0;
29177   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29178   string *arg2 = 0 ;
29179   Hex::Document *result = 0 ;
29180   void *argp1 = 0 ;
29181   int res1 = 0 ;
29182   void *argp2 = 0 ;
29183   int res2 = 0 ;
29184   PyObject * obj0 = 0 ;
29185   PyObject * obj1 = 0 ;
29186
29187   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
29188   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29189   if (!SWIG_IsOK(res1)) {
29190     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29191   }
29192   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29193   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string,  0  | 0);
29194   if (!SWIG_IsOK(res2)) {
29195     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
29196   }
29197   if (!argp2) {
29198     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
29199   }
29200   arg2 = reinterpret_cast< string * >(argp2);
29201   result = (Hex::Document *)(arg1)->findDocument((string const &)*arg2);
29202   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
29203   return resultobj;
29204 fail:
29205   return NULL;
29206 }
29207
29208
29209 SWIGINTERN PyObject *_wrap_Hex_findDocument(PyObject *self, PyObject *args) {
29210   int argc;
29211   PyObject *argv[3];
29212   int ii;
29213
29214   if (!PyTuple_Check(args)) SWIG_fail;
29215   argc = PyObject_Length(args);
29216   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29217     argv[ii] = PyTuple_GET_ITEM(args,ii);
29218   }
29219   if (argc == 2) {
29220     int _v;
29221     void *vptr = 0;
29222     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29223     _v = SWIG_CheckState(res);
29224     if (_v) {
29225       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_string, 0);
29226       _v = SWIG_CheckState(res);
29227       if (_v) {
29228         return _wrap_Hex_findDocument__SWIG_1(self, args);
29229       }
29230     }
29231   }
29232   if (argc == 2) {
29233     int _v;
29234     void *vptr = 0;
29235     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29236     _v = SWIG_CheckState(res);
29237     if (_v) {
29238       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
29239       _v = SWIG_CheckState(res);
29240       if (_v) {
29241         return _wrap_Hex_findDocument__SWIG_0(self, args);
29242       }
29243     }
29244   }
29245
29246 fail:
29247   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Hex_findDocument'.\n  Possible C/C++ prototypes are:\n    findDocument(cpchar)\n    findDocument(string const &)\n");
29248   return NULL;
29249 }
29250
29251
29252 SWIGINTERN PyObject *_wrap_Hex_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29253   PyObject *resultobj = 0;
29254   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29255   void *argp1 = 0 ;
29256   int res1 = 0 ;
29257   PyObject * obj0 = 0 ;
29258
29259   if (!PyArg_ParseTuple(args,(char *)"O:Hex_what",&obj0)) SWIG_fail;
29260   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29261   if (!SWIG_IsOK(res1)) {
29262     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_what" "', argument " "1"" of type '" "Hex::Hex *""'");
29263   }
29264   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29265   (arg1)->what();
29266   resultobj = SWIG_Py_Void();
29267   return resultobj;
29268 fail:
29269   return NULL;
29270 }
29271
29272
29273 SWIGINTERN PyObject *_wrap_Hex_sizeofMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29274   PyObject *resultobj = 0;
29275   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29276   int result;
29277   void *argp1 = 0 ;
29278   int res1 = 0 ;
29279   PyObject * obj0 = 0 ;
29280
29281   if (!PyArg_ParseTuple(args,(char *)"O:Hex_sizeofMessage",&obj0)) SWIG_fail;
29282   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29283   if (!SWIG_IsOK(res1)) {
29284     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_sizeofMessage" "', argument " "1"" of type '" "Hex::Hex *""'");
29285   }
29286   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29287   result = (int)(arg1)->sizeofMessage();
29288   resultobj = SWIG_From_int(static_cast< int >(result));
29289   return resultobj;
29290 fail:
29291   return NULL;
29292 }
29293
29294
29295 SWIGINTERN PyObject *_wrap_Hex_getMessageLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29296   PyObject *resultobj = 0;
29297   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29298   int arg2 ;
29299   cpchar result;
29300   void *argp1 = 0 ;
29301   int res1 = 0 ;
29302   int val2 ;
29303   int ecode2 = 0 ;
29304   PyObject * obj0 = 0 ;
29305   PyObject * obj1 = 0 ;
29306
29307   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getMessageLine",&obj0,&obj1)) SWIG_fail;
29308   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29309   if (!SWIG_IsOK(res1)) {
29310     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getMessageLine" "', argument " "1"" of type '" "Hex::Hex *""'");
29311   }
29312   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29313   ecode2 = SWIG_AsVal_int(obj1, &val2);
29314   if (!SWIG_IsOK(ecode2)) {
29315     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getMessageLine" "', argument " "2"" of type '" "int""'");
29316   }
29317   arg2 = static_cast< int >(val2);
29318   result = (cpchar)(arg1)->getMessageLine(arg2);
29319   resultobj = SWIG_FromCharPtr((const char *)result);
29320   return resultobj;
29321 fail:
29322   return NULL;
29323 }
29324
29325
29326 SWIGINTERN PyObject *_wrap_new_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29327   PyObject *resultobj = 0;
29328   Hex::Hex *result = 0 ;
29329
29330   if (!PyArg_ParseTuple(args,(char *)":new_Hex")) SWIG_fail;
29331   result = (Hex::Hex *)new Hex::Hex();
29332   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, SWIG_POINTER_NEW |  0 );
29333   return resultobj;
29334 fail:
29335   return NULL;
29336 }
29337
29338
29339 SWIGINTERN PyObject *_wrap_delete_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29340   PyObject *resultobj = 0;
29341   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29342   void *argp1 = 0 ;
29343   int res1 = 0 ;
29344   PyObject * obj0 = 0 ;
29345
29346   if (!PyArg_ParseTuple(args,(char *)"O:delete_Hex",&obj0)) SWIG_fail;
29347   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, SWIG_POINTER_DISOWN |  0 );
29348   if (!SWIG_IsOK(res1)) {
29349     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hex" "', argument " "1"" of type '" "Hex::Hex *""'");
29350   }
29351   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29352   delete arg1;
29353
29354   resultobj = SWIG_Py_Void();
29355   return resultobj;
29356 fail:
29357   return NULL;
29358 }
29359
29360
29361 SWIGINTERN PyObject *Hex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29362   PyObject *obj;
29363   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
29364   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hex, SWIG_NewClientData(obj));
29365   return SWIG_Py_Void();
29366 }
29367
29368 SWIGINTERN PyObject *_wrap_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29369   PyObject *resultobj = 0;
29370
29371   if (!PyArg_ParseTuple(args,(char *)":what")) SWIG_fail;
29372   Hex::what();
29373   resultobj = SWIG_Py_Void();
29374   return resultobj;
29375 fail:
29376   return NULL;
29377 }
29378
29379
29380 SWIGINTERN PyObject *_wrap_Elements_getHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29381   PyObject *resultobj = 0;
29382   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29383   int arg2 ;
29384   Hex::Hexa *result = 0 ;
29385   void *argp1 = 0 ;
29386   int res1 = 0 ;
29387   int val2 ;
29388   int ecode2 = 0 ;
29389   PyObject * obj0 = 0 ;
29390   PyObject * obj1 = 0 ;
29391
29392   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getHexa",&obj0,&obj1)) SWIG_fail;
29393   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29394   if (!SWIG_IsOK(res1)) {
29395     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
29396   }
29397   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29398   ecode2 = SWIG_AsVal_int(obj1, &val2);
29399   if (!SWIG_IsOK(ecode2)) {
29400     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexa" "', argument " "2"" of type '" "int""'");
29401   }
29402   arg2 = static_cast< int >(val2);
29403   result = (Hex::Hexa *)(arg1)->getHexa(arg2);
29404   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
29405   return resultobj;
29406 fail:
29407   return NULL;
29408 }
29409
29410
29411 SWIGINTERN PyObject *_wrap_Elements_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29412   PyObject *resultobj = 0;
29413   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29414   int arg2 ;
29415   Hex::Quad *result = 0 ;
29416   void *argp1 = 0 ;
29417   int res1 = 0 ;
29418   int val2 ;
29419   int ecode2 = 0 ;
29420   PyObject * obj0 = 0 ;
29421   PyObject * obj1 = 0 ;
29422
29423   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getQuad",&obj0,&obj1)) SWIG_fail;
29424   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29425   if (!SWIG_IsOK(res1)) {
29426     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
29427   }
29428   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29429   ecode2 = SWIG_AsVal_int(obj1, &val2);
29430   if (!SWIG_IsOK(ecode2)) {
29431     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuad" "', argument " "2"" of type '" "int""'");
29432   }
29433   arg2 = static_cast< int >(val2);
29434   result = (Hex::Quad *)(arg1)->getQuad(arg2);
29435   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
29436   return resultobj;
29437 fail:
29438   return NULL;
29439 }
29440
29441
29442 SWIGINTERN PyObject *_wrap_Elements_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29443   PyObject *resultobj = 0;
29444   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29445   int arg2 ;
29446   Hex::Edge *result = 0 ;
29447   void *argp1 = 0 ;
29448   int res1 = 0 ;
29449   int val2 ;
29450   int ecode2 = 0 ;
29451   PyObject * obj0 = 0 ;
29452   PyObject * obj1 = 0 ;
29453
29454   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getEdge",&obj0,&obj1)) SWIG_fail;
29455   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29456   if (!SWIG_IsOK(res1)) {
29457     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
29458   }
29459   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29460   ecode2 = SWIG_AsVal_int(obj1, &val2);
29461   if (!SWIG_IsOK(ecode2)) {
29462     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdge" "', argument " "2"" of type '" "int""'");
29463   }
29464   arg2 = static_cast< int >(val2);
29465   result = (Hex::Edge *)(arg1)->getEdge(arg2);
29466   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
29467   return resultobj;
29468 fail:
29469   return NULL;
29470 }
29471
29472
29473 SWIGINTERN PyObject *_wrap_Elements_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29474   PyObject *resultobj = 0;
29475   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29476   int arg2 ;
29477   Hex::Vertex *result = 0 ;
29478   void *argp1 = 0 ;
29479   int res1 = 0 ;
29480   int val2 ;
29481   int ecode2 = 0 ;
29482   PyObject * obj0 = 0 ;
29483   PyObject * obj1 = 0 ;
29484
29485   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getVertex",&obj0,&obj1)) SWIG_fail;
29486   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29487   if (!SWIG_IsOK(res1)) {
29488     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
29489   }
29490   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29491   ecode2 = SWIG_AsVal_int(obj1, &val2);
29492   if (!SWIG_IsOK(ecode2)) {
29493     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertex" "', argument " "2"" of type '" "int""'");
29494   }
29495   arg2 = static_cast< int >(val2);
29496   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
29497   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29498   return resultobj;
29499 fail:
29500   return NULL;
29501 }
29502
29503
29504 SWIGINTERN PyObject *_wrap_Elements_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29505   PyObject *resultobj = 0;
29506   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29507   int arg2 ;
29508   int arg3 ;
29509   int arg4 ;
29510   Hex::Hexa *result = 0 ;
29511   void *argp1 = 0 ;
29512   int res1 = 0 ;
29513   int val2 ;
29514   int ecode2 = 0 ;
29515   int val3 ;
29516   int ecode3 = 0 ;
29517   int val4 ;
29518   int ecode4 = 0 ;
29519   PyObject * obj0 = 0 ;
29520   PyObject * obj1 = 0 ;
29521   PyObject * obj2 = 0 ;
29522   PyObject * obj3 = 0 ;
29523
29524   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getHexaIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29525   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29526   if (!SWIG_IsOK(res1)) {
29527     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexaIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
29528   }
29529   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29530   ecode2 = SWIG_AsVal_int(obj1, &val2);
29531   if (!SWIG_IsOK(ecode2)) {
29532     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexaIJK" "', argument " "2"" of type '" "int""'");
29533   }
29534   arg2 = static_cast< int >(val2);
29535   ecode3 = SWIG_AsVal_int(obj2, &val3);
29536   if (!SWIG_IsOK(ecode3)) {
29537     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getHexaIJK" "', argument " "3"" of type '" "int""'");
29538   }
29539   arg3 = static_cast< int >(val3);
29540   ecode4 = SWIG_AsVal_int(obj3, &val4);
29541   if (!SWIG_IsOK(ecode4)) {
29542     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getHexaIJK" "', argument " "4"" of type '" "int""'");
29543   }
29544   arg4 = static_cast< int >(val4);
29545   result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4);
29546   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
29547   return resultobj;
29548 fail:
29549   return NULL;
29550 }
29551
29552
29553 SWIGINTERN PyObject *_wrap_Elements_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29554   PyObject *resultobj = 0;
29555   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29556   int arg2 ;
29557   int arg3 ;
29558   int arg4 ;
29559   Hex::Quad *result = 0 ;
29560   void *argp1 = 0 ;
29561   int res1 = 0 ;
29562   int val2 ;
29563   int ecode2 = 0 ;
29564   int val3 ;
29565   int ecode3 = 0 ;
29566   int val4 ;
29567   int ecode4 = 0 ;
29568   PyObject * obj0 = 0 ;
29569   PyObject * obj1 = 0 ;
29570   PyObject * obj2 = 0 ;
29571   PyObject * obj3 = 0 ;
29572
29573   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29574   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29575   if (!SWIG_IsOK(res1)) {
29576     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIJ" "', argument " "1"" of type '" "Hex::Elements *""'");
29577   }
29578   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29579   ecode2 = SWIG_AsVal_int(obj1, &val2);
29580   if (!SWIG_IsOK(ecode2)) {
29581     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIJ" "', argument " "2"" of type '" "int""'");
29582   }
29583   arg2 = static_cast< int >(val2);
29584   ecode3 = SWIG_AsVal_int(obj2, &val3);
29585   if (!SWIG_IsOK(ecode3)) {
29586     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIJ" "', argument " "3"" of type '" "int""'");
29587   }
29588   arg3 = static_cast< int >(val3);
29589   ecode4 = SWIG_AsVal_int(obj3, &val4);
29590   if (!SWIG_IsOK(ecode4)) {
29591     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIJ" "', argument " "4"" of type '" "int""'");
29592   }
29593   arg4 = static_cast< int >(val4);
29594   result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4);
29595   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
29596   return resultobj;
29597 fail:
29598   return NULL;
29599 }
29600
29601
29602 SWIGINTERN PyObject *_wrap_Elements_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29603   PyObject *resultobj = 0;
29604   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29605   int arg2 ;
29606   int arg3 ;
29607   int arg4 ;
29608   Hex::Quad *result = 0 ;
29609   void *argp1 = 0 ;
29610   int res1 = 0 ;
29611   int val2 ;
29612   int ecode2 = 0 ;
29613   int val3 ;
29614   int ecode3 = 0 ;
29615   int val4 ;
29616   int ecode4 = 0 ;
29617   PyObject * obj0 = 0 ;
29618   PyObject * obj1 = 0 ;
29619   PyObject * obj2 = 0 ;
29620   PyObject * obj3 = 0 ;
29621
29622   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29623   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29624   if (!SWIG_IsOK(res1)) {
29625     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadJK" "', argument " "1"" of type '" "Hex::Elements *""'");
29626   }
29627   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29628   ecode2 = SWIG_AsVal_int(obj1, &val2);
29629   if (!SWIG_IsOK(ecode2)) {
29630     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadJK" "', argument " "2"" of type '" "int""'");
29631   }
29632   arg2 = static_cast< int >(val2);
29633   ecode3 = SWIG_AsVal_int(obj2, &val3);
29634   if (!SWIG_IsOK(ecode3)) {
29635     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadJK" "', argument " "3"" of type '" "int""'");
29636   }
29637   arg3 = static_cast< int >(val3);
29638   ecode4 = SWIG_AsVal_int(obj3, &val4);
29639   if (!SWIG_IsOK(ecode4)) {
29640     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadJK" "', argument " "4"" of type '" "int""'");
29641   }
29642   arg4 = static_cast< int >(val4);
29643   result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4);
29644   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
29645   return resultobj;
29646 fail:
29647   return NULL;
29648 }
29649
29650
29651 SWIGINTERN PyObject *_wrap_Elements_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29652   PyObject *resultobj = 0;
29653   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29654   int arg2 ;
29655   int arg3 ;
29656   int arg4 ;
29657   Hex::Quad *result = 0 ;
29658   void *argp1 = 0 ;
29659   int res1 = 0 ;
29660   int val2 ;
29661   int ecode2 = 0 ;
29662   int val3 ;
29663   int ecode3 = 0 ;
29664   int val4 ;
29665   int ecode4 = 0 ;
29666   PyObject * obj0 = 0 ;
29667   PyObject * obj1 = 0 ;
29668   PyObject * obj2 = 0 ;
29669   PyObject * obj3 = 0 ;
29670
29671   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29672   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29673   if (!SWIG_IsOK(res1)) {
29674     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIK" "', argument " "1"" of type '" "Hex::Elements *""'");
29675   }
29676   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29677   ecode2 = SWIG_AsVal_int(obj1, &val2);
29678   if (!SWIG_IsOK(ecode2)) {
29679     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIK" "', argument " "2"" of type '" "int""'");
29680   }
29681   arg2 = static_cast< int >(val2);
29682   ecode3 = SWIG_AsVal_int(obj2, &val3);
29683   if (!SWIG_IsOK(ecode3)) {
29684     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIK" "', argument " "3"" of type '" "int""'");
29685   }
29686   arg3 = static_cast< int >(val3);
29687   ecode4 = SWIG_AsVal_int(obj3, &val4);
29688   if (!SWIG_IsOK(ecode4)) {
29689     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIK" "', argument " "4"" of type '" "int""'");
29690   }
29691   arg4 = static_cast< int >(val4);
29692   result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4);
29693   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
29694   return resultobj;
29695 fail:
29696   return NULL;
29697 }
29698
29699
29700 SWIGINTERN PyObject *_wrap_Elements_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29701   PyObject *resultobj = 0;
29702   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29703   int arg2 ;
29704   int arg3 ;
29705   int arg4 ;
29706   Hex::Edge *result = 0 ;
29707   void *argp1 = 0 ;
29708   int res1 = 0 ;
29709   int val2 ;
29710   int ecode2 = 0 ;
29711   int val3 ;
29712   int ecode3 = 0 ;
29713   int val4 ;
29714   int ecode4 = 0 ;
29715   PyObject * obj0 = 0 ;
29716   PyObject * obj1 = 0 ;
29717   PyObject * obj2 = 0 ;
29718   PyObject * obj3 = 0 ;
29719
29720   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeI",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29721   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29722   if (!SWIG_IsOK(res1)) {
29723     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeI" "', argument " "1"" of type '" "Hex::Elements *""'");
29724   }
29725   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29726   ecode2 = SWIG_AsVal_int(obj1, &val2);
29727   if (!SWIG_IsOK(ecode2)) {
29728     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeI" "', argument " "2"" of type '" "int""'");
29729   }
29730   arg2 = static_cast< int >(val2);
29731   ecode3 = SWIG_AsVal_int(obj2, &val3);
29732   if (!SWIG_IsOK(ecode3)) {
29733     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeI" "', argument " "3"" of type '" "int""'");
29734   }
29735   arg3 = static_cast< int >(val3);
29736   ecode4 = SWIG_AsVal_int(obj3, &val4);
29737   if (!SWIG_IsOK(ecode4)) {
29738     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeI" "', argument " "4"" of type '" "int""'");
29739   }
29740   arg4 = static_cast< int >(val4);
29741   result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4);
29742   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
29743   return resultobj;
29744 fail:
29745   return NULL;
29746 }
29747
29748
29749 SWIGINTERN PyObject *_wrap_Elements_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29750   PyObject *resultobj = 0;
29751   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29752   int arg2 ;
29753   int arg3 ;
29754   int arg4 ;
29755   Hex::Edge *result = 0 ;
29756   void *argp1 = 0 ;
29757   int res1 = 0 ;
29758   int val2 ;
29759   int ecode2 = 0 ;
29760   int val3 ;
29761   int ecode3 = 0 ;
29762   int val4 ;
29763   int ecode4 = 0 ;
29764   PyObject * obj0 = 0 ;
29765   PyObject * obj1 = 0 ;
29766   PyObject * obj2 = 0 ;
29767   PyObject * obj3 = 0 ;
29768
29769   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29770   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29771   if (!SWIG_IsOK(res1)) {
29772     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeJ" "', argument " "1"" of type '" "Hex::Elements *""'");
29773   }
29774   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29775   ecode2 = SWIG_AsVal_int(obj1, &val2);
29776   if (!SWIG_IsOK(ecode2)) {
29777     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeJ" "', argument " "2"" of type '" "int""'");
29778   }
29779   arg2 = static_cast< int >(val2);
29780   ecode3 = SWIG_AsVal_int(obj2, &val3);
29781   if (!SWIG_IsOK(ecode3)) {
29782     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeJ" "', argument " "3"" of type '" "int""'");
29783   }
29784   arg3 = static_cast< int >(val3);
29785   ecode4 = SWIG_AsVal_int(obj3, &val4);
29786   if (!SWIG_IsOK(ecode4)) {
29787     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeJ" "', argument " "4"" of type '" "int""'");
29788   }
29789   arg4 = static_cast< int >(val4);
29790   result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4);
29791   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
29792   return resultobj;
29793 fail:
29794   return NULL;
29795 }
29796
29797
29798 SWIGINTERN PyObject *_wrap_Elements_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29799   PyObject *resultobj = 0;
29800   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29801   int arg2 ;
29802   int arg3 ;
29803   int arg4 ;
29804   Hex::Edge *result = 0 ;
29805   void *argp1 = 0 ;
29806   int res1 = 0 ;
29807   int val2 ;
29808   int ecode2 = 0 ;
29809   int val3 ;
29810   int ecode3 = 0 ;
29811   int val4 ;
29812   int ecode4 = 0 ;
29813   PyObject * obj0 = 0 ;
29814   PyObject * obj1 = 0 ;
29815   PyObject * obj2 = 0 ;
29816   PyObject * obj3 = 0 ;
29817
29818   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29819   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29820   if (!SWIG_IsOK(res1)) {
29821     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeK" "', argument " "1"" of type '" "Hex::Elements *""'");
29822   }
29823   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29824   ecode2 = SWIG_AsVal_int(obj1, &val2);
29825   if (!SWIG_IsOK(ecode2)) {
29826     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeK" "', argument " "2"" of type '" "int""'");
29827   }
29828   arg2 = static_cast< int >(val2);
29829   ecode3 = SWIG_AsVal_int(obj2, &val3);
29830   if (!SWIG_IsOK(ecode3)) {
29831     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeK" "', argument " "3"" of type '" "int""'");
29832   }
29833   arg3 = static_cast< int >(val3);
29834   ecode4 = SWIG_AsVal_int(obj3, &val4);
29835   if (!SWIG_IsOK(ecode4)) {
29836     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeK" "', argument " "4"" of type '" "int""'");
29837   }
29838   arg4 = static_cast< int >(val4);
29839   result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4);
29840   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
29841   return resultobj;
29842 fail:
29843   return NULL;
29844 }
29845
29846
29847 SWIGINTERN PyObject *_wrap_Elements_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29848   PyObject *resultobj = 0;
29849   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29850   int arg2 ;
29851   int arg3 ;
29852   int arg4 ;
29853   Hex::Vertex *result = 0 ;
29854   void *argp1 = 0 ;
29855   int res1 = 0 ;
29856   int val2 ;
29857   int ecode2 = 0 ;
29858   int val3 ;
29859   int ecode3 = 0 ;
29860   int val4 ;
29861   int ecode4 = 0 ;
29862   PyObject * obj0 = 0 ;
29863   PyObject * obj1 = 0 ;
29864   PyObject * obj2 = 0 ;
29865   PyObject * obj3 = 0 ;
29866
29867   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getVertexIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29868   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29869   if (!SWIG_IsOK(res1)) {
29870     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertexIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
29871   }
29872   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29873   ecode2 = SWIG_AsVal_int(obj1, &val2);
29874   if (!SWIG_IsOK(ecode2)) {
29875     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertexIJK" "', argument " "2"" of type '" "int""'");
29876   }
29877   arg2 = static_cast< int >(val2);
29878   ecode3 = SWIG_AsVal_int(obj2, &val3);
29879   if (!SWIG_IsOK(ecode3)) {
29880     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getVertexIJK" "', argument " "3"" of type '" "int""'");
29881   }
29882   arg3 = static_cast< int >(val3);
29883   ecode4 = SWIG_AsVal_int(obj3, &val4);
29884   if (!SWIG_IsOK(ecode4)) {
29885     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getVertexIJK" "', argument " "4"" of type '" "int""'");
29886   }
29887   arg4 = static_cast< int >(val4);
29888   result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4);
29889   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29890   return resultobj;
29891 fail:
29892   return NULL;
29893 }
29894
29895
29896 SWIGINTERN PyObject *_wrap_Elements_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29897   PyObject *resultobj = 0;
29898   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29899   int result;
29900   void *argp1 = 0 ;
29901   int res1 = 0 ;
29902   PyObject * obj0 = 0 ;
29903
29904   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countHexa",&obj0)) SWIG_fail;
29905   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29906   if (!SWIG_IsOK(res1)) {
29907     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
29908   }
29909   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29910   result = (int)(arg1)->countHexa();
29911   resultobj = SWIG_From_int(static_cast< int >(result));
29912   return resultobj;
29913 fail:
29914   return NULL;
29915 }
29916
29917
29918 SWIGINTERN PyObject *_wrap_Elements_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29919   PyObject *resultobj = 0;
29920   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29921   int result;
29922   void *argp1 = 0 ;
29923   int res1 = 0 ;
29924   PyObject * obj0 = 0 ;
29925
29926   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countQuad",&obj0)) SWIG_fail;
29927   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29928   if (!SWIG_IsOK(res1)) {
29929     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
29930   }
29931   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29932   result = (int)(arg1)->countQuad();
29933   resultobj = SWIG_From_int(static_cast< int >(result));
29934   return resultobj;
29935 fail:
29936   return NULL;
29937 }
29938
29939
29940 SWIGINTERN PyObject *_wrap_Elements_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29941   PyObject *resultobj = 0;
29942   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29943   int result;
29944   void *argp1 = 0 ;
29945   int res1 = 0 ;
29946   PyObject * obj0 = 0 ;
29947
29948   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countEdge",&obj0)) SWIG_fail;
29949   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29950   if (!SWIG_IsOK(res1)) {
29951     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
29952   }
29953   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29954   result = (int)(arg1)->countEdge();
29955   resultobj = SWIG_From_int(static_cast< int >(result));
29956   return resultobj;
29957 fail:
29958   return NULL;
29959 }
29960
29961
29962 SWIGINTERN PyObject *_wrap_Elements_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29963   PyObject *resultobj = 0;
29964   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29965   int result;
29966   void *argp1 = 0 ;
29967   int res1 = 0 ;
29968   PyObject * obj0 = 0 ;
29969
29970   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countVertex",&obj0)) SWIG_fail;
29971   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29972   if (!SWIG_IsOK(res1)) {
29973     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
29974   }
29975   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29976   result = (int)(arg1)->countVertex();
29977   resultobj = SWIG_From_int(static_cast< int >(result));
29978   return resultobj;
29979 fail:
29980   return NULL;
29981 }
29982
29983
29984 SWIGINTERN PyObject *_wrap_Elements_nearestVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29985   PyObject *resultobj = 0;
29986   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29987   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29988   Hex::Vertex *result = 0 ;
29989   void *argp1 = 0 ;
29990   int res1 = 0 ;
29991   void *argp2 = 0 ;
29992   int res2 = 0 ;
29993   PyObject * obj0 = 0 ;
29994   PyObject * obj1 = 0 ;
29995
29996   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_nearestVertex",&obj0,&obj1)) SWIG_fail;
29997   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29998   if (!SWIG_IsOK(res1)) {
29999     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_nearestVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
30000   }
30001   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30002   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30003   if (!SWIG_IsOK(res2)) {
30004     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_nearestVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
30005   }
30006   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30007   result = (Hex::Vertex *)(arg1)->nearestVertex(arg2);
30008   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30009   return resultobj;
30010 fail:
30011   return NULL;
30012 }
30013
30014
30015 SWIGINTERN PyObject *_wrap_Elements_findVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30016   PyObject *resultobj = 0;
30017   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30018   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30019   int result;
30020   void *argp1 = 0 ;
30021   int res1 = 0 ;
30022   void *argp2 = 0 ;
30023   int res2 = 0 ;
30024   PyObject * obj0 = 0 ;
30025   PyObject * obj1 = 0 ;
30026
30027   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_findVertex",&obj0,&obj1)) SWIG_fail;
30028   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30029   if (!SWIG_IsOK(res1)) {
30030     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_findVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
30031   }
30032   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30033   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30034   if (!SWIG_IsOK(res2)) {
30035     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_findVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
30036   }
30037   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30038   result = (int)(arg1)->findVertex(arg2);
30039   resultobj = SWIG_From_int(static_cast< int >(result));
30040   return resultobj;
30041 fail:
30042   return NULL;
30043 }
30044
30045
30046 SWIGINTERN PyObject *_wrap_Elements_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30047   PyObject *resultobj = 0;
30048   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30049   void *argp1 = 0 ;
30050   int res1 = 0 ;
30051   PyObject * obj0 = 0 ;
30052
30053   if (!PyArg_ParseTuple(args,(char *)"O:Elements_clearAssociation",&obj0)) SWIG_fail;
30054   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30055   if (!SWIG_IsOK(res1)) {
30056     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_clearAssociation" "', argument " "1"" of type '" "Hex::Elements *""'");
30057   }
30058   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30059   (arg1)->clearAssociation();
30060   resultobj = SWIG_Py_Void();
30061   return resultobj;
30062 fail:
30063   return NULL;
30064 }
30065
30066
30067 SWIGINTERN PyObject *_wrap_Elements_saveVtk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30068   PyObject *resultobj = 0;
30069   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30070   cpchar arg2 = (cpchar) 0 ;
30071   int result;
30072   void *argp1 = 0 ;
30073   int res1 = 0 ;
30074   int res2 ;
30075   char *buf2 = 0 ;
30076   int alloc2 = 0 ;
30077   PyObject * obj0 = 0 ;
30078   PyObject * obj1 = 0 ;
30079
30080   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_saveVtk",&obj0,&obj1)) SWIG_fail;
30081   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30082   if (!SWIG_IsOK(res1)) {
30083     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_saveVtk" "', argument " "1"" of type '" "Hex::Elements *""'");
30084   }
30085   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30086   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30087   if (!SWIG_IsOK(res2)) {
30088     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_saveVtk" "', argument " "2"" of type '" "cpchar""'");
30089   }
30090   arg2 = reinterpret_cast< cpchar >(buf2);
30091   result = (int)(arg1)->saveVtk(arg2);
30092   resultobj = SWIG_From_int(static_cast< int >(result));
30093   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30094   return resultobj;
30095 fail:
30096   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30097   return NULL;
30098 }
30099
30100
30101 SWIGINTERN PyObject *_wrap_new_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30102   PyObject *resultobj = 0;
30103   Hex::Document *arg1 = (Hex::Document *) 0 ;
30104   Hex::Elements *result = 0 ;
30105   void *argp1 = 0 ;
30106   int res1 = 0 ;
30107   PyObject * obj0 = 0 ;
30108
30109   if (!PyArg_ParseTuple(args,(char *)"O:new_Elements",&obj0)) SWIG_fail;
30110   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30111   if (!SWIG_IsOK(res1)) {
30112     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Elements" "', argument " "1"" of type '" "Hex::Document *""'");
30113   }
30114   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30115   result = (Hex::Elements *)new Hex::Elements(arg1);
30116   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, SWIG_POINTER_NEW |  0 );
30117   return resultobj;
30118 fail:
30119   return NULL;
30120 }
30121
30122
30123 SWIGINTERN PyObject *_wrap_delete_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30124   PyObject *resultobj = 0;
30125   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30126   void *argp1 = 0 ;
30127   int res1 = 0 ;
30128   PyObject * obj0 = 0 ;
30129
30130   if (!PyArg_ParseTuple(args,(char *)"O:delete_Elements",&obj0)) SWIG_fail;
30131   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, SWIG_POINTER_DISOWN |  0 );
30132   if (!SWIG_IsOK(res1)) {
30133     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Elements" "', argument " "1"" of type '" "Hex::Elements *""'");
30134   }
30135   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30136   delete arg1;
30137
30138   resultobj = SWIG_Py_Void();
30139   return resultobj;
30140 fail:
30141   return NULL;
30142 }
30143
30144
30145 SWIGINTERN PyObject *Elements_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30146   PyObject *obj;
30147   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
30148   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Elements, SWIG_NewClientData(obj));
30149   return SWIG_Py_Void();
30150 }
30151
30152 SWIGINTERN PyObject *_wrap_new_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30153   PyObject *resultobj = 0;
30154   Hex::Document *arg1 = (Hex::Document *) 0 ;
30155   Hex::BiCylinder *result = 0 ;
30156   void *argp1 = 0 ;
30157   int res1 = 0 ;
30158   PyObject * obj0 = 0 ;
30159
30160   if (!PyArg_ParseTuple(args,(char *)"O:new_BiCylinder",&obj0)) SWIG_fail;
30161   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30162   if (!SWIG_IsOK(res1)) {
30163     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BiCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
30164   }
30165   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30166   result = (Hex::BiCylinder *)new Hex::BiCylinder(arg1);
30167   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_NEW |  0 );
30168   return resultobj;
30169 fail:
30170   return NULL;
30171 }
30172
30173
30174 SWIGINTERN PyObject *_wrap_BiCylinder_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30175   PyObject *resultobj = 0;
30176   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30177   int arg2 ;
30178   int arg3 ;
30179   int arg4 ;
30180   int arg5 ;
30181   Hex::Hexa *result = 0 ;
30182   void *argp1 = 0 ;
30183   int res1 = 0 ;
30184   int val2 ;
30185   int ecode2 = 0 ;
30186   int val3 ;
30187   int ecode3 = 0 ;
30188   int val4 ;
30189   int ecode4 = 0 ;
30190   int val5 ;
30191   int ecode5 = 0 ;
30192   PyObject * obj0 = 0 ;
30193   PyObject * obj1 = 0 ;
30194   PyObject * obj2 = 0 ;
30195   PyObject * obj3 = 0 ;
30196   PyObject * obj4 = 0 ;
30197
30198   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getHexaIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30199   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30200   if (!SWIG_IsOK(res1)) {
30201     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getHexaIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30202   }
30203   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30204   ecode2 = SWIG_AsVal_int(obj1, &val2);
30205   if (!SWIG_IsOK(ecode2)) {
30206     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getHexaIJK" "', argument " "2"" of type '" "int""'");
30207   }
30208   arg2 = static_cast< int >(val2);
30209   ecode3 = SWIG_AsVal_int(obj2, &val3);
30210   if (!SWIG_IsOK(ecode3)) {
30211     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getHexaIJK" "', argument " "3"" of type '" "int""'");
30212   }
30213   arg3 = static_cast< int >(val3);
30214   ecode4 = SWIG_AsVal_int(obj3, &val4);
30215   if (!SWIG_IsOK(ecode4)) {
30216     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getHexaIJK" "', argument " "4"" of type '" "int""'");
30217   }
30218   arg4 = static_cast< int >(val4);
30219   ecode5 = SWIG_AsVal_int(obj4, &val5);
30220   if (!SWIG_IsOK(ecode5)) {
30221     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getHexaIJK" "', argument " "5"" of type '" "int""'");
30222   }
30223   arg5 = static_cast< int >(val5);
30224   result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4,arg5);
30225   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
30226   return resultobj;
30227 fail:
30228   return NULL;
30229 }
30230
30231
30232 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30233   PyObject *resultobj = 0;
30234   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30235   int arg2 ;
30236   int arg3 ;
30237   int arg4 ;
30238   int arg5 ;
30239   Hex::Quad *result = 0 ;
30240   void *argp1 = 0 ;
30241   int res1 = 0 ;
30242   int val2 ;
30243   int ecode2 = 0 ;
30244   int val3 ;
30245   int ecode3 = 0 ;
30246   int val4 ;
30247   int ecode4 = 0 ;
30248   int val5 ;
30249   int ecode5 = 0 ;
30250   PyObject * obj0 = 0 ;
30251   PyObject * obj1 = 0 ;
30252   PyObject * obj2 = 0 ;
30253   PyObject * obj3 = 0 ;
30254   PyObject * obj4 = 0 ;
30255
30256   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30257   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30258   if (!SWIG_IsOK(res1)) {
30259     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30260   }
30261   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30262   ecode2 = SWIG_AsVal_int(obj1, &val2);
30263   if (!SWIG_IsOK(ecode2)) {
30264     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIJ" "', argument " "2"" of type '" "int""'");
30265   }
30266   arg2 = static_cast< int >(val2);
30267   ecode3 = SWIG_AsVal_int(obj2, &val3);
30268   if (!SWIG_IsOK(ecode3)) {
30269     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIJ" "', argument " "3"" of type '" "int""'");
30270   }
30271   arg3 = static_cast< int >(val3);
30272   ecode4 = SWIG_AsVal_int(obj3, &val4);
30273   if (!SWIG_IsOK(ecode4)) {
30274     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIJ" "', argument " "4"" of type '" "int""'");
30275   }
30276   arg4 = static_cast< int >(val4);
30277   ecode5 = SWIG_AsVal_int(obj4, &val5);
30278   if (!SWIG_IsOK(ecode5)) {
30279     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIJ" "', argument " "5"" of type '" "int""'");
30280   }
30281   arg5 = static_cast< int >(val5);
30282   result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4,arg5);
30283   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
30284   return resultobj;
30285 fail:
30286   return NULL;
30287 }
30288
30289
30290 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30291   PyObject *resultobj = 0;
30292   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30293   int arg2 ;
30294   int arg3 ;
30295   int arg4 ;
30296   int arg5 ;
30297   Hex::Quad *result = 0 ;
30298   void *argp1 = 0 ;
30299   int res1 = 0 ;
30300   int val2 ;
30301   int ecode2 = 0 ;
30302   int val3 ;
30303   int ecode3 = 0 ;
30304   int val4 ;
30305   int ecode4 = 0 ;
30306   int val5 ;
30307   int ecode5 = 0 ;
30308   PyObject * obj0 = 0 ;
30309   PyObject * obj1 = 0 ;
30310   PyObject * obj2 = 0 ;
30311   PyObject * obj3 = 0 ;
30312   PyObject * obj4 = 0 ;
30313
30314   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30315   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30316   if (!SWIG_IsOK(res1)) {
30317     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30318   }
30319   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30320   ecode2 = SWIG_AsVal_int(obj1, &val2);
30321   if (!SWIG_IsOK(ecode2)) {
30322     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadJK" "', argument " "2"" of type '" "int""'");
30323   }
30324   arg2 = static_cast< int >(val2);
30325   ecode3 = SWIG_AsVal_int(obj2, &val3);
30326   if (!SWIG_IsOK(ecode3)) {
30327     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadJK" "', argument " "3"" of type '" "int""'");
30328   }
30329   arg3 = static_cast< int >(val3);
30330   ecode4 = SWIG_AsVal_int(obj3, &val4);
30331   if (!SWIG_IsOK(ecode4)) {
30332     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadJK" "', argument " "4"" of type '" "int""'");
30333   }
30334   arg4 = static_cast< int >(val4);
30335   ecode5 = SWIG_AsVal_int(obj4, &val5);
30336   if (!SWIG_IsOK(ecode5)) {
30337     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadJK" "', argument " "5"" of type '" "int""'");
30338   }
30339   arg5 = static_cast< int >(val5);
30340   result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4,arg5);
30341   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
30342   return resultobj;
30343 fail:
30344   return NULL;
30345 }
30346
30347
30348 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30349   PyObject *resultobj = 0;
30350   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30351   int arg2 ;
30352   int arg3 ;
30353   int arg4 ;
30354   int arg5 ;
30355   Hex::Quad *result = 0 ;
30356   void *argp1 = 0 ;
30357   int res1 = 0 ;
30358   int val2 ;
30359   int ecode2 = 0 ;
30360   int val3 ;
30361   int ecode3 = 0 ;
30362   int val4 ;
30363   int ecode4 = 0 ;
30364   int val5 ;
30365   int ecode5 = 0 ;
30366   PyObject * obj0 = 0 ;
30367   PyObject * obj1 = 0 ;
30368   PyObject * obj2 = 0 ;
30369   PyObject * obj3 = 0 ;
30370   PyObject * obj4 = 0 ;
30371
30372   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30373   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30374   if (!SWIG_IsOK(res1)) {
30375     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30376   }
30377   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30378   ecode2 = SWIG_AsVal_int(obj1, &val2);
30379   if (!SWIG_IsOK(ecode2)) {
30380     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIK" "', argument " "2"" of type '" "int""'");
30381   }
30382   arg2 = static_cast< int >(val2);
30383   ecode3 = SWIG_AsVal_int(obj2, &val3);
30384   if (!SWIG_IsOK(ecode3)) {
30385     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIK" "', argument " "3"" of type '" "int""'");
30386   }
30387   arg3 = static_cast< int >(val3);
30388   ecode4 = SWIG_AsVal_int(obj3, &val4);
30389   if (!SWIG_IsOK(ecode4)) {
30390     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIK" "', argument " "4"" of type '" "int""'");
30391   }
30392   arg4 = static_cast< int >(val4);
30393   ecode5 = SWIG_AsVal_int(obj4, &val5);
30394   if (!SWIG_IsOK(ecode5)) {
30395     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIK" "', argument " "5"" of type '" "int""'");
30396   }
30397   arg5 = static_cast< int >(val5);
30398   result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4,arg5);
30399   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
30400   return resultobj;
30401 fail:
30402   return NULL;
30403 }
30404
30405
30406 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30407   PyObject *resultobj = 0;
30408   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30409   int arg2 ;
30410   int arg3 ;
30411   int arg4 ;
30412   int arg5 ;
30413   Hex::Edge *result = 0 ;
30414   void *argp1 = 0 ;
30415   int res1 = 0 ;
30416   int val2 ;
30417   int ecode2 = 0 ;
30418   int val3 ;
30419   int ecode3 = 0 ;
30420   int val4 ;
30421   int ecode4 = 0 ;
30422   int val5 ;
30423   int ecode5 = 0 ;
30424   PyObject * obj0 = 0 ;
30425   PyObject * obj1 = 0 ;
30426   PyObject * obj2 = 0 ;
30427   PyObject * obj3 = 0 ;
30428   PyObject * obj4 = 0 ;
30429
30430   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeI",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30431   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30432   if (!SWIG_IsOK(res1)) {
30433     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeI" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30434   }
30435   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30436   ecode2 = SWIG_AsVal_int(obj1, &val2);
30437   if (!SWIG_IsOK(ecode2)) {
30438     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeI" "', argument " "2"" of type '" "int""'");
30439   }
30440   arg2 = static_cast< int >(val2);
30441   ecode3 = SWIG_AsVal_int(obj2, &val3);
30442   if (!SWIG_IsOK(ecode3)) {
30443     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeI" "', argument " "3"" of type '" "int""'");
30444   }
30445   arg3 = static_cast< int >(val3);
30446   ecode4 = SWIG_AsVal_int(obj3, &val4);
30447   if (!SWIG_IsOK(ecode4)) {
30448     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeI" "', argument " "4"" of type '" "int""'");
30449   }
30450   arg4 = static_cast< int >(val4);
30451   ecode5 = SWIG_AsVal_int(obj4, &val5);
30452   if (!SWIG_IsOK(ecode5)) {
30453     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeI" "', argument " "5"" of type '" "int""'");
30454   }
30455   arg5 = static_cast< int >(val5);
30456   result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4,arg5);
30457   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
30458   return resultobj;
30459 fail:
30460   return NULL;
30461 }
30462
30463
30464 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30465   PyObject *resultobj = 0;
30466   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30467   int arg2 ;
30468   int arg3 ;
30469   int arg4 ;
30470   int arg5 ;
30471   Hex::Edge *result = 0 ;
30472   void *argp1 = 0 ;
30473   int res1 = 0 ;
30474   int val2 ;
30475   int ecode2 = 0 ;
30476   int val3 ;
30477   int ecode3 = 0 ;
30478   int val4 ;
30479   int ecode4 = 0 ;
30480   int val5 ;
30481   int ecode5 = 0 ;
30482   PyObject * obj0 = 0 ;
30483   PyObject * obj1 = 0 ;
30484   PyObject * obj2 = 0 ;
30485   PyObject * obj3 = 0 ;
30486   PyObject * obj4 = 0 ;
30487
30488   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30489   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30490   if (!SWIG_IsOK(res1)) {
30491     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30492   }
30493   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30494   ecode2 = SWIG_AsVal_int(obj1, &val2);
30495   if (!SWIG_IsOK(ecode2)) {
30496     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeJ" "', argument " "2"" of type '" "int""'");
30497   }
30498   arg2 = static_cast< int >(val2);
30499   ecode3 = SWIG_AsVal_int(obj2, &val3);
30500   if (!SWIG_IsOK(ecode3)) {
30501     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeJ" "', argument " "3"" of type '" "int""'");
30502   }
30503   arg3 = static_cast< int >(val3);
30504   ecode4 = SWIG_AsVal_int(obj3, &val4);
30505   if (!SWIG_IsOK(ecode4)) {
30506     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeJ" "', argument " "4"" of type '" "int""'");
30507   }
30508   arg4 = static_cast< int >(val4);
30509   ecode5 = SWIG_AsVal_int(obj4, &val5);
30510   if (!SWIG_IsOK(ecode5)) {
30511     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeJ" "', argument " "5"" of type '" "int""'");
30512   }
30513   arg5 = static_cast< int >(val5);
30514   result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4,arg5);
30515   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
30516   return resultobj;
30517 fail:
30518   return NULL;
30519 }
30520
30521
30522 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30523   PyObject *resultobj = 0;
30524   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30525   int arg2 ;
30526   int arg3 ;
30527   int arg4 ;
30528   int arg5 ;
30529   Hex::Edge *result = 0 ;
30530   void *argp1 = 0 ;
30531   int res1 = 0 ;
30532   int val2 ;
30533   int ecode2 = 0 ;
30534   int val3 ;
30535   int ecode3 = 0 ;
30536   int val4 ;
30537   int ecode4 = 0 ;
30538   int val5 ;
30539   int ecode5 = 0 ;
30540   PyObject * obj0 = 0 ;
30541   PyObject * obj1 = 0 ;
30542   PyObject * obj2 = 0 ;
30543   PyObject * obj3 = 0 ;
30544   PyObject * obj4 = 0 ;
30545
30546   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30547   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30548   if (!SWIG_IsOK(res1)) {
30549     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30550   }
30551   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30552   ecode2 = SWIG_AsVal_int(obj1, &val2);
30553   if (!SWIG_IsOK(ecode2)) {
30554     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeK" "', argument " "2"" of type '" "int""'");
30555   }
30556   arg2 = static_cast< int >(val2);
30557   ecode3 = SWIG_AsVal_int(obj2, &val3);
30558   if (!SWIG_IsOK(ecode3)) {
30559     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeK" "', argument " "3"" of type '" "int""'");
30560   }
30561   arg3 = static_cast< int >(val3);
30562   ecode4 = SWIG_AsVal_int(obj3, &val4);
30563   if (!SWIG_IsOK(ecode4)) {
30564     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeK" "', argument " "4"" of type '" "int""'");
30565   }
30566   arg4 = static_cast< int >(val4);
30567   ecode5 = SWIG_AsVal_int(obj4, &val5);
30568   if (!SWIG_IsOK(ecode5)) {
30569     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeK" "', argument " "5"" of type '" "int""'");
30570   }
30571   arg5 = static_cast< int >(val5);
30572   result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4,arg5);
30573   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
30574   return resultobj;
30575 fail:
30576   return NULL;
30577 }
30578
30579
30580 SWIGINTERN PyObject *_wrap_BiCylinder_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30581   PyObject *resultobj = 0;
30582   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30583   int arg2 ;
30584   int arg3 ;
30585   int arg4 ;
30586   int arg5 ;
30587   Hex::Vertex *result = 0 ;
30588   void *argp1 = 0 ;
30589   int res1 = 0 ;
30590   int val2 ;
30591   int ecode2 = 0 ;
30592   int val3 ;
30593   int ecode3 = 0 ;
30594   int val4 ;
30595   int ecode4 = 0 ;
30596   int val5 ;
30597   int ecode5 = 0 ;
30598   PyObject * obj0 = 0 ;
30599   PyObject * obj1 = 0 ;
30600   PyObject * obj2 = 0 ;
30601   PyObject * obj3 = 0 ;
30602   PyObject * obj4 = 0 ;
30603
30604   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getVertexIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30605   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30606   if (!SWIG_IsOK(res1)) {
30607     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getVertexIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30608   }
30609   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30610   ecode2 = SWIG_AsVal_int(obj1, &val2);
30611   if (!SWIG_IsOK(ecode2)) {
30612     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getVertexIJK" "', argument " "2"" of type '" "int""'");
30613   }
30614   arg2 = static_cast< int >(val2);
30615   ecode3 = SWIG_AsVal_int(obj2, &val3);
30616   if (!SWIG_IsOK(ecode3)) {
30617     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getVertexIJK" "', argument " "3"" of type '" "int""'");
30618   }
30619   arg3 = static_cast< int >(val3);
30620   ecode4 = SWIG_AsVal_int(obj3, &val4);
30621   if (!SWIG_IsOK(ecode4)) {
30622     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getVertexIJK" "', argument " "4"" of type '" "int""'");
30623   }
30624   arg4 = static_cast< int >(val4);
30625   ecode5 = SWIG_AsVal_int(obj4, &val5);
30626   if (!SWIG_IsOK(ecode5)) {
30627     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getVertexIJK" "', argument " "5"" of type '" "int""'");
30628   }
30629   arg5 = static_cast< int >(val5);
30630   result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4,arg5);
30631   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30632   return resultobj;
30633 fail:
30634   return NULL;
30635 }
30636
30637
30638 SWIGINTERN PyObject *_wrap_delete_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30639   PyObject *resultobj = 0;
30640   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30641   void *argp1 = 0 ;
30642   int res1 = 0 ;
30643   PyObject * obj0 = 0 ;
30644
30645   if (!PyArg_ParseTuple(args,(char *)"O:delete_BiCylinder",&obj0)) SWIG_fail;
30646   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_DISOWN |  0 );
30647   if (!SWIG_IsOK(res1)) {
30648     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCylinder" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30649   }
30650   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30651   delete arg1;
30652
30653   resultobj = SWIG_Py_Void();
30654   return resultobj;
30655 fail:
30656   return NULL;
30657 }
30658
30659
30660 SWIGINTERN PyObject *BiCylinder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30661   PyObject *obj;
30662   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
30663   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__BiCylinder, SWIG_NewClientData(obj));
30664   return SWIG_Py_Void();
30665 }
30666
30667 SWIGINTERN PyObject *_wrap_NewShape_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30668   PyObject *resultobj = 0;
30669   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30670   int result;
30671   void *argp1 = 0 ;
30672   int res1 = 0 ;
30673   PyObject * obj0 = 0 ;
30674
30675   if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countVertex",&obj0)) SWIG_fail;
30676   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30677   if (!SWIG_IsOK(res1)) {
30678     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
30679   }
30680   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30681   result = (int)(arg1)->countVertex();
30682   resultobj = SWIG_From_int(static_cast< int >(result));
30683   return resultobj;
30684 fail:
30685   return NULL;
30686 }
30687
30688
30689 SWIGINTERN PyObject *_wrap_NewShape_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30690   PyObject *resultobj = 0;
30691   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30692   int result;
30693   void *argp1 = 0 ;
30694   int res1 = 0 ;
30695   PyObject * obj0 = 0 ;
30696
30697   if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countEdge",&obj0)) SWIG_fail;
30698   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30699   if (!SWIG_IsOK(res1)) {
30700     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
30701   }
30702   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30703   result = (int)(arg1)->countEdge();
30704   resultobj = SWIG_From_int(static_cast< int >(result));
30705   return resultobj;
30706 fail:
30707   return NULL;
30708 }
30709
30710
30711 SWIGINTERN PyObject *_wrap_NewShape_countFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30712   PyObject *resultobj = 0;
30713   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30714   int result;
30715   void *argp1 = 0 ;
30716   int res1 = 0 ;
30717   PyObject * obj0 = 0 ;
30718
30719   if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countFace",&obj0)) SWIG_fail;
30720   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30721   if (!SWIG_IsOK(res1)) {
30722     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
30723   }
30724   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30725   result = (int)(arg1)->countFace();
30726   resultobj = SWIG_From_int(static_cast< int >(result));
30727   return resultobj;
30728 fail:
30729   return NULL;
30730 }
30731
30732
30733 SWIGINTERN PyObject *_wrap_NewShape_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30734   PyObject *resultobj = 0;
30735   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30736   int arg2 ;
30737   int result;
30738   void *argp1 = 0 ;
30739   int res1 = 0 ;
30740   int val2 ;
30741   int ecode2 = 0 ;
30742   PyObject * obj0 = 0 ;
30743   PyObject * obj1 = 0 ;
30744
30745   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getVertex",&obj0,&obj1)) SWIG_fail;
30746   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30747   if (!SWIG_IsOK(res1)) {
30748     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
30749   }
30750   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30751   ecode2 = SWIG_AsVal_int(obj1, &val2);
30752   if (!SWIG_IsOK(ecode2)) {
30753     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getVertex" "', argument " "2"" of type '" "int""'");
30754   }
30755   arg2 = static_cast< int >(val2);
30756   result = (int)(arg1)->getVertex(arg2);
30757   resultobj = SWIG_From_int(static_cast< int >(result));
30758   return resultobj;
30759 fail:
30760   return NULL;
30761 }
30762
30763
30764 SWIGINTERN PyObject *_wrap_NewShape_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30765   PyObject *resultobj = 0;
30766   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30767   int arg2 ;
30768   int result;
30769   void *argp1 = 0 ;
30770   int res1 = 0 ;
30771   int val2 ;
30772   int ecode2 = 0 ;
30773   PyObject * obj0 = 0 ;
30774   PyObject * obj1 = 0 ;
30775
30776   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getEdge",&obj0,&obj1)) SWIG_fail;
30777   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30778   if (!SWIG_IsOK(res1)) {
30779     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
30780   }
30781   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30782   ecode2 = SWIG_AsVal_int(obj1, &val2);
30783   if (!SWIG_IsOK(ecode2)) {
30784     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getEdge" "', argument " "2"" of type '" "int""'");
30785   }
30786   arg2 = static_cast< int >(val2);
30787   result = (int)(arg1)->getEdge(arg2);
30788   resultobj = SWIG_From_int(static_cast< int >(result));
30789   return resultobj;
30790 fail:
30791   return NULL;
30792 }
30793
30794
30795 SWIGINTERN PyObject *_wrap_NewShape_getFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30796   PyObject *resultobj = 0;
30797   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30798   int arg2 ;
30799   int result;
30800   void *argp1 = 0 ;
30801   int res1 = 0 ;
30802   int val2 ;
30803   int ecode2 = 0 ;
30804   PyObject * obj0 = 0 ;
30805   PyObject * obj1 = 0 ;
30806
30807   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getFace",&obj0,&obj1)) SWIG_fail;
30808   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30809   if (!SWIG_IsOK(res1)) {
30810     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
30811   }
30812   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30813   ecode2 = SWIG_AsVal_int(obj1, &val2);
30814   if (!SWIG_IsOK(ecode2)) {
30815     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getFace" "', argument " "2"" of type '" "int""'");
30816   }
30817   arg2 = static_cast< int >(val2);
30818   result = (int)(arg1)->getFace(arg2);
30819   resultobj = SWIG_From_int(static_cast< int >(result));
30820   return resultobj;
30821 fail:
30822   return NULL;
30823 }
30824
30825
30826 SWIGINTERN PyObject *_wrap_NewShape_getNameVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30827   PyObject *resultobj = 0;
30828   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30829   int arg2 ;
30830   cpchar result;
30831   void *argp1 = 0 ;
30832   int res1 = 0 ;
30833   int val2 ;
30834   int ecode2 = 0 ;
30835   PyObject * obj0 = 0 ;
30836   PyObject * obj1 = 0 ;
30837
30838   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameVertex",&obj0,&obj1)) SWIG_fail;
30839   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30840   if (!SWIG_IsOK(res1)) {
30841     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
30842   }
30843   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30844   ecode2 = SWIG_AsVal_int(obj1, &val2);
30845   if (!SWIG_IsOK(ecode2)) {
30846     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameVertex" "', argument " "2"" of type '" "int""'");
30847   }
30848   arg2 = static_cast< int >(val2);
30849   result = (cpchar)(arg1)->getNameVertex(arg2);
30850   resultobj = SWIG_FromCharPtr((const char *)result);
30851   return resultobj;
30852 fail:
30853   return NULL;
30854 }
30855
30856
30857 SWIGINTERN PyObject *_wrap_NewShape_getNameEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30858   PyObject *resultobj = 0;
30859   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30860   int arg2 ;
30861   cpchar result;
30862   void *argp1 = 0 ;
30863   int res1 = 0 ;
30864   int val2 ;
30865   int ecode2 = 0 ;
30866   PyObject * obj0 = 0 ;
30867   PyObject * obj1 = 0 ;
30868
30869   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameEdge",&obj0,&obj1)) SWIG_fail;
30870   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30871   if (!SWIG_IsOK(res1)) {
30872     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
30873   }
30874   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30875   ecode2 = SWIG_AsVal_int(obj1, &val2);
30876   if (!SWIG_IsOK(ecode2)) {
30877     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameEdge" "', argument " "2"" of type '" "int""'");
30878   }
30879   arg2 = static_cast< int >(val2);
30880   result = (cpchar)(arg1)->getNameEdge(arg2);
30881   resultobj = SWIG_FromCharPtr((const char *)result);
30882   return resultobj;
30883 fail:
30884   return NULL;
30885 }
30886
30887
30888 SWIGINTERN PyObject *_wrap_NewShape_getNameFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30889   PyObject *resultobj = 0;
30890   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30891   int arg2 ;
30892   cpchar result;
30893   void *argp1 = 0 ;
30894   int res1 = 0 ;
30895   int val2 ;
30896   int ecode2 = 0 ;
30897   PyObject * obj0 = 0 ;
30898   PyObject * obj1 = 0 ;
30899
30900   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameFace",&obj0,&obj1)) SWIG_fail;
30901   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30902   if (!SWIG_IsOK(res1)) {
30903     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
30904   }
30905   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30906   ecode2 = SWIG_AsVal_int(obj1, &val2);
30907   if (!SWIG_IsOK(ecode2)) {
30908     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameFace" "', argument " "2"" of type '" "int""'");
30909   }
30910   arg2 = static_cast< int >(val2);
30911   result = (cpchar)(arg1)->getNameFace(arg2);
30912   resultobj = SWIG_FromCharPtr((const char *)result);
30913   return resultobj;
30914 fail:
30915   return NULL;
30916 }
30917
30918
30919 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30920   PyObject *resultobj = 0;
30921   Hex::Document *arg1 = (Hex::Document *) 0 ;
30922   Hex::EnumShape arg2 ;
30923   Hex::NewShape *result = 0 ;
30924   void *argp1 = 0 ;
30925   int res1 = 0 ;
30926   int val2 ;
30927   int ecode2 = 0 ;
30928   PyObject * obj0 = 0 ;
30929   PyObject * obj1 = 0 ;
30930
30931   if (!PyArg_ParseTuple(args,(char *)"OO:new_NewShape",&obj0,&obj1)) SWIG_fail;
30932   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30933   if (!SWIG_IsOK(res1)) {
30934     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
30935   }
30936   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30937   ecode2 = SWIG_AsVal_int(obj1, &val2);
30938   if (!SWIG_IsOK(ecode2)) {
30939     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewShape" "', argument " "2"" of type '" "Hex::EnumShape""'");
30940   }
30941   arg2 = static_cast< Hex::EnumShape >(val2);
30942   result = (Hex::NewShape *)new Hex::NewShape(arg1,arg2);
30943   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_NEW |  0 );
30944   return resultobj;
30945 fail:
30946   return NULL;
30947 }
30948
30949
30950 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30951   PyObject *resultobj = 0;
30952   Hex::Document *arg1 = (Hex::Document *) 0 ;
30953   Hex::NewShape *result = 0 ;
30954   void *argp1 = 0 ;
30955   int res1 = 0 ;
30956   PyObject * obj0 = 0 ;
30957
30958   if (!PyArg_ParseTuple(args,(char *)"O:new_NewShape",&obj0)) SWIG_fail;
30959   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30960   if (!SWIG_IsOK(res1)) {
30961     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
30962   }
30963   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30964   result = (Hex::NewShape *)new Hex::NewShape(arg1);
30965   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_NEW |  0 );
30966   return resultobj;
30967 fail:
30968   return NULL;
30969 }
30970
30971
30972 SWIGINTERN PyObject *_wrap_new_NewShape(PyObject *self, PyObject *args) {
30973   int argc;
30974   PyObject *argv[3];
30975   int ii;
30976
30977   if (!PyTuple_Check(args)) SWIG_fail;
30978   argc = PyObject_Length(args);
30979   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30980     argv[ii] = PyTuple_GET_ITEM(args,ii);
30981   }
30982   if (argc == 1) {
30983     int _v;
30984     void *vptr = 0;
30985     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
30986     _v = SWIG_CheckState(res);
30987     if (_v) {
30988       return _wrap_new_NewShape__SWIG_1(self, args);
30989     }
30990   }
30991   if (argc == 2) {
30992     int _v;
30993     void *vptr = 0;
30994     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
30995     _v = SWIG_CheckState(res);
30996     if (_v) {
30997       {
30998         int res = SWIG_AsVal_int(argv[1], NULL);
30999         _v = SWIG_CheckState(res);
31000       }
31001       if (_v) {
31002         return _wrap_new_NewShape__SWIG_0(self, args);
31003       }
31004     }
31005   }
31006
31007 fail:
31008   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NewShape'.\n  Possible C/C++ prototypes are:\n    Hex::NewShape(Hex::Document *,Hex::EnumShape)\n    Hex::NewShape(Hex::Document *)\n");
31009   return NULL;
31010 }
31011
31012
31013 SWIGINTERN PyObject *_wrap_delete_NewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31014   PyObject *resultobj = 0;
31015   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
31016   void *argp1 = 0 ;
31017   int res1 = 0 ;
31018   PyObject * obj0 = 0 ;
31019
31020   if (!PyArg_ParseTuple(args,(char *)"O:delete_NewShape",&obj0)) SWIG_fail;
31021   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_DISOWN |  0 );
31022   if (!SWIG_IsOK(res1)) {
31023     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewShape" "', argument " "1"" of type '" "Hex::NewShape *""'");
31024   }
31025   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31026   delete arg1;
31027
31028   resultobj = SWIG_Py_Void();
31029   return resultobj;
31030 fail:
31031   return NULL;
31032 }
31033
31034
31035 SWIGINTERN PyObject *NewShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31036   PyObject *obj;
31037   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
31038   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__NewShape, SWIG_NewClientData(obj));
31039   return SWIG_Py_Void();
31040 }
31041
31042 SWIGINTERN PyObject *_wrap_Group_addElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31043   PyObject *resultobj = 0;
31044   Hex::Group *arg1 = (Hex::Group *) 0 ;
31045   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
31046   int result;
31047   void *argp1 = 0 ;
31048   int res1 = 0 ;
31049   void *argp2 = 0 ;
31050   int res2 = 0 ;
31051   PyObject * obj0 = 0 ;
31052   PyObject * obj1 = 0 ;
31053
31054   if (!PyArg_ParseTuple(args,(char *)"OO:Group_addElement",&obj0,&obj1)) SWIG_fail;
31055   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31056   if (!SWIG_IsOK(res1)) {
31057     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_addElement" "', argument " "1"" of type '" "Hex::Group *""'");
31058   }
31059   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31060   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
31061   if (!SWIG_IsOK(res2)) {
31062     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_addElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
31063   }
31064   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
31065   result = (int)(arg1)->addElement(arg2);
31066   resultobj = SWIG_From_int(static_cast< int >(result));
31067   return resultobj;
31068 fail:
31069   return NULL;
31070 }
31071
31072
31073 SWIGINTERN PyObject *_wrap_Group_countElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31074   PyObject *resultobj = 0;
31075   Hex::Group *arg1 = (Hex::Group *) 0 ;
31076   int result;
31077   void *argp1 = 0 ;
31078   int res1 = 0 ;
31079   PyObject * obj0 = 0 ;
31080
31081   if (!PyArg_ParseTuple(args,(char *)"O:Group_countElement",&obj0)) SWIG_fail;
31082   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31083   if (!SWIG_IsOK(res1)) {
31084     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_countElement" "', argument " "1"" of type '" "Hex::Group *""'");
31085   }
31086   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31087   result = (int)(arg1)->countElement();
31088   resultobj = SWIG_From_int(static_cast< int >(result));
31089   return resultobj;
31090 fail:
31091   return NULL;
31092 }
31093
31094
31095 SWIGINTERN PyObject *_wrap_Group_getKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31096   PyObject *resultobj = 0;
31097   Hex::Group *arg1 = (Hex::Group *) 0 ;
31098   Hex::EnumGroup result;
31099   void *argp1 = 0 ;
31100   int res1 = 0 ;
31101   PyObject * obj0 = 0 ;
31102
31103   if (!PyArg_ParseTuple(args,(char *)"O:Group_getKind",&obj0)) SWIG_fail;
31104   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31105   if (!SWIG_IsOK(res1)) {
31106     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getKind" "', argument " "1"" of type '" "Hex::Group *""'");
31107   }
31108   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31109   result = (Hex::EnumGroup)(arg1)->getKind();
31110   resultobj = SWIG_From_int(static_cast< int >(result));
31111   return resultobj;
31112 fail:
31113   return NULL;
31114 }
31115
31116
31117 SWIGINTERN PyObject *_wrap_Group_removeElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31118   PyObject *resultobj = 0;
31119   Hex::Group *arg1 = (Hex::Group *) 0 ;
31120   int arg2 ;
31121   int result;
31122   void *argp1 = 0 ;
31123   int res1 = 0 ;
31124   int val2 ;
31125   int ecode2 = 0 ;
31126   PyObject * obj0 = 0 ;
31127   PyObject * obj1 = 0 ;
31128
31129   if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
31130   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31131   if (!SWIG_IsOK(res1)) {
31132     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
31133   }
31134   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31135   ecode2 = SWIG_AsVal_int(obj1, &val2);
31136   if (!SWIG_IsOK(ecode2)) {
31137     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "int""'");
31138   }
31139   arg2 = static_cast< int >(val2);
31140   result = (int)(arg1)->removeElement(arg2);
31141   resultobj = SWIG_From_int(static_cast< int >(result));
31142   return resultobj;
31143 fail:
31144   return NULL;
31145 }
31146
31147
31148 SWIGINTERN PyObject *_wrap_Group_clearElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31149   PyObject *resultobj = 0;
31150   Hex::Group *arg1 = (Hex::Group *) 0 ;
31151   void *argp1 = 0 ;
31152   int res1 = 0 ;
31153   PyObject * obj0 = 0 ;
31154
31155   if (!PyArg_ParseTuple(args,(char *)"O:Group_clearElement",&obj0)) SWIG_fail;
31156   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31157   if (!SWIG_IsOK(res1)) {
31158     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_clearElement" "', argument " "1"" of type '" "Hex::Group *""'");
31159   }
31160   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31161   (arg1)->clearElement();
31162   resultobj = SWIG_Py_Void();
31163   return resultobj;
31164 fail:
31165   return NULL;
31166 }
31167
31168
31169 SWIGINTERN PyObject *_wrap_Group_removeElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31170   PyObject *resultobj = 0;
31171   Hex::Group *arg1 = (Hex::Group *) 0 ;
31172   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
31173   int result;
31174   void *argp1 = 0 ;
31175   int res1 = 0 ;
31176   void *argp2 = 0 ;
31177   int res2 = 0 ;
31178   PyObject * obj0 = 0 ;
31179   PyObject * obj1 = 0 ;
31180
31181   if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
31182   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31183   if (!SWIG_IsOK(res1)) {
31184     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
31185   }
31186   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31187   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
31188   if (!SWIG_IsOK(res2)) {
31189     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
31190   }
31191   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
31192   result = (int)(arg1)->removeElement(arg2);
31193   resultobj = SWIG_From_int(static_cast< int >(result));
31194   return resultobj;
31195 fail:
31196   return NULL;
31197 }
31198
31199
31200 SWIGINTERN PyObject *_wrap_Group_removeElement(PyObject *self, PyObject *args) {
31201   int argc;
31202   PyObject *argv[3];
31203   int ii;
31204
31205   if (!PyTuple_Check(args)) SWIG_fail;
31206   argc = PyObject_Length(args);
31207   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31208     argv[ii] = PyTuple_GET_ITEM(args,ii);
31209   }
31210   if (argc == 2) {
31211     int _v;
31212     void *vptr = 0;
31213     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
31214     _v = SWIG_CheckState(res);
31215     if (_v) {
31216       void *vptr = 0;
31217       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
31218       _v = SWIG_CheckState(res);
31219       if (_v) {
31220         return _wrap_Group_removeElement__SWIG_1(self, args);
31221       }
31222     }
31223   }
31224   if (argc == 2) {
31225     int _v;
31226     void *vptr = 0;
31227     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
31228     _v = SWIG_CheckState(res);
31229     if (_v) {
31230       {
31231         int res = SWIG_AsVal_int(argv[1], NULL);
31232         _v = SWIG_CheckState(res);
31233       }
31234       if (_v) {
31235         return _wrap_Group_removeElement__SWIG_0(self, args);
31236       }
31237     }
31238   }
31239
31240 fail:
31241   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Group_removeElement'.\n  Possible C/C++ prototypes are:\n    removeElement(int)\n    removeElement(Hex::EltBase *)\n");
31242   return NULL;
31243 }
31244
31245
31246 SWIGINTERN PyObject *_wrap_Group_getElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31247   PyObject *resultobj = 0;
31248   Hex::Group *arg1 = (Hex::Group *) 0 ;
31249   int arg2 ;
31250   Hex::EltBase *result = 0 ;
31251   void *argp1 = 0 ;
31252   int res1 = 0 ;
31253   int val2 ;
31254   int ecode2 = 0 ;
31255   PyObject * obj0 = 0 ;
31256   PyObject * obj1 = 0 ;
31257
31258   if (!PyArg_ParseTuple(args,(char *)"OO:Group_getElement",&obj0,&obj1)) SWIG_fail;
31259   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31260   if (!SWIG_IsOK(res1)) {
31261     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getElement" "', argument " "1"" of type '" "Hex::Group *""'");
31262   }
31263   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31264   ecode2 = SWIG_AsVal_int(obj1, &val2);
31265   if (!SWIG_IsOK(ecode2)) {
31266     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_getElement" "', argument " "2"" of type '" "int""'");
31267   }
31268   arg2 = static_cast< int >(val2);
31269   result = (Hex::EltBase *)(arg1)->getElement(arg2);
31270   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 |  0 );
31271   return resultobj;
31272 fail:
31273   return NULL;
31274 }
31275
31276
31277 SWIGINTERN PyObject *_wrap_new_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31278   PyObject *resultobj = 0;
31279   Hex::Document *arg1 = (Hex::Document *) 0 ;
31280   cpchar arg2 = (cpchar) 0 ;
31281   Hex::EnumGroup arg3 ;
31282   Hex::Group *result = 0 ;
31283   void *argp1 = 0 ;
31284   int res1 = 0 ;
31285   int res2 ;
31286   char *buf2 = 0 ;
31287   int alloc2 = 0 ;
31288   int val3 ;
31289   int ecode3 = 0 ;
31290   PyObject * obj0 = 0 ;
31291   PyObject * obj1 = 0 ;
31292   PyObject * obj2 = 0 ;
31293
31294   if (!PyArg_ParseTuple(args,(char *)"OOO:new_Group",&obj0,&obj1,&obj2)) SWIG_fail;
31295   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31296   if (!SWIG_IsOK(res1)) {
31297     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Group" "', argument " "1"" of type '" "Hex::Document *""'");
31298   }
31299   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31300   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
31301   if (!SWIG_IsOK(res2)) {
31302     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Group" "', argument " "2"" of type '" "cpchar""'");
31303   }
31304   arg2 = reinterpret_cast< cpchar >(buf2);
31305   ecode3 = SWIG_AsVal_int(obj2, &val3);
31306   if (!SWIG_IsOK(ecode3)) {
31307     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Group" "', argument " "3"" of type '" "Hex::EnumGroup""'");
31308   }
31309   arg3 = static_cast< Hex::EnumGroup >(val3);
31310   result = (Hex::Group *)new Hex::Group(arg1,arg2,arg3);
31311   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, SWIG_POINTER_NEW |  0 );
31312   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31313   return resultobj;
31314 fail:
31315   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31316   return NULL;
31317 }
31318
31319
31320 SWIGINTERN PyObject *_wrap_delete_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31321   PyObject *resultobj = 0;
31322   Hex::Group *arg1 = (Hex::Group *) 0 ;
31323   void *argp1 = 0 ;
31324   int res1 = 0 ;
31325   PyObject * obj0 = 0 ;
31326
31327   if (!PyArg_ParseTuple(args,(char *)"O:delete_Group",&obj0)) SWIG_fail;
31328   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, SWIG_POINTER_DISOWN |  0 );
31329   if (!SWIG_IsOK(res1)) {
31330     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Group" "', argument " "1"" of type '" "Hex::Group *""'");
31331   }
31332   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31333   delete arg1;
31334
31335   resultobj = SWIG_Py_Void();
31336   return resultobj;
31337 fail:
31338   return NULL;
31339 }
31340
31341
31342 SWIGINTERN PyObject *Group_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31343   PyObject *obj;
31344   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
31345   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Group, SWIG_NewClientData(obj));
31346   return SWIG_Py_Void();
31347 }
31348
31349 static PyMethodDef SwigMethods[] = {
31350          { (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, NULL},
31351          { (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, NULL},
31352          { (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, NULL},
31353          { (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, NULL},
31354          { (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, NULL},
31355          { (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, NULL},
31356          { (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, NULL},
31357          { (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, NULL},
31358          { (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, NULL},
31359          { (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, NULL},
31360          { (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, NULL},
31361          { (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, NULL},
31362          { (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, NULL},
31363          { (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, NULL},
31364          { (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, NULL},
31365          { (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, NULL},
31366          { (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
31367          { (char *)"VectorHexas_iterator", _wrap_VectorHexas_iterator, METH_VARARGS, NULL},
31368          { (char *)"VectorHexas___nonzero__", _wrap_VectorHexas___nonzero__, METH_VARARGS, NULL},
31369          { (char *)"VectorHexas___len__", _wrap_VectorHexas___len__, METH_VARARGS, NULL},
31370          { (char *)"VectorHexas_pop", _wrap_VectorHexas_pop, METH_VARARGS, NULL},
31371          { (char *)"VectorHexas___getslice__", _wrap_VectorHexas___getslice__, METH_VARARGS, NULL},
31372          { (char *)"VectorHexas___setslice__", _wrap_VectorHexas___setslice__, METH_VARARGS, NULL},
31373          { (char *)"VectorHexas___delslice__", _wrap_VectorHexas___delslice__, METH_VARARGS, NULL},
31374          { (char *)"VectorHexas___delitem__", _wrap_VectorHexas___delitem__, METH_VARARGS, NULL},
31375          { (char *)"VectorHexas___getitem__", _wrap_VectorHexas___getitem__, METH_VARARGS, NULL},
31376          { (char *)"VectorHexas___setitem__", _wrap_VectorHexas___setitem__, METH_VARARGS, NULL},
31377          { (char *)"VectorHexas_append", _wrap_VectorHexas_append, METH_VARARGS, NULL},
31378          { (char *)"VectorHexas_empty", _wrap_VectorHexas_empty, METH_VARARGS, NULL},
31379          { (char *)"VectorHexas_size", _wrap_VectorHexas_size, METH_VARARGS, NULL},
31380          { (char *)"VectorHexas_clear", _wrap_VectorHexas_clear, METH_VARARGS, NULL},
31381          { (char *)"VectorHexas_swap", _wrap_VectorHexas_swap, METH_VARARGS, NULL},
31382          { (char *)"VectorHexas_get_allocator", _wrap_VectorHexas_get_allocator, METH_VARARGS, NULL},
31383          { (char *)"VectorHexas_begin", _wrap_VectorHexas_begin, METH_VARARGS, NULL},
31384          { (char *)"VectorHexas_end", _wrap_VectorHexas_end, METH_VARARGS, NULL},
31385          { (char *)"VectorHexas_rbegin", _wrap_VectorHexas_rbegin, METH_VARARGS, NULL},
31386          { (char *)"VectorHexas_rend", _wrap_VectorHexas_rend, METH_VARARGS, NULL},
31387          { (char *)"VectorHexas_pop_back", _wrap_VectorHexas_pop_back, METH_VARARGS, NULL},
31388          { (char *)"VectorHexas_erase", _wrap_VectorHexas_erase, METH_VARARGS, NULL},
31389          { (char *)"new_VectorHexas", _wrap_new_VectorHexas, METH_VARARGS, NULL},
31390          { (char *)"VectorHexas_push_back", _wrap_VectorHexas_push_back, METH_VARARGS, NULL},
31391          { (char *)"VectorHexas_front", _wrap_VectorHexas_front, METH_VARARGS, NULL},
31392          { (char *)"VectorHexas_back", _wrap_VectorHexas_back, METH_VARARGS, NULL},
31393          { (char *)"VectorHexas_assign", _wrap_VectorHexas_assign, METH_VARARGS, NULL},
31394          { (char *)"VectorHexas_resize", _wrap_VectorHexas_resize, METH_VARARGS, NULL},
31395          { (char *)"VectorHexas_insert", _wrap_VectorHexas_insert, METH_VARARGS, NULL},
31396          { (char *)"VectorHexas_reserve", _wrap_VectorHexas_reserve, METH_VARARGS, NULL},
31397          { (char *)"VectorHexas_capacity", _wrap_VectorHexas_capacity, METH_VARARGS, NULL},
31398          { (char *)"delete_VectorHexas", _wrap_delete_VectorHexas, METH_VARARGS, NULL},
31399          { (char *)"VectorHexas_swigregister", VectorHexas_swigregister, METH_VARARGS, NULL},
31400          { (char *)"VectorQuads_iterator", _wrap_VectorQuads_iterator, METH_VARARGS, NULL},
31401          { (char *)"VectorQuads___nonzero__", _wrap_VectorQuads___nonzero__, METH_VARARGS, NULL},
31402          { (char *)"VectorQuads___len__", _wrap_VectorQuads___len__, METH_VARARGS, NULL},
31403          { (char *)"VectorQuads_pop", _wrap_VectorQuads_pop, METH_VARARGS, NULL},
31404          { (char *)"VectorQuads___getslice__", _wrap_VectorQuads___getslice__, METH_VARARGS, NULL},
31405          { (char *)"VectorQuads___setslice__", _wrap_VectorQuads___setslice__, METH_VARARGS, NULL},
31406          { (char *)"VectorQuads___delslice__", _wrap_VectorQuads___delslice__, METH_VARARGS, NULL},
31407          { (char *)"VectorQuads___delitem__", _wrap_VectorQuads___delitem__, METH_VARARGS, NULL},
31408          { (char *)"VectorQuads___getitem__", _wrap_VectorQuads___getitem__, METH_VARARGS, NULL},
31409          { (char *)"VectorQuads___setitem__", _wrap_VectorQuads___setitem__, METH_VARARGS, NULL},
31410          { (char *)"VectorQuads_append", _wrap_VectorQuads_append, METH_VARARGS, NULL},
31411          { (char *)"VectorQuads_empty", _wrap_VectorQuads_empty, METH_VARARGS, NULL},
31412          { (char *)"VectorQuads_size", _wrap_VectorQuads_size, METH_VARARGS, NULL},
31413          { (char *)"VectorQuads_clear", _wrap_VectorQuads_clear, METH_VARARGS, NULL},
31414          { (char *)"VectorQuads_swap", _wrap_VectorQuads_swap, METH_VARARGS, NULL},
31415          { (char *)"VectorQuads_get_allocator", _wrap_VectorQuads_get_allocator, METH_VARARGS, NULL},
31416          { (char *)"VectorQuads_begin", _wrap_VectorQuads_begin, METH_VARARGS, NULL},
31417          { (char *)"VectorQuads_end", _wrap_VectorQuads_end, METH_VARARGS, NULL},
31418          { (char *)"VectorQuads_rbegin", _wrap_VectorQuads_rbegin, METH_VARARGS, NULL},
31419          { (char *)"VectorQuads_rend", _wrap_VectorQuads_rend, METH_VARARGS, NULL},
31420          { (char *)"VectorQuads_pop_back", _wrap_VectorQuads_pop_back, METH_VARARGS, NULL},
31421          { (char *)"VectorQuads_erase", _wrap_VectorQuads_erase, METH_VARARGS, NULL},
31422          { (char *)"new_VectorQuads", _wrap_new_VectorQuads, METH_VARARGS, NULL},
31423          { (char *)"VectorQuads_push_back", _wrap_VectorQuads_push_back, METH_VARARGS, NULL},
31424          { (char *)"VectorQuads_front", _wrap_VectorQuads_front, METH_VARARGS, NULL},
31425          { (char *)"VectorQuads_back", _wrap_VectorQuads_back, METH_VARARGS, NULL},
31426          { (char *)"VectorQuads_assign", _wrap_VectorQuads_assign, METH_VARARGS, NULL},
31427          { (char *)"VectorQuads_resize", _wrap_VectorQuads_resize, METH_VARARGS, NULL},
31428          { (char *)"VectorQuads_insert", _wrap_VectorQuads_insert, METH_VARARGS, NULL},
31429          { (char *)"VectorQuads_reserve", _wrap_VectorQuads_reserve, METH_VARARGS, NULL},
31430          { (char *)"VectorQuads_capacity", _wrap_VectorQuads_capacity, METH_VARARGS, NULL},
31431          { (char *)"delete_VectorQuads", _wrap_delete_VectorQuads, METH_VARARGS, NULL},
31432          { (char *)"VectorQuads_swigregister", VectorQuads_swigregister, METH_VARARGS, NULL},
31433          { (char *)"VectorEdges_iterator", _wrap_VectorEdges_iterator, METH_VARARGS, NULL},
31434          { (char *)"VectorEdges___nonzero__", _wrap_VectorEdges___nonzero__, METH_VARARGS, NULL},
31435          { (char *)"VectorEdges___len__", _wrap_VectorEdges___len__, METH_VARARGS, NULL},
31436          { (char *)"VectorEdges_pop", _wrap_VectorEdges_pop, METH_VARARGS, NULL},
31437          { (char *)"VectorEdges___getslice__", _wrap_VectorEdges___getslice__, METH_VARARGS, NULL},
31438          { (char *)"VectorEdges___setslice__", _wrap_VectorEdges___setslice__, METH_VARARGS, NULL},
31439          { (char *)"VectorEdges___delslice__", _wrap_VectorEdges___delslice__, METH_VARARGS, NULL},
31440          { (char *)"VectorEdges___delitem__", _wrap_VectorEdges___delitem__, METH_VARARGS, NULL},
31441          { (char *)"VectorEdges___getitem__", _wrap_VectorEdges___getitem__, METH_VARARGS, NULL},
31442          { (char *)"VectorEdges___setitem__", _wrap_VectorEdges___setitem__, METH_VARARGS, NULL},
31443          { (char *)"VectorEdges_append", _wrap_VectorEdges_append, METH_VARARGS, NULL},
31444          { (char *)"VectorEdges_empty", _wrap_VectorEdges_empty, METH_VARARGS, NULL},
31445          { (char *)"VectorEdges_size", _wrap_VectorEdges_size, METH_VARARGS, NULL},
31446          { (char *)"VectorEdges_clear", _wrap_VectorEdges_clear, METH_VARARGS, NULL},
31447          { (char *)"VectorEdges_swap", _wrap_VectorEdges_swap, METH_VARARGS, NULL},
31448          { (char *)"VectorEdges_get_allocator", _wrap_VectorEdges_get_allocator, METH_VARARGS, NULL},
31449          { (char *)"VectorEdges_begin", _wrap_VectorEdges_begin, METH_VARARGS, NULL},
31450          { (char *)"VectorEdges_end", _wrap_VectorEdges_end, METH_VARARGS, NULL},
31451          { (char *)"VectorEdges_rbegin", _wrap_VectorEdges_rbegin, METH_VARARGS, NULL},
31452          { (char *)"VectorEdges_rend", _wrap_VectorEdges_rend, METH_VARARGS, NULL},
31453          { (char *)"VectorEdges_pop_back", _wrap_VectorEdges_pop_back, METH_VARARGS, NULL},
31454          { (char *)"VectorEdges_erase", _wrap_VectorEdges_erase, METH_VARARGS, NULL},
31455          { (char *)"new_VectorEdges", _wrap_new_VectorEdges, METH_VARARGS, NULL},
31456          { (char *)"VectorEdges_push_back", _wrap_VectorEdges_push_back, METH_VARARGS, NULL},
31457          { (char *)"VectorEdges_front", _wrap_VectorEdges_front, METH_VARARGS, NULL},
31458          { (char *)"VectorEdges_back", _wrap_VectorEdges_back, METH_VARARGS, NULL},
31459          { (char *)"VectorEdges_assign", _wrap_VectorEdges_assign, METH_VARARGS, NULL},
31460          { (char *)"VectorEdges_resize", _wrap_VectorEdges_resize, METH_VARARGS, NULL},
31461          { (char *)"VectorEdges_insert", _wrap_VectorEdges_insert, METH_VARARGS, NULL},
31462          { (char *)"VectorEdges_reserve", _wrap_VectorEdges_reserve, METH_VARARGS, NULL},
31463          { (char *)"VectorEdges_capacity", _wrap_VectorEdges_capacity, METH_VARARGS, NULL},
31464          { (char *)"delete_VectorEdges", _wrap_delete_VectorEdges, METH_VARARGS, NULL},
31465          { (char *)"VectorEdges_swigregister", VectorEdges_swigregister, METH_VARARGS, NULL},
31466          { (char *)"VectorVertices_iterator", _wrap_VectorVertices_iterator, METH_VARARGS, NULL},
31467          { (char *)"VectorVertices___nonzero__", _wrap_VectorVertices___nonzero__, METH_VARARGS, NULL},
31468          { (char *)"VectorVertices___len__", _wrap_VectorVertices___len__, METH_VARARGS, NULL},
31469          { (char *)"VectorVertices_pop", _wrap_VectorVertices_pop, METH_VARARGS, NULL},
31470          { (char *)"VectorVertices___getslice__", _wrap_VectorVertices___getslice__, METH_VARARGS, NULL},
31471          { (char *)"VectorVertices___setslice__", _wrap_VectorVertices___setslice__, METH_VARARGS, NULL},
31472          { (char *)"VectorVertices___delslice__", _wrap_VectorVertices___delslice__, METH_VARARGS, NULL},
31473          { (char *)"VectorVertices___delitem__", _wrap_VectorVertices___delitem__, METH_VARARGS, NULL},
31474          { (char *)"VectorVertices___getitem__", _wrap_VectorVertices___getitem__, METH_VARARGS, NULL},
31475          { (char *)"VectorVertices___setitem__", _wrap_VectorVertices___setitem__, METH_VARARGS, NULL},
31476          { (char *)"VectorVertices_append", _wrap_VectorVertices_append, METH_VARARGS, NULL},
31477          { (char *)"VectorVertices_empty", _wrap_VectorVertices_empty, METH_VARARGS, NULL},
31478          { (char *)"VectorVertices_size", _wrap_VectorVertices_size, METH_VARARGS, NULL},
31479          { (char *)"VectorVertices_clear", _wrap_VectorVertices_clear, METH_VARARGS, NULL},
31480          { (char *)"VectorVertices_swap", _wrap_VectorVertices_swap, METH_VARARGS, NULL},
31481          { (char *)"VectorVertices_get_allocator", _wrap_VectorVertices_get_allocator, METH_VARARGS, NULL},
31482          { (char *)"VectorVertices_begin", _wrap_VectorVertices_begin, METH_VARARGS, NULL},
31483          { (char *)"VectorVertices_end", _wrap_VectorVertices_end, METH_VARARGS, NULL},
31484          { (char *)"VectorVertices_rbegin", _wrap_VectorVertices_rbegin, METH_VARARGS, NULL},
31485          { (char *)"VectorVertices_rend", _wrap_VectorVertices_rend, METH_VARARGS, NULL},
31486          { (char *)"VectorVertices_pop_back", _wrap_VectorVertices_pop_back, METH_VARARGS, NULL},
31487          { (char *)"VectorVertices_erase", _wrap_VectorVertices_erase, METH_VARARGS, NULL},
31488          { (char *)"new_VectorVertices", _wrap_new_VectorVertices, METH_VARARGS, NULL},
31489          { (char *)"VectorVertices_push_back", _wrap_VectorVertices_push_back, METH_VARARGS, NULL},
31490          { (char *)"VectorVertices_front", _wrap_VectorVertices_front, METH_VARARGS, NULL},
31491          { (char *)"VectorVertices_back", _wrap_VectorVertices_back, METH_VARARGS, NULL},
31492          { (char *)"VectorVertices_assign", _wrap_VectorVertices_assign, METH_VARARGS, NULL},
31493          { (char *)"VectorVertices_resize", _wrap_VectorVertices_resize, METH_VARARGS, NULL},
31494          { (char *)"VectorVertices_insert", _wrap_VectorVertices_insert, METH_VARARGS, NULL},
31495          { (char *)"VectorVertices_reserve", _wrap_VectorVertices_reserve, METH_VARARGS, NULL},
31496          { (char *)"VectorVertices_capacity", _wrap_VectorVertices_capacity, METH_VARARGS, NULL},
31497          { (char *)"delete_VectorVertices", _wrap_delete_VectorVertices, METH_VARARGS, NULL},
31498          { (char *)"VectorVertices_swigregister", VectorVertices_swigregister, METH_VARARGS, NULL},
31499          { (char *)"VectorShapes_iterator", _wrap_VectorShapes_iterator, METH_VARARGS, NULL},
31500          { (char *)"VectorShapes___nonzero__", _wrap_VectorShapes___nonzero__, METH_VARARGS, NULL},
31501          { (char *)"VectorShapes___len__", _wrap_VectorShapes___len__, METH_VARARGS, NULL},
31502          { (char *)"VectorShapes_pop", _wrap_VectorShapes_pop, METH_VARARGS, NULL},
31503          { (char *)"VectorShapes___getslice__", _wrap_VectorShapes___getslice__, METH_VARARGS, NULL},
31504          { (char *)"VectorShapes___setslice__", _wrap_VectorShapes___setslice__, METH_VARARGS, NULL},
31505          { (char *)"VectorShapes___delslice__", _wrap_VectorShapes___delslice__, METH_VARARGS, NULL},
31506          { (char *)"VectorShapes___delitem__", _wrap_VectorShapes___delitem__, METH_VARARGS, NULL},
31507          { (char *)"VectorShapes___getitem__", _wrap_VectorShapes___getitem__, METH_VARARGS, NULL},
31508          { (char *)"VectorShapes___setitem__", _wrap_VectorShapes___setitem__, METH_VARARGS, NULL},
31509          { (char *)"VectorShapes_append", _wrap_VectorShapes_append, METH_VARARGS, NULL},
31510          { (char *)"VectorShapes_empty", _wrap_VectorShapes_empty, METH_VARARGS, NULL},
31511          { (char *)"VectorShapes_size", _wrap_VectorShapes_size, METH_VARARGS, NULL},
31512          { (char *)"VectorShapes_clear", _wrap_VectorShapes_clear, METH_VARARGS, NULL},
31513          { (char *)"VectorShapes_swap", _wrap_VectorShapes_swap, METH_VARARGS, NULL},
31514          { (char *)"VectorShapes_get_allocator", _wrap_VectorShapes_get_allocator, METH_VARARGS, NULL},
31515          { (char *)"VectorShapes_begin", _wrap_VectorShapes_begin, METH_VARARGS, NULL},
31516          { (char *)"VectorShapes_end", _wrap_VectorShapes_end, METH_VARARGS, NULL},
31517          { (char *)"VectorShapes_rbegin", _wrap_VectorShapes_rbegin, METH_VARARGS, NULL},
31518          { (char *)"VectorShapes_rend", _wrap_VectorShapes_rend, METH_VARARGS, NULL},
31519          { (char *)"VectorShapes_pop_back", _wrap_VectorShapes_pop_back, METH_VARARGS, NULL},
31520          { (char *)"VectorShapes_erase", _wrap_VectorShapes_erase, METH_VARARGS, NULL},
31521          { (char *)"new_VectorShapes", _wrap_new_VectorShapes, METH_VARARGS, NULL},
31522          { (char *)"VectorShapes_push_back", _wrap_VectorShapes_push_back, METH_VARARGS, NULL},
31523          { (char *)"VectorShapes_front", _wrap_VectorShapes_front, METH_VARARGS, NULL},
31524          { (char *)"VectorShapes_back", _wrap_VectorShapes_back, METH_VARARGS, NULL},
31525          { (char *)"VectorShapes_assign", _wrap_VectorShapes_assign, METH_VARARGS, NULL},
31526          { (char *)"VectorShapes_resize", _wrap_VectorShapes_resize, METH_VARARGS, NULL},
31527          { (char *)"VectorShapes_insert", _wrap_VectorShapes_insert, METH_VARARGS, NULL},
31528          { (char *)"VectorShapes_reserve", _wrap_VectorShapes_reserve, METH_VARARGS, NULL},
31529          { (char *)"VectorShapes_capacity", _wrap_VectorShapes_capacity, METH_VARARGS, NULL},
31530          { (char *)"delete_VectorShapes", _wrap_delete_VectorShapes, METH_VARARGS, NULL},
31531          { (char *)"VectorShapes_swigregister", VectorShapes_swigregister, METH_VARARGS, NULL},
31532          { (char *)"VectorReal_iterator", _wrap_VectorReal_iterator, METH_VARARGS, NULL},
31533          { (char *)"VectorReal___nonzero__", _wrap_VectorReal___nonzero__, METH_VARARGS, NULL},
31534          { (char *)"VectorReal___len__", _wrap_VectorReal___len__, METH_VARARGS, NULL},
31535          { (char *)"VectorReal_pop", _wrap_VectorReal_pop, METH_VARARGS, NULL},
31536          { (char *)"VectorReal___getslice__", _wrap_VectorReal___getslice__, METH_VARARGS, NULL},
31537          { (char *)"VectorReal___setslice__", _wrap_VectorReal___setslice__, METH_VARARGS, NULL},
31538          { (char *)"VectorReal___delslice__", _wrap_VectorReal___delslice__, METH_VARARGS, NULL},
31539          { (char *)"VectorReal___delitem__", _wrap_VectorReal___delitem__, METH_VARARGS, NULL},
31540          { (char *)"VectorReal___getitem__", _wrap_VectorReal___getitem__, METH_VARARGS, NULL},
31541          { (char *)"VectorReal___setitem__", _wrap_VectorReal___setitem__, METH_VARARGS, NULL},
31542          { (char *)"VectorReal_append", _wrap_VectorReal_append, METH_VARARGS, NULL},
31543          { (char *)"VectorReal_empty", _wrap_VectorReal_empty, METH_VARARGS, NULL},
31544          { (char *)"VectorReal_size", _wrap_VectorReal_size, METH_VARARGS, NULL},
31545          { (char *)"VectorReal_clear", _wrap_VectorReal_clear, METH_VARARGS, NULL},
31546          { (char *)"VectorReal_swap", _wrap_VectorReal_swap, METH_VARARGS, NULL},
31547          { (char *)"VectorReal_get_allocator", _wrap_VectorReal_get_allocator, METH_VARARGS, NULL},
31548          { (char *)"VectorReal_begin", _wrap_VectorReal_begin, METH_VARARGS, NULL},
31549          { (char *)"VectorReal_end", _wrap_VectorReal_end, METH_VARARGS, NULL},
31550          { (char *)"VectorReal_rbegin", _wrap_VectorReal_rbegin, METH_VARARGS, NULL},
31551          { (char *)"VectorReal_rend", _wrap_VectorReal_rend, METH_VARARGS, NULL},
31552          { (char *)"VectorReal_pop_back", _wrap_VectorReal_pop_back, METH_VARARGS, NULL},
31553          { (char *)"VectorReal_erase", _wrap_VectorReal_erase, METH_VARARGS, NULL},
31554          { (char *)"new_VectorReal", _wrap_new_VectorReal, METH_VARARGS, NULL},
31555          { (char *)"VectorReal_push_back", _wrap_VectorReal_push_back, METH_VARARGS, NULL},
31556          { (char *)"VectorReal_front", _wrap_VectorReal_front, METH_VARARGS, NULL},
31557          { (char *)"VectorReal_back", _wrap_VectorReal_back, METH_VARARGS, NULL},
31558          { (char *)"VectorReal_assign", _wrap_VectorReal_assign, METH_VARARGS, NULL},
31559          { (char *)"VectorReal_resize", _wrap_VectorReal_resize, METH_VARARGS, NULL},
31560          { (char *)"VectorReal_insert", _wrap_VectorReal_insert, METH_VARARGS, NULL},
31561          { (char *)"VectorReal_reserve", _wrap_VectorReal_reserve, METH_VARARGS, NULL},
31562          { (char *)"VectorReal_capacity", _wrap_VectorReal_capacity, METH_VARARGS, NULL},
31563          { (char *)"delete_VectorReal", _wrap_delete_VectorReal, METH_VARARGS, NULL},
31564          { (char *)"VectorReal_swigregister", VectorReal_swigregister, METH_VARARGS, NULL},
31565          { (char *)"VectorInt_iterator", _wrap_VectorInt_iterator, METH_VARARGS, NULL},
31566          { (char *)"VectorInt___nonzero__", _wrap_VectorInt___nonzero__, METH_VARARGS, NULL},
31567          { (char *)"VectorInt___len__", _wrap_VectorInt___len__, METH_VARARGS, NULL},
31568          { (char *)"VectorInt_pop", _wrap_VectorInt_pop, METH_VARARGS, NULL},
31569          { (char *)"VectorInt___getslice__", _wrap_VectorInt___getslice__, METH_VARARGS, NULL},
31570          { (char *)"VectorInt___setslice__", _wrap_VectorInt___setslice__, METH_VARARGS, NULL},
31571          { (char *)"VectorInt___delslice__", _wrap_VectorInt___delslice__, METH_VARARGS, NULL},
31572          { (char *)"VectorInt___delitem__", _wrap_VectorInt___delitem__, METH_VARARGS, NULL},
31573          { (char *)"VectorInt___getitem__", _wrap_VectorInt___getitem__, METH_VARARGS, NULL},
31574          { (char *)"VectorInt___setitem__", _wrap_VectorInt___setitem__, METH_VARARGS, NULL},
31575          { (char *)"VectorInt_append", _wrap_VectorInt_append, METH_VARARGS, NULL},
31576          { (char *)"VectorInt_empty", _wrap_VectorInt_empty, METH_VARARGS, NULL},
31577          { (char *)"VectorInt_size", _wrap_VectorInt_size, METH_VARARGS, NULL},
31578          { (char *)"VectorInt_clear", _wrap_VectorInt_clear, METH_VARARGS, NULL},
31579          { (char *)"VectorInt_swap", _wrap_VectorInt_swap, METH_VARARGS, NULL},
31580          { (char *)"VectorInt_get_allocator", _wrap_VectorInt_get_allocator, METH_VARARGS, NULL},
31581          { (char *)"VectorInt_begin", _wrap_VectorInt_begin, METH_VARARGS, NULL},
31582          { (char *)"VectorInt_end", _wrap_VectorInt_end, METH_VARARGS, NULL},
31583          { (char *)"VectorInt_rbegin", _wrap_VectorInt_rbegin, METH_VARARGS, NULL},
31584          { (char *)"VectorInt_rend", _wrap_VectorInt_rend, METH_VARARGS, NULL},
31585          { (char *)"VectorInt_pop_back", _wrap_VectorInt_pop_back, METH_VARARGS, NULL},
31586          { (char *)"VectorInt_erase", _wrap_VectorInt_erase, METH_VARARGS, NULL},
31587          { (char *)"new_VectorInt", _wrap_new_VectorInt, METH_VARARGS, NULL},
31588          { (char *)"VectorInt_push_back", _wrap_VectorInt_push_back, METH_VARARGS, NULL},
31589          { (char *)"VectorInt_front", _wrap_VectorInt_front, METH_VARARGS, NULL},
31590          { (char *)"VectorInt_back", _wrap_VectorInt_back, METH_VARARGS, NULL},
31591          { (char *)"VectorInt_assign", _wrap_VectorInt_assign, METH_VARARGS, NULL},
31592          { (char *)"VectorInt_resize", _wrap_VectorInt_resize, METH_VARARGS, NULL},
31593          { (char *)"VectorInt_insert", _wrap_VectorInt_insert, METH_VARARGS, NULL},
31594          { (char *)"VectorInt_reserve", _wrap_VectorInt_reserve, METH_VARARGS, NULL},
31595          { (char *)"VectorInt_capacity", _wrap_VectorInt_capacity, METH_VARARGS, NULL},
31596          { (char *)"delete_VectorInt", _wrap_delete_VectorInt, METH_VARARGS, NULL},
31597          { (char *)"VectorInt_swigregister", VectorInt_swigregister, METH_VARARGS, NULL},
31598          { (char *)"get_temp_name", _wrap_get_temp_name, METH_VARARGS, NULL},
31599          { (char *)"fatal_error", _wrap_fatal_error, METH_VARARGS, NULL},
31600          { (char *)"prod_scalaire", _wrap_prod_scalaire, METH_VARARGS, NULL},
31601          { (char *)"prod_vectoriel", _wrap_prod_vectoriel, METH_VARARGS, NULL},
31602          { (char *)"prod_mixte", _wrap_prod_mixte, METH_VARARGS, NULL},
31603          { (char *)"deg2radians", _wrap_deg2radians, METH_VARARGS, NULL},
31604          { (char *)"rad2degres", _wrap_rad2degres, METH_VARARGS, NULL},
31605          { (char *)"calc_norme", _wrap_calc_norme, METH_VARARGS, NULL},
31606          { (char *)"calc_distance", _wrap_calc_distance, METH_VARARGS, NULL},
31607          { (char *)"calc_d2", _wrap_calc_d2, METH_VARARGS, NULL},
31608          { (char *)"calc_vecteur", _wrap_calc_vecteur, METH_VARARGS, NULL},
31609          { (char *)"copy_vecteur", _wrap_copy_vecteur, METH_VARARGS, NULL},
31610          { (char *)"calc_milieu", _wrap_calc_milieu, METH_VARARGS, NULL},
31611          { (char *)"normer_vecteur", _wrap_normer_vecteur, METH_VARARGS, NULL},
31612          { (char *)"carre", _wrap_carre, METH_VARARGS, NULL},
31613          { (char *)"same_coords", _wrap_same_coords, METH_VARARGS, NULL},
31614          { (char *)"requals", _wrap_requals, METH_VARARGS, NULL},
31615          { (char *)"on_debug", _wrap_on_debug, METH_VARARGS, NULL},
31616          { (char *)"in_test", _wrap_in_test, METH_VARARGS, NULL},
31617          { (char *)"niv_debug", _wrap_niv_debug, METH_VARARGS, NULL},
31618          { (char *)"set_minus", _wrap_set_minus, METH_VARARGS, NULL},
31619          { (char *)"special_option", _wrap_special_option, METH_VARARGS, NULL},
31620          { (char *)"set_special_option", _wrap_set_special_option, METH_VARARGS, NULL},
31621          { (char *)"sizeof_file", _wrap_sizeof_file, METH_VARARGS, NULL},
31622          { (char *)"read_file", _wrap_read_file, METH_VARARGS, NULL},
31623          { (char *)"get_time", _wrap_get_time, METH_VARARGS, NULL},
31624          { (char *)"make_basename", _wrap_make_basename, METH_VARARGS, NULL},
31625          { (char *)"EltBase_countHexa", _wrap_EltBase_countHexa, METH_VARARGS, NULL},
31626          { (char *)"EltBase_countQuad", _wrap_EltBase_countQuad, METH_VARARGS, NULL},
31627          { (char *)"EltBase_countEdge", _wrap_EltBase_countEdge, METH_VARARGS, NULL},
31628          { (char *)"EltBase_countVertex", _wrap_EltBase_countVertex, METH_VARARGS, NULL},
31629          { (char *)"EltBase_setError", _wrap_EltBase_setError, METH_VARARGS, NULL},
31630          { (char *)"EltBase_getError", _wrap_EltBase_getError, METH_VARARGS, NULL},
31631          { (char *)"EltBase_isValid", _wrap_EltBase_isValid, METH_VARARGS, NULL},
31632          { (char *)"EltBase_isBad", _wrap_EltBase_isBad, METH_VARARGS, NULL},
31633          { (char *)"EltBase_duplicate", _wrap_EltBase_duplicate, METH_VARARGS, NULL},
31634          { (char *)"EltBase_clearAssociation", _wrap_EltBase_clearAssociation, METH_VARARGS, NULL},
31635          { (char *)"EltBase_replaceEdge", _wrap_EltBase_replaceEdge, METH_VARARGS, NULL},
31636          { (char *)"EltBase_replaceVertex", _wrap_EltBase_replaceVertex, METH_VARARGS, NULL},
31637          { (char *)"new_EltBase", _wrap_new_EltBase, METH_VARARGS, NULL},
31638          { (char *)"delete_EltBase", _wrap_delete_EltBase, METH_VARARGS, NULL},
31639          { (char *)"EltBase_remove", _wrap_EltBase_remove, METH_VARARGS, NULL},
31640          { (char *)"EltBase_suppress", _wrap_EltBase_suppress, METH_VARARGS, NULL},
31641          { (char *)"EltBase_dump", _wrap_EltBase_dump, METH_VARARGS, NULL},
31642          { (char *)"EltBase_saveXml", _wrap_EltBase_saveXml, METH_VARARGS, NULL},
31643          { (char *)"EltBase_majReferences", _wrap_EltBase_majReferences, METH_VARARGS, NULL},
31644          { (char *)"EltBase_makeVarName", _wrap_EltBase_makeVarName, METH_VARARGS, NULL},
31645          { (char *)"EltBase_makeName", _wrap_EltBase_makeName, METH_VARARGS, NULL},
31646          { (char *)"EltBase_next", _wrap_EltBase_next, METH_VARARGS, NULL},
31647          { (char *)"EltBase_setNext", _wrap_EltBase_setNext, METH_VARARGS, NULL},
31648          { (char *)"EltBase_getId", _wrap_EltBase_getId, METH_VARARGS, NULL},
31649          { (char *)"EltBase_setId", _wrap_EltBase_setId, METH_VARARGS, NULL},
31650          { (char *)"EltBase_dad", _wrap_EltBase_dad, METH_VARARGS, NULL},
31651          { (char *)"EltBase_getType", _wrap_EltBase_getType, METH_VARARGS, NULL},
31652          { (char *)"EltBase_isHere", _wrap_EltBase_isHere, METH_VARARGS, NULL},
31653          { (char *)"EltBase_isDeleted", _wrap_EltBase_isDeleted, METH_VARARGS, NULL},
31654          { (char *)"EltBase_razReferences", _wrap_EltBase_razReferences, METH_VARARGS, NULL},
31655          { (char *)"EltBase_addParent", _wrap_EltBase_addParent, METH_VARARGS, NULL},
31656          { (char *)"EltBase_getNbrParents", _wrap_EltBase_getNbrParents, METH_VARARGS, NULL},
31657          { (char *)"EltBase_hasParents", _wrap_EltBase_hasParents, METH_VARARGS, NULL},
31658          { (char *)"EltBase_getFather", _wrap_EltBase_getFather, METH_VARARGS, NULL},
31659          { (char *)"EltBase_getMark", _wrap_EltBase_getMark, METH_VARARGS, NULL},
31660          { (char *)"EltBase_setMark", _wrap_EltBase_setMark, METH_VARARGS, NULL},
31661          { (char *)"EltBase_printName", _wrap_EltBase_printName, METH_VARARGS, NULL},
31662          { (char *)"EltBase_dumpRef", _wrap_EltBase_dumpRef, METH_VARARGS, NULL},
31663          { (char *)"EltBase_getName", _wrap_EltBase_getName, METH_VARARGS, NULL},
31664          { (char *)"EltBase_setName", _wrap_EltBase_setName, METH_VARARGS, NULL},
31665          { (char *)"EltBase_debug", _wrap_EltBase_debug, METH_VARARGS, NULL},
31666          { (char *)"EltBase_isAssociated", _wrap_EltBase_isAssociated, METH_VARARGS, NULL},
31667          { (char *)"EltBase_getNextName", _wrap_EltBase_getNextName, METH_VARARGS, NULL},
31668          { (char *)"EltBase_swigregister", EltBase_swigregister, METH_VARARGS, NULL},
31669          { (char *)"Vertex_getX", _wrap_Vertex_getX, METH_VARARGS, NULL},
31670          { (char *)"Vertex_getY", _wrap_Vertex_getY, METH_VARARGS, NULL},
31671          { (char *)"Vertex_getZ", _wrap_Vertex_getZ, METH_VARARGS, NULL},
31672          { (char *)"Vertex_setX", _wrap_Vertex_setX, METH_VARARGS, NULL},
31673          { (char *)"Vertex_setY", _wrap_Vertex_setY, METH_VARARGS, NULL},
31674          { (char *)"Vertex_setZ", _wrap_Vertex_setZ, METH_VARARGS, NULL},
31675          { (char *)"Vertex_getAssoX", _wrap_Vertex_getAssoX, METH_VARARGS, NULL},
31676          { (char *)"Vertex_getAssoY", _wrap_Vertex_getAssoY, METH_VARARGS, NULL},
31677          { (char *)"Vertex_getAssoZ", _wrap_Vertex_getAssoZ, METH_VARARGS, NULL},
31678          { (char *)"Vertex_setAssociation", _wrap_Vertex_setAssociation, METH_VARARGS, NULL},
31679          { (char *)"Vertex_clearAssociation", _wrap_Vertex_clearAssociation, METH_VARARGS, NULL},
31680          { (char *)"Vertex_setColor", _wrap_Vertex_setColor, METH_VARARGS, NULL},
31681          { (char *)"new_Vertex", _wrap_new_Vertex, METH_VARARGS, NULL},
31682          { (char *)"delete_Vertex", _wrap_delete_Vertex, METH_VARARGS, NULL},
31683          { (char *)"Vertex_swigregister", Vertex_swigregister, METH_VARARGS, NULL},
31684          { (char *)"Edge_getVertex", _wrap_Edge_getVertex, METH_VARARGS, NULL},
31685          { (char *)"Edge_addAssociation", _wrap_Edge_addAssociation, METH_VARARGS, NULL},
31686          { (char *)"Edge_setAssociation", _wrap_Edge_setAssociation, METH_VARARGS, NULL},
31687          { (char *)"Edge_findAssociation", _wrap_Edge_findAssociation, METH_VARARGS, NULL},
31688          { (char *)"Edge_clearAssociation", _wrap_Edge_clearAssociation, METH_VARARGS, NULL},
31689          { (char *)"Edge_setColor", _wrap_Edge_setColor, METH_VARARGS, NULL},
31690          { (char *)"Edge_getWay", _wrap_Edge_getWay, METH_VARARGS, NULL},
31691          { (char *)"Edge_getLength", _wrap_Edge_getLength, METH_VARARGS, NULL},
31692          { (char *)"new_Edge", _wrap_new_Edge, METH_VARARGS, NULL},
31693          { (char *)"delete_Edge", _wrap_delete_Edge, METH_VARARGS, NULL},
31694          { (char *)"Edge_swigregister", Edge_swigregister, METH_VARARGS, NULL},
31695          { (char *)"Quad_getEdge", _wrap_Quad_getEdge, METH_VARARGS, NULL},
31696          { (char *)"Quad_getVertex", _wrap_Quad_getVertex, METH_VARARGS, NULL},
31697          { (char *)"Quad_addAssociation", _wrap_Quad_addAssociation, METH_VARARGS, NULL},
31698          { (char *)"Quad_clearAssociation", _wrap_Quad_clearAssociation, METH_VARARGS, NULL},
31699          { (char *)"Quad_setColor", _wrap_Quad_setColor, METH_VARARGS, NULL},
31700          { (char *)"Quad_nearestVertex", _wrap_Quad_nearestVertex, METH_VARARGS, NULL},
31701          { (char *)"Quad_getCenter", _wrap_Quad_getCenter, METH_VARARGS, NULL},
31702          { (char *)"new_Quad", _wrap_new_Quad, METH_VARARGS, NULL},
31703          { (char *)"delete_Quad", _wrap_delete_Quad, METH_VARARGS, NULL},
31704          { (char *)"Quad_swigregister", Quad_swigregister, METH_VARARGS, NULL},
31705          { (char *)"Hexa_getQuad", _wrap_Hexa_getQuad, METH_VARARGS, NULL},
31706          { (char *)"Hexa_getEdge", _wrap_Hexa_getEdge, METH_VARARGS, NULL},
31707          { (char *)"Hexa_getVertex", _wrap_Hexa_getVertex, METH_VARARGS, NULL},
31708          { (char *)"Hexa_setColor", _wrap_Hexa_setColor, METH_VARARGS, NULL},
31709          { (char *)"new_Hexa", _wrap_new_Hexa, METH_VARARGS, NULL},
31710          { (char *)"delete_Hexa", _wrap_delete_Hexa, METH_VARARGS, NULL},
31711          { (char *)"Hexa_swigregister", Hexa_swigregister, METH_VARARGS, NULL},
31712          { (char *)"Vector_getDx", _wrap_Vector_getDx, METH_VARARGS, NULL},
31713          { (char *)"Vector_getDy", _wrap_Vector_getDy, METH_VARARGS, NULL},
31714          { (char *)"Vector_getDz", _wrap_Vector_getDz, METH_VARARGS, NULL},
31715          { (char *)"Vector_getNorm", _wrap_Vector_getNorm, METH_VARARGS, NULL},
31716          { (char *)"Vector_getAngleX", _wrap_Vector_getAngleX, METH_VARARGS, NULL},
31717          { (char *)"new_Vector", _wrap_new_Vector, METH_VARARGS, NULL},
31718          { (char *)"delete_Vector", _wrap_delete_Vector, METH_VARARGS, NULL},
31719          { (char *)"Vector_swigregister", Vector_swigregister, METH_VARARGS, NULL},
31720          { (char *)"new_Document", _wrap_new_Document, METH_VARARGS, NULL},
31721          { (char *)"Document_dump", _wrap_Document_dump, METH_VARARGS, NULL},
31722          { (char *)"Document_setName", _wrap_Document_setName, METH_VARARGS, NULL},
31723          { (char *)"Document_setLevel", _wrap_Document_setLevel, METH_VARARGS, NULL},
31724          { (char *)"Document_save", _wrap_Document_save, METH_VARARGS, NULL},
31725          { (char *)"Document_saveVtk", _wrap_Document_saveVtk, METH_VARARGS, NULL},
31726          { (char *)"Document_purge", _wrap_Document_purge, METH_VARARGS, NULL},
31727          { (char *)"Document_setTolerance", _wrap_Document_setTolerance, METH_VARARGS, NULL},
31728          { (char *)"Document_getTolerance", _wrap_Document_getTolerance, METH_VARARGS, NULL},
31729          { (char *)"Document_addVertex", _wrap_Document_addVertex, METH_VARARGS, NULL},
31730          { (char *)"Document_addEdge", _wrap_Document_addEdge, METH_VARARGS, NULL},
31731          { (char *)"Document_addEdgeVector", _wrap_Document_addEdgeVector, METH_VARARGS, NULL},
31732          { (char *)"Document_addQuad", _wrap_Document_addQuad, METH_VARARGS, NULL},
31733          { (char *)"Document_addQuadVertices", _wrap_Document_addQuadVertices, METH_VARARGS, NULL},
31734          { (char *)"Document_addHexa", _wrap_Document_addHexa, METH_VARARGS, NULL},
31735          { (char *)"Document_addHexaVertices", _wrap_Document_addHexaVertices, METH_VARARGS, NULL},
31736          { (char *)"Document_addHexa2Quads", _wrap_Document_addHexa2Quads, METH_VARARGS, NULL},
31737          { (char *)"Document_addHexa3Quads", _wrap_Document_addHexa3Quads, METH_VARARGS, NULL},
31738          { (char *)"Document_addHexa4Quads", _wrap_Document_addHexa4Quads, METH_VARARGS, NULL},
31739          { (char *)"Document_addHexa5Quads", _wrap_Document_addHexa5Quads, METH_VARARGS, NULL},
31740          { (char *)"Document_addVector", _wrap_Document_addVector, METH_VARARGS, NULL},
31741          { (char *)"Document_addVectorVertices", _wrap_Document_addVectorVertices, METH_VARARGS, NULL},
31742          { (char *)"Document_addLaws", _wrap_Document_addLaws, METH_VARARGS, NULL},
31743          { (char *)"Document_addHexaGroup", _wrap_Document_addHexaGroup, METH_VARARGS, NULL},
31744          { (char *)"Document_addQuadGroup", _wrap_Document_addQuadGroup, METH_VARARGS, NULL},
31745          { (char *)"Document_addQuadNodeGroup", _wrap_Document_addQuadNodeGroup, METH_VARARGS, NULL},
31746          { (char *)"Document_addHexaNodeGroup", _wrap_Document_addHexaNodeGroup, METH_VARARGS, NULL},
31747          { (char *)"Document_addEdgeGroup", _wrap_Document_addEdgeGroup, METH_VARARGS, NULL},
31748          { (char *)"Document_addEdgeNodeGroup", _wrap_Document_addEdgeNodeGroup, METH_VARARGS, NULL},
31749          { (char *)"Document_addVertexNodeGroup", _wrap_Document_addVertexNodeGroup, METH_VARARGS, NULL},
31750          { (char *)"Document_makeTranslation", _wrap_Document_makeTranslation, METH_VARARGS, NULL},
31751          { (char *)"Document_makeScale", _wrap_Document_makeScale, METH_VARARGS, NULL},
31752          { (char *)"Document_makeRotation", _wrap_Document_makeRotation, METH_VARARGS, NULL},
31753          { (char *)"Document_makeSymmetryPoint", _wrap_Document_makeSymmetryPoint, METH_VARARGS, NULL},
31754          { (char *)"Document_makeSymmetryLine", _wrap_Document_makeSymmetryLine, METH_VARARGS, NULL},
31755          { (char *)"Document_makeSymmetryPlane", _wrap_Document_makeSymmetryPlane, METH_VARARGS, NULL},
31756          { (char *)"Document_performTranslation", _wrap_Document_performTranslation, METH_VARARGS, NULL},
31757          { (char *)"Document_performScale", _wrap_Document_performScale, METH_VARARGS, NULL},
31758          { (char *)"Document_performRotation", _wrap_Document_performRotation, METH_VARARGS, NULL},
31759          { (char *)"Document_performSymmetryPoint", _wrap_Document_performSymmetryPoint, METH_VARARGS, NULL},
31760          { (char *)"Document_performSymmetryLine", _wrap_Document_performSymmetryLine, METH_VARARGS, NULL},
31761          { (char *)"Document_performSymmetryPlane", _wrap_Document_performSymmetryPlane, METH_VARARGS, NULL},
31762          { (char *)"Document_disconnectQuad", _wrap_Document_disconnectQuad, METH_VARARGS, NULL},
31763          { (char *)"Document_disconnectEdge", _wrap_Document_disconnectEdge, METH_VARARGS, NULL},
31764          { (char *)"Document_disconnectVertex", _wrap_Document_disconnectVertex, METH_VARARGS, NULL},
31765          { (char *)"Document_disconnectEdges", _wrap_Document_disconnectEdges, METH_VARARGS, NULL},
31766          { (char *)"Document_replace", _wrap_Document_replace, METH_VARARGS, NULL},
31767          { (char *)"Document_mergeVertices", _wrap_Document_mergeVertices, METH_VARARGS, NULL},
31768          { (char *)"Document_mergeEdges", _wrap_Document_mergeEdges, METH_VARARGS, NULL},
31769          { (char *)"Document_mergeQuads", _wrap_Document_mergeQuads, METH_VARARGS, NULL},
31770          { (char *)"Document_clearAssociation", _wrap_Document_clearAssociation, METH_VARARGS, NULL},
31771          { (char *)"Document_associateOpenedLine", _wrap_Document_associateOpenedLine, METH_VARARGS, NULL},
31772          { (char *)"Document_associateClosedLine", _wrap_Document_associateClosedLine, METH_VARARGS, NULL},
31773          { (char *)"Document_countHexa", _wrap_Document_countHexa, METH_VARARGS, NULL},
31774          { (char *)"Document_countQuad", _wrap_Document_countQuad, METH_VARARGS, NULL},
31775          { (char *)"Document_countEdge", _wrap_Document_countEdge, METH_VARARGS, NULL},
31776          { (char *)"Document_countVertex", _wrap_Document_countVertex, METH_VARARGS, NULL},
31777          { (char *)"Document_countVector", _wrap_Document_countVector, METH_VARARGS, NULL},
31778          { (char *)"Document_countGroup", _wrap_Document_countGroup, METH_VARARGS, NULL},
31779          { (char *)"Document_countLaw", _wrap_Document_countLaw, METH_VARARGS, NULL},
31780          { (char *)"Document_countPropagation", _wrap_Document_countPropagation, METH_VARARGS, NULL},
31781          { (char *)"Document_countShape", _wrap_Document_countShape, METH_VARARGS, NULL},
31782          { (char *)"Document_countUsedHexa", _wrap_Document_countUsedHexa, METH_VARARGS, NULL},
31783          { (char *)"Document_countUsedQuad", _wrap_Document_countUsedQuad, METH_VARARGS, NULL},
31784          { (char *)"Document_countUsedEdge", _wrap_Document_countUsedEdge, METH_VARARGS, NULL},
31785          { (char *)"Document_countUsedVertex", _wrap_Document_countUsedVertex, METH_VARARGS, NULL},
31786          { (char *)"Document_getHexa", _wrap_Document_getHexa, METH_VARARGS, NULL},
31787          { (char *)"Document_getQuad", _wrap_Document_getQuad, METH_VARARGS, NULL},
31788          { (char *)"Document_getEdge", _wrap_Document_getEdge, METH_VARARGS, NULL},
31789          { (char *)"Document_getVertex", _wrap_Document_getVertex, METH_VARARGS, NULL},
31790          { (char *)"Document_getUsedHexa", _wrap_Document_getUsedHexa, METH_VARARGS, NULL},
31791          { (char *)"Document_getUsedQuad", _wrap_Document_getUsedQuad, METH_VARARGS, NULL},
31792          { (char *)"Document_getUsedEdge", _wrap_Document_getUsedEdge, METH_VARARGS, NULL},
31793          { (char *)"Document_getUsedVertex", _wrap_Document_getUsedVertex, METH_VARARGS, NULL},
31794          { (char *)"Document_getVector", _wrap_Document_getVector, METH_VARARGS, NULL},
31795          { (char *)"Document_getShape", _wrap_Document_getShape, METH_VARARGS, NULL},
31796          { (char *)"Document_getGroup", _wrap_Document_getGroup, METH_VARARGS, NULL},
31797          { (char *)"Document_getLaw", _wrap_Document_getLaw, METH_VARARGS, NULL},
31798          { (char *)"Document_getPropagation", _wrap_Document_getPropagation, METH_VARARGS, NULL},
31799          { (char *)"Document_getFirstExplicitShape", _wrap_Document_getFirstExplicitShape, METH_VARARGS, NULL},
31800          { (char *)"Document_findEdge", _wrap_Document_findEdge, METH_VARARGS, NULL},
31801          { (char *)"Document_findQuad", _wrap_Document_findQuad, METH_VARARGS, NULL},
31802          { (char *)"Document_findHexa", _wrap_Document_findHexa, METH_VARARGS, NULL},
31803          { (char *)"Document_findGroup", _wrap_Document_findGroup, METH_VARARGS, NULL},
31804          { (char *)"Document_findLaw", _wrap_Document_findLaw, METH_VARARGS, NULL},
31805          { (char *)"Document_findPropagation", _wrap_Document_findPropagation, METH_VARARGS, NULL},
31806          { (char *)"Document_removeHexa", _wrap_Document_removeHexa, METH_VARARGS, NULL},
31807          { (char *)"Document_removeQuad", _wrap_Document_removeQuad, METH_VARARGS, NULL},
31808          { (char *)"Document_removeConnectedHexa", _wrap_Document_removeConnectedHexa, METH_VARARGS, NULL},
31809          { (char *)"Document_removeElements", _wrap_Document_removeElements, METH_VARARGS, NULL},
31810          { (char *)"Document_removeGroup", _wrap_Document_removeGroup, METH_VARARGS, NULL},
31811          { (char *)"Document_removeLaw", _wrap_Document_removeLaw, METH_VARARGS, NULL},
31812          { (char *)"Document_makeCartesianTop", _wrap_Document_makeCartesianTop, METH_VARARGS, NULL},
31813          { (char *)"Document_makeCartesianUni", _wrap_Document_makeCartesianUni, METH_VARARGS, NULL},
31814          { (char *)"Document_makeCartesian", _wrap_Document_makeCartesian, METH_VARARGS, NULL},
31815          { (char *)"Document_makeCylinderTop", _wrap_Document_makeCylinderTop, METH_VARARGS, NULL},
31816          { (char *)"Document_makeCylinderUni", _wrap_Document_makeCylinderUni, METH_VARARGS, NULL},
31817          { (char *)"Document_makeCylinder", _wrap_Document_makeCylinder, METH_VARARGS, NULL},
31818          { (char *)"Document_makePipeTop", _wrap_Document_makePipeTop, METH_VARARGS, NULL},
31819          { (char *)"Document_makePipeUni", _wrap_Document_makePipeUni, METH_VARARGS, NULL},
31820          { (char *)"Document_makePipe", _wrap_Document_makePipe, METH_VARARGS, NULL},
31821          { (char *)"Document_makeSphericalTop", _wrap_Document_makeSphericalTop, METH_VARARGS, NULL},
31822          { (char *)"Document_makeSphericalUni", _wrap_Document_makeSphericalUni, METH_VARARGS, NULL},
31823          { (char *)"Document_makeSpherical", _wrap_Document_makeSpherical, METH_VARARGS, NULL},
31824          { (char *)"Document_makeSphereTop", _wrap_Document_makeSphereTop, METH_VARARGS, NULL},
31825          { (char *)"Document_makeSphereUni", _wrap_Document_makeSphereUni, METH_VARARGS, NULL},
31826          { (char *)"Document_makeSphere", _wrap_Document_makeSphere, METH_VARARGS, NULL},
31827          { (char *)"Document_makeRindTop", _wrap_Document_makeRindTop, METH_VARARGS, NULL},
31828          { (char *)"Document_makeRindUni", _wrap_Document_makeRindUni, METH_VARARGS, NULL},
31829          { (char *)"Document_makeRind", _wrap_Document_makeRind, METH_VARARGS, NULL},
31830          { (char *)"Document_makeCylinders", _wrap_Document_makeCylinders, METH_VARARGS, NULL},
31831          { (char *)"Document_makePipes", _wrap_Document_makePipes, METH_VARARGS, NULL},
31832          { (char *)"Document_extrudeQuadTop", _wrap_Document_extrudeQuadTop, METH_VARARGS, NULL},
31833          { (char *)"Document_extrudeQuadUni", _wrap_Document_extrudeQuadUni, METH_VARARGS, NULL},
31834          { (char *)"Document_extrudeQuad", _wrap_Document_extrudeQuad, METH_VARARGS, NULL},
31835          { (char *)"Document_extrudeQuadsTop", _wrap_Document_extrudeQuadsTop, METH_VARARGS, NULL},
31836          { (char *)"Document_extrudeQuadsUni", _wrap_Document_extrudeQuadsUni, METH_VARARGS, NULL},
31837          { (char *)"Document_extrudeQuads", _wrap_Document_extrudeQuads, METH_VARARGS, NULL},
31838          { (char *)"Document_revolutionQuadUni", _wrap_Document_revolutionQuadUni, METH_VARARGS, NULL},
31839          { (char *)"Document_revolutionQuad", _wrap_Document_revolutionQuad, METH_VARARGS, NULL},
31840          { (char *)"Document_revolutionQuadsUni", _wrap_Document_revolutionQuadsUni, METH_VARARGS, NULL},
31841          { (char *)"Document_revolutionQuads", _wrap_Document_revolutionQuads, METH_VARARGS, NULL},
31842          { (char *)"Document_joinQuadUni", _wrap_Document_joinQuadUni, METH_VARARGS, NULL},
31843          { (char *)"Document_joinQuadsUni", _wrap_Document_joinQuadsUni, METH_VARARGS, NULL},
31844          { (char *)"Document_joinQuad", _wrap_Document_joinQuad, METH_VARARGS, NULL},
31845          { (char *)"Document_joinQuads", _wrap_Document_joinQuads, METH_VARARGS, NULL},
31846          { (char *)"Document_cutUni", _wrap_Document_cutUni, METH_VARARGS, NULL},
31847          { (char *)"Document_cut", _wrap_Document_cut, METH_VARARGS, NULL},
31848          { (char *)"Document_addGroup", _wrap_Document_addGroup, METH_VARARGS, NULL},
31849          { (char *)"Document_isSaved", _wrap_Document_isSaved, METH_VARARGS, NULL},
31850          { (char *)"Document_appendXml", _wrap_Document_appendXml, METH_VARARGS, NULL},
31851          { (char *)"Document_getXml", _wrap_Document_getXml, METH_VARARGS, NULL},
31852          { (char *)"Document_getLevel", _wrap_Document_getLevel, METH_VARARGS, NULL},
31853          { (char *)"Document_findVertex", _wrap_Document_findVertex, METH_VARARGS, NULL},
31854          { (char *)"Document_closeQuads", _wrap_Document_closeQuads, METH_VARARGS, NULL},
31855          { (char *)"Document_addLaw", _wrap_Document_addLaw, METH_VARARGS, NULL},
31856          { (char *)"Document_checkAssociations", _wrap_Document_checkAssociations, METH_VARARGS, NULL},
31857          { (char *)"Document_addShape", _wrap_Document_addShape, METH_VARARGS, NULL},
31858          { (char *)"delete_Document", _wrap_delete_Document, METH_VARARGS, NULL},
31859          { (char *)"Document_swigregister", Document_swigregister, METH_VARARGS, NULL},
31860          { (char *)"Propagation_getEdges", _wrap_Propagation_getEdges, METH_VARARGS, NULL},
31861          { (char *)"Propagation_getLaw", _wrap_Propagation_getLaw, METH_VARARGS, NULL},
31862          { (char *)"Propagation_getWay", _wrap_Propagation_getWay, METH_VARARGS, NULL},
31863          { (char *)"Propagation_setWay", _wrap_Propagation_setWay, METH_VARARGS, NULL},
31864          { (char *)"Propagation_setLaw", _wrap_Propagation_setLaw, METH_VARARGS, NULL},
31865          { (char *)"new_Propagation", _wrap_new_Propagation, METH_VARARGS, NULL},
31866          { (char *)"Propagation_saveXml", _wrap_Propagation_saveXml, METH_VARARGS, NULL},
31867          { (char *)"Propagation_addEdge", _wrap_Propagation_addEdge, METH_VARARGS, NULL},
31868          { (char *)"Propagation_majLaw", _wrap_Propagation_majLaw, METH_VARARGS, NULL},
31869          { (char *)"delete_Propagation", _wrap_delete_Propagation, METH_VARARGS, NULL},
31870          { (char *)"Propagation_swigregister", Propagation_swigregister, METH_VARARGS, NULL},
31871          { (char *)"hex_instance", _wrap_hex_instance, METH_VARARGS, NULL},
31872          { (char *)"Hex_getInstance", _wrap_Hex_getInstance, METH_VARARGS, NULL},
31873          { (char *)"Hex_countDocument", _wrap_Hex_countDocument, METH_VARARGS, NULL},
31874          { (char *)"Hex_getDocument", _wrap_Hex_getDocument, METH_VARARGS, NULL},
31875          { (char *)"Hex_removeDocument", _wrap_Hex_removeDocument, METH_VARARGS, NULL},
31876          { (char *)"Hex_addDocument", _wrap_Hex_addDocument, METH_VARARGS, NULL},
31877          { (char *)"Hex_loadDocument", _wrap_Hex_loadDocument, METH_VARARGS, NULL},
31878          { (char *)"Hex_findDocument", _wrap_Hex_findDocument, METH_VARARGS, NULL},
31879          { (char *)"Hex_what", _wrap_Hex_what, METH_VARARGS, NULL},
31880          { (char *)"Hex_sizeofMessage", _wrap_Hex_sizeofMessage, METH_VARARGS, NULL},
31881          { (char *)"Hex_getMessageLine", _wrap_Hex_getMessageLine, METH_VARARGS, NULL},
31882          { (char *)"new_Hex", _wrap_new_Hex, METH_VARARGS, NULL},
31883          { (char *)"delete_Hex", _wrap_delete_Hex, METH_VARARGS, NULL},
31884          { (char *)"Hex_swigregister", Hex_swigregister, METH_VARARGS, NULL},
31885          { (char *)"what", _wrap_what, METH_VARARGS, NULL},
31886          { (char *)"Elements_getHexa", _wrap_Elements_getHexa, METH_VARARGS, NULL},
31887          { (char *)"Elements_getQuad", _wrap_Elements_getQuad, METH_VARARGS, NULL},
31888          { (char *)"Elements_getEdge", _wrap_Elements_getEdge, METH_VARARGS, NULL},
31889          { (char *)"Elements_getVertex", _wrap_Elements_getVertex, METH_VARARGS, NULL},
31890          { (char *)"Elements_getHexaIJK", _wrap_Elements_getHexaIJK, METH_VARARGS, NULL},
31891          { (char *)"Elements_getQuadIJ", _wrap_Elements_getQuadIJ, METH_VARARGS, NULL},
31892          { (char *)"Elements_getQuadJK", _wrap_Elements_getQuadJK, METH_VARARGS, NULL},
31893          { (char *)"Elements_getQuadIK", _wrap_Elements_getQuadIK, METH_VARARGS, NULL},
31894          { (char *)"Elements_getEdgeI", _wrap_Elements_getEdgeI, METH_VARARGS, NULL},
31895          { (char *)"Elements_getEdgeJ", _wrap_Elements_getEdgeJ, METH_VARARGS, NULL},
31896          { (char *)"Elements_getEdgeK", _wrap_Elements_getEdgeK, METH_VARARGS, NULL},
31897          { (char *)"Elements_getVertexIJK", _wrap_Elements_getVertexIJK, METH_VARARGS, NULL},
31898          { (char *)"Elements_countHexa", _wrap_Elements_countHexa, METH_VARARGS, NULL},
31899          { (char *)"Elements_countQuad", _wrap_Elements_countQuad, METH_VARARGS, NULL},
31900          { (char *)"Elements_countEdge", _wrap_Elements_countEdge, METH_VARARGS, NULL},
31901          { (char *)"Elements_countVertex", _wrap_Elements_countVertex, METH_VARARGS, NULL},
31902          { (char *)"Elements_nearestVertex", _wrap_Elements_nearestVertex, METH_VARARGS, NULL},
31903          { (char *)"Elements_findVertex", _wrap_Elements_findVertex, METH_VARARGS, NULL},
31904          { (char *)"Elements_clearAssociation", _wrap_Elements_clearAssociation, METH_VARARGS, NULL},
31905          { (char *)"Elements_saveVtk", _wrap_Elements_saveVtk, METH_VARARGS, NULL},
31906          { (char *)"new_Elements", _wrap_new_Elements, METH_VARARGS, NULL},
31907          { (char *)"delete_Elements", _wrap_delete_Elements, METH_VARARGS, NULL},
31908          { (char *)"Elements_swigregister", Elements_swigregister, METH_VARARGS, NULL},
31909          { (char *)"new_BiCylinder", _wrap_new_BiCylinder, METH_VARARGS, NULL},
31910          { (char *)"BiCylinder_getHexaIJK", _wrap_BiCylinder_getHexaIJK, METH_VARARGS, NULL},
31911          { (char *)"BiCylinder_getQuadIJ", _wrap_BiCylinder_getQuadIJ, METH_VARARGS, NULL},
31912          { (char *)"BiCylinder_getQuadJK", _wrap_BiCylinder_getQuadJK, METH_VARARGS, NULL},
31913          { (char *)"BiCylinder_getQuadIK", _wrap_BiCylinder_getQuadIK, METH_VARARGS, NULL},
31914          { (char *)"BiCylinder_getEdgeI", _wrap_BiCylinder_getEdgeI, METH_VARARGS, NULL},
31915          { (char *)"BiCylinder_getEdgeJ", _wrap_BiCylinder_getEdgeJ, METH_VARARGS, NULL},
31916          { (char *)"BiCylinder_getEdgeK", _wrap_BiCylinder_getEdgeK, METH_VARARGS, NULL},
31917          { (char *)"BiCylinder_getVertexIJK", _wrap_BiCylinder_getVertexIJK, METH_VARARGS, NULL},
31918          { (char *)"delete_BiCylinder", _wrap_delete_BiCylinder, METH_VARARGS, NULL},
31919          { (char *)"BiCylinder_swigregister", BiCylinder_swigregister, METH_VARARGS, NULL},
31920          { (char *)"NewShape_countVertex", _wrap_NewShape_countVertex, METH_VARARGS, NULL},
31921          { (char *)"NewShape_countEdge", _wrap_NewShape_countEdge, METH_VARARGS, NULL},
31922          { (char *)"NewShape_countFace", _wrap_NewShape_countFace, METH_VARARGS, NULL},
31923          { (char *)"NewShape_getVertex", _wrap_NewShape_getVertex, METH_VARARGS, NULL},
31924          { (char *)"NewShape_getEdge", _wrap_NewShape_getEdge, METH_VARARGS, NULL},
31925          { (char *)"NewShape_getFace", _wrap_NewShape_getFace, METH_VARARGS, NULL},
31926          { (char *)"NewShape_getNameVertex", _wrap_NewShape_getNameVertex, METH_VARARGS, NULL},
31927          { (char *)"NewShape_getNameEdge", _wrap_NewShape_getNameEdge, METH_VARARGS, NULL},
31928          { (char *)"NewShape_getNameFace", _wrap_NewShape_getNameFace, METH_VARARGS, NULL},
31929          { (char *)"new_NewShape", _wrap_new_NewShape, METH_VARARGS, NULL},
31930          { (char *)"delete_NewShape", _wrap_delete_NewShape, METH_VARARGS, NULL},
31931          { (char *)"NewShape_swigregister", NewShape_swigregister, METH_VARARGS, NULL},
31932          { (char *)"Group_addElement", _wrap_Group_addElement, METH_VARARGS, NULL},
31933          { (char *)"Group_countElement", _wrap_Group_countElement, METH_VARARGS, NULL},
31934          { (char *)"Group_getKind", _wrap_Group_getKind, METH_VARARGS, NULL},
31935          { (char *)"Group_clearElement", _wrap_Group_clearElement, METH_VARARGS, NULL},
31936          { (char *)"Group_removeElement", _wrap_Group_removeElement, METH_VARARGS, NULL},
31937          { (char *)"Group_getElement", _wrap_Group_getElement, METH_VARARGS, NULL},
31938          { (char *)"new_Group", _wrap_new_Group, METH_VARARGS, NULL},
31939          { (char *)"delete_Group", _wrap_delete_Group, METH_VARARGS, NULL},
31940          { (char *)"Group_swigregister", Group_swigregister, METH_VARARGS, NULL},
31941          { NULL, NULL, 0, NULL }
31942 };
31943
31944
31945 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31946
31947 static void *_p_Hex__VectorTo_p_Hex__EltBase(void *x) {
31948     return (void *)((Hex::EltBase *)  ((Hex::Vector *) x));
31949 }
31950 static void *_p_Hex__NewShapeTo_p_Hex__EltBase(void *x) {
31951     return (void *)((Hex::EltBase *)  ((Hex::NewShape *) x));
31952 }
31953 static void *_p_Hex__GroupTo_p_Hex__EltBase(void *x) {
31954     return (void *)((Hex::EltBase *)  ((Hex::Group *) x));
31955 }
31956 static void *_p_Hex__PropagationTo_p_Hex__EltBase(void *x) {
31957     return (void *)((Hex::EltBase *)  ((Hex::Propagation *) x));
31958 }
31959 static void *_p_Hex__VertexTo_p_Hex__EltBase(void *x) {
31960     return (void *)((Hex::EltBase *)  ((Hex::Vertex *) x));
31961 }
31962 static void *_p_Hex__HexaTo_p_Hex__EltBase(void *x) {
31963     return (void *)((Hex::EltBase *)  ((Hex::Hexa *) x));
31964 }
31965 static void *_p_Hex__EdgeTo_p_Hex__EltBase(void *x) {
31966     return (void *)((Hex::EltBase *)  ((Hex::Edge *) x));
31967 }
31968 static void *_p_Hex__QuadTo_p_Hex__EltBase(void *x) {
31969     return (void *)((Hex::EltBase *)  ((Hex::Quad *) x));
31970 }
31971 static void *_p_Hex__ElementsTo_p_Hex__EltBase(void *x) {
31972     return (void *)((Hex::EltBase *)  ((Hex::Elements *) x));
31973 }
31974 static void *_p_Hex__DocumentTo_p_Hex__EltBase(void *x) {
31975     return (void *)((Hex::EltBase *)  ((Hex::Document *) x));
31976 }
31977 static void *_p_Hex__BiCylinderTo_p_Hex__EltBase(void *x) {
31978     return (void *)((Hex::EltBase *) (Hex::Elements *) ((Hex::BiCylinder *) x));
31979 }
31980 static void *_p_Hex__BiCylinderTo_p_Hex__Elements(void *x) {
31981     return (void *)((Hex::Elements *)  ((Hex::BiCylinder *) x));
31982 }
31983 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *|pfile", 0, 0, (void*)0, 0};
31984 static swig_type_info _swigt__p_Hex__BiCylinder = {"_p_Hex__BiCylinder", "Hex::BiCylinder *", 0, 0, (void*)0, 0};
31985 static swig_type_info _swigt__p_Hex__Document = {"_p_Hex__Document", "Hex::Document *", 0, 0, (void*)0, 0};
31986 static swig_type_info _swigt__p_Hex__Edge = {"_p_Hex__Edge", "Hex::Edge *", 0, 0, (void*)0, 0};
31987 static swig_type_info _swigt__p_Hex__Elements = {"_p_Hex__Elements", "Hex::Elements *", 0, 0, (void*)0, 0};
31988 static swig_type_info _swigt__p_Hex__EltBase = {"_p_Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
31989 static swig_type_info _swigt__p_Hex__Group = {"_p_Hex__Group", "Hex::Group *", 0, 0, (void*)0, 0};
31990 static swig_type_info _swigt__p_Hex__Hex = {"_p_Hex__Hex", "Hex::Hex *", 0, 0, (void*)0, 0};
31991 static swig_type_info _swigt__p_Hex__Hex__EltBase = {"_p_Hex__Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
31992 static swig_type_info _swigt__p_Hex__Hexa = {"_p_Hex__Hexa", "Hex::Hexa *", 0, 0, (void*)0, 0};
31993 static swig_type_info _swigt__p_Hex__Law = {"_p_Hex__Law", "Hex::Law *", 0, 0, (void*)0, 0};
31994 static swig_type_info _swigt__p_Hex__NewShape = {"_p_Hex__NewShape", "Hex::NewShape *", 0, 0, (void*)0, 0};
31995 static swig_type_info _swigt__p_Hex__Propagation = {"_p_Hex__Propagation", "Hex::Propagation *", 0, 0, (void*)0, 0};
31996 static swig_type_info _swigt__p_Hex__Quad = {"_p_Hex__Quad", "Hex::Quad *", 0, 0, (void*)0, 0};
31997 static swig_type_info _swigt__p_Hex__Shape = {"_p_Hex__Shape", "Hex::Shape *|Hex::OldShape *", 0, 0, (void*)0, 0};
31998 static swig_type_info _swigt__p_Hex__Vector = {"_p_Hex__Vector", "Hex::Vector *", 0, 0, (void*)0, 0};
31999 static swig_type_info _swigt__p_Hex__Vertex = {"_p_Hex__Vertex", "Hex::Vertex *", 0, 0, (void*)0, 0};
32000 static swig_type_info _swigt__p_Hex__XmlWriter = {"_p_Hex__XmlWriter", "Hex::XmlWriter *", 0, 0, (void*)0, 0};
32001 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};
32002 static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
32003 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
32004 static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
32005 static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
32006 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
32007 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
32008 static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
32009 static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
32010 static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
32011 static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
32012 static swig_type_info _swigt__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t = {"_p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t", "std::vector<Hex::AssoEdge *,std::allocator<Hex::AssoEdge * > > *|Hex::AssoEdges *", 0, 0, (void*)0, 0};
32013 static swig_type_info _swigt__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t = {"_p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t", "std::vector<Hex::EdgeShape *,std::allocator<Hex::EdgeShape * > > *|Hex::EdgeShapes *", 0, 0, (void*)0, 0};
32014 static swig_type_info _swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t = {"_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t", "std::vector<Hex::Edge *,std::allocator<Hex::Edge * > > *|Hex::Edges *", 0, 0, (void*)0, 0};
32015 static swig_type_info _swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type = {"_p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type", "std::allocator<Hex::Edge * > *|std::vector<Hex::Edge * >::allocator_type *", 0, 0, (void*)0, 0};
32016 static swig_type_info _swigt__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t = {"_p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t", "std::vector<Hex::EltBase *,std::allocator<Hex::EltBase * > > *|Hex::TabElts *", 0, 0, (void*)0, 0};
32017 static swig_type_info _swigt__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t = {"_p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t", "std::vector<Hex::FaceShape *,std::allocator<Hex::FaceShape * > > *|Hex::FaceShapes *", 0, 0, (void*)0, 0};
32018 static swig_type_info _swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t = {"_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t", "std::vector<Hex::Hexa *,std::allocator<Hex::Hexa * > > *|Hex::Hexas *", 0, 0, (void*)0, 0};
32019 static swig_type_info _swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type = {"_p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type", "std::allocator<Hex::Hexa * > *|std::vector<Hex::Hexa * >::allocator_type *", 0, 0, (void*)0, 0};
32020 static swig_type_info _swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t = {"_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t", "std::vector<Hex::NewShape *,std::allocator<Hex::NewShape * > > *|Hex::NewShapes *", 0, 0, (void*)0, 0};
32021 static swig_type_info _swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type = {"_p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type", "std::allocator<Hex::NewShape * > *|std::vector<Hex::NewShape * >::allocator_type *", 0, 0, (void*)0, 0};
32022 static swig_type_info _swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t = {"_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t", "std::vector<Hex::Quad *,std::allocator<Hex::Quad * > > *|Hex::Quads *", 0, 0, (void*)0, 0};
32023 static swig_type_info _swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type = {"_p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type", "std::allocator<Hex::Quad * > *|std::vector<Hex::Quad * >::allocator_type *", 0, 0, (void*)0, 0};
32024 static swig_type_info _swigt__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t = {"_p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t", "std::vector<Hex::Shape *,std::allocator<Hex::Shape * > > *|Hex::Shapes *", 0, 0, (void*)0, 0};
32025 static swig_type_info _swigt__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t = {"_p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t", "std::vector<Hex::SubShape *,std::allocator<Hex::SubShape * > > *|Hex::SubShapes *", 0, 0, (void*)0, 0};
32026 static swig_type_info _swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t = {"_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t", "std::vector<Hex::Vertex *,std::allocator<Hex::Vertex * > > *|Hex::Vertices *", 0, 0, (void*)0, 0};
32027 static swig_type_info _swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type = {"_p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type", "std::allocator<Hex::Vertex * > *|std::vector<Hex::Vertex * >::allocator_type *", 0, 0, (void*)0, 0};
32028 static swig_type_info _swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t = {"_p_std__vectorTdouble_std__allocatorTdouble_t_t", "std::vector<double,std::allocator<double > > *|Hex::RealVector *", 0, 0, (void*)0, 0};
32029 static swig_type_info _swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type = {"_p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type", "std::allocator<double > *|std::vector<double >::allocator_type *", 0, 0, (void*)0, 0};
32030 static swig_type_info _swigt__p_std__vectorTint_std__allocatorTint_t_t = {"_p_std__vectorTint_std__allocatorTint_t_t", "std::vector<int,std::allocator<int > > *|Hex::IntVector *", 0, 0, (void*)0, 0};
32031 static swig_type_info _swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type = {"_p_std__vectorTint_std__allocatorTint_t_t__allocator_type", "std::allocator<int > *|std::vector<int >::allocator_type *", 0, 0, (void*)0, 0};
32032 static swig_type_info _swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t = {"_p_std__vectorTstd__string_std__allocatorTstd__string_t_t", "std::vector<std::string,std::allocator<std::string > > *|Hex::TabText *", 0, 0, (void*)0, 0};
32033 static swig_type_info _swigt__p_string = {"_p_string", "string *", 0, 0, (void*)0, 0};
32034 static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
32035 static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
32036 static swig_type_info _swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type = {"_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type", "Hex::Edge *|std::vector<Hex::Edge * >::value_type", 0, 0, (void*)0, 0};
32037 static swig_type_info _swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type = {"_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type", "Hex::Hexa *|std::vector<Hex::Hexa * >::value_type", 0, 0, (void*)0, 0};
32038 static swig_type_info _swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type = {"_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type", "Hex::NewShape *|std::vector<Hex::NewShape * >::value_type", 0, 0, (void*)0, 0};
32039 static swig_type_info _swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type = {"_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type", "Hex::Quad *|std::vector<Hex::Quad * >::value_type", 0, 0, (void*)0, 0};
32040 static swig_type_info _swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type = {"_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type", "Hex::Vertex *|std::vector<Hex::Vertex * >::value_type", 0, 0, (void*)0, 0};
32041
32042 static swig_type_info *swig_type_initial[] = {
32043   &_swigt__p_FILE,
32044   &_swigt__p_Hex__BiCylinder,
32045   &_swigt__p_Hex__Document,
32046   &_swigt__p_Hex__Edge,
32047   &_swigt__p_Hex__Elements,
32048   &_swigt__p_Hex__EltBase,
32049   &_swigt__p_Hex__Group,
32050   &_swigt__p_Hex__Hex,
32051   &_swigt__p_Hex__Hex__EltBase,
32052   &_swigt__p_Hex__Hexa,
32053   &_swigt__p_Hex__Law,
32054   &_swigt__p_Hex__NewShape,
32055   &_swigt__p_Hex__Propagation,
32056   &_swigt__p_Hex__Quad,
32057   &_swigt__p_Hex__Shape,
32058   &_swigt__p_Hex__Vector,
32059   &_swigt__p_Hex__Vertex,
32060   &_swigt__p_Hex__XmlWriter,
32061   &_swigt__p_a_Hex__DIM3__double,
32062   &_swigt__p_allocator_type,
32063   &_swigt__p_char,
32064   &_swigt__p_const_reference,
32065   &_swigt__p_difference_type,
32066   &_swigt__p_double,
32067   &_swigt__p_int,
32068   &_swigt__p_p_PyObject,
32069   &_swigt__p_reference,
32070   &_swigt__p_size_type,
32071   &_swigt__p_std__invalid_argument,
32072   &_swigt__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t,
32073   &_swigt__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t,
32074   &_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t,
32075   &_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type,
32076   &_swigt__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t,
32077   &_swigt__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t,
32078   &_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t,
32079   &_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type,
32080   &_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t,
32081   &_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type,
32082   &_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t,
32083   &_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type,
32084   &_swigt__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t,
32085   &_swigt__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t,
32086   &_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t,
32087   &_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type,
32088   &_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t,
32089   &_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type,
32090   &_swigt__p_std__vectorTint_std__allocatorTint_t_t,
32091   &_swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type,
32092   &_swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t,
32093   &_swigt__p_string,
32094   &_swigt__p_swig__PySwigIterator,
32095   &_swigt__p_value_type,
32096   &_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type,
32097   &_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type,
32098   &_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type,
32099   &_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type,
32100   &_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type,
32101 };
32102
32103 static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
32104 static swig_cast_info _swigc__p_Hex__BiCylinder[] = {  {&_swigt__p_Hex__BiCylinder, 0, 0, 0},{0, 0, 0, 0}};
32105 static swig_cast_info _swigc__p_Hex__Document[] = {  {&_swigt__p_Hex__Document, 0, 0, 0},{0, 0, 0, 0}};
32106 static swig_cast_info _swigc__p_Hex__Edge[] = {  {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
32107 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}};
32108 static swig_cast_info _swigc__p_Hex__EltBase[] = {  {&_swigt__p_Hex__Group, _p_Hex__GroupTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Vertex, _p_Hex__VertexTo_p_Hex__EltBase, 0, 0},  {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, _p_Hex__NewShapeTo_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__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, _p_Hex__HexaTo_p_Hex__EltBase, 0, 0},  {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, _p_Hex__VertexTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Propagation, _p_Hex__PropagationTo_p_Hex__EltBase, 0, 0},  {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, _p_Hex__QuadTo_p_Hex__EltBase, 0, 0},  {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, _p_Hex__EdgeTo_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__Quad, _p_Hex__QuadTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Edge, _p_Hex__EdgeTo_p_Hex__EltBase, 0, 0},{0, 0, 0, 0}};
32109 static swig_cast_info _swigc__p_Hex__Group[] = {  {&_swigt__p_Hex__Group, 0, 0, 0},{0, 0, 0, 0}};
32110 static swig_cast_info _swigc__p_Hex__Hex[] = {  {&_swigt__p_Hex__Hex, 0, 0, 0},{0, 0, 0, 0}};
32111 static swig_cast_info _swigc__p_Hex__Hex__EltBase[] = {  {&_swigt__p_Hex__Group, 0, 0, 0},  {&_swigt__p_Hex__Vertex, 0, 0, 0},  {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 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__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0, 0, 0},  {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Propagation, 0, 0, 0},  {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0, 0, 0},  {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 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__Quad, 0, 0, 0},  {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
32112 static swig_cast_info _swigc__p_Hex__Hexa[] = {  {&_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
32113 static swig_cast_info _swigc__p_Hex__Law[] = {  {&_swigt__p_Hex__Law, 0, 0, 0},{0, 0, 0, 0}};
32114 static swig_cast_info _swigc__p_Hex__NewShape[] = {  {&_swigt__p_Hex__NewShape, 0, 0, 0},  {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
32115 static swig_cast_info _swigc__p_Hex__Propagation[] = {  {&_swigt__p_Hex__Propagation, 0, 0, 0},{0, 0, 0, 0}};
32116 static swig_cast_info _swigc__p_Hex__Quad[] = {  {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
32117 static swig_cast_info _swigc__p_Hex__Shape[] = {  {&_swigt__p_Hex__Shape, 0, 0, 0},{0, 0, 0, 0}};
32118 static swig_cast_info _swigc__p_Hex__Vector[] = {  {&_swigt__p_Hex__Vector, 0, 0, 0},{0, 0, 0, 0}};
32119 static swig_cast_info _swigc__p_Hex__Vertex[] = {  {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
32120 static swig_cast_info _swigc__p_Hex__XmlWriter[] = {  {&_swigt__p_Hex__XmlWriter, 0, 0, 0},{0, 0, 0, 0}};
32121 static swig_cast_info _swigc__p_a_Hex__DIM3__double[] = {  {&_swigt__p_a_Hex__DIM3__double, 0, 0, 0},{0, 0, 0, 0}};
32122 static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32123 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
32124 static swig_cast_info _swigc__p_const_reference[] = {  {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
32125 static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
32126 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
32127 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
32128 static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
32129 static swig_cast_info _swigc__p_reference[] = {  {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
32130 static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
32131 static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
32132 static swig_cast_info _swigc__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t[] = {  {&_swigt__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32133 static swig_cast_info _swigc__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t[] = {  {&_swigt__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32134 static swig_cast_info _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t[] = {  {&_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32135 static swig_cast_info _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32136 static swig_cast_info _swigc__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t[] = {  {&_swigt__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32137 static swig_cast_info _swigc__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t[] = {  {&_swigt__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32138 static swig_cast_info _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t[] = {  {&_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32139 static swig_cast_info _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32140 static swig_cast_info _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t[] = {  {&_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32141 static swig_cast_info _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32142 static swig_cast_info _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t[] = {  {&_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32143 static swig_cast_info _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32144 static swig_cast_info _swigc__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t[] = {  {&_swigt__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32145 static swig_cast_info _swigc__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t[] = {  {&_swigt__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32146 static swig_cast_info _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t[] = {  {&_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
32147 static swig_cast_info _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32148 static swig_cast_info _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t[] = {  {&_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t, 0, 0, 0},{0, 0, 0, 0}};
32149 static swig_cast_info _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32150 static swig_cast_info _swigc__p_std__vectorTint_std__allocatorTint_t_t[] = {  {&_swigt__p_std__vectorTint_std__allocatorTint_t_t, 0, 0, 0},{0, 0, 0, 0}};
32151 static swig_cast_info _swigc__p_std__vectorTint_std__allocatorTint_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32152 static swig_cast_info _swigc__p_std__vectorTstd__string_std__allocatorTstd__string_t_t[] = {  {&_swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
32153 static swig_cast_info _swigc__p_string[] = {  {&_swigt__p_string, 0, 0, 0},{0, 0, 0, 0}};
32154 static swig_cast_info _swigc__p_swig__PySwigIterator[] = {  {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
32155 static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
32156 static swig_cast_info _swigc__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type[] = {  {&_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
32157 static swig_cast_info _swigc__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type[] = {  {&_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
32158 static swig_cast_info _swigc__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type[] = {  {&_swigt__p_Hex__NewShape, 0, 0, 0},  {&_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
32159 static swig_cast_info _swigc__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type[] = {  {&_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
32160 static swig_cast_info _swigc__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type[] = {  {&_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
32161
32162 static swig_cast_info *swig_cast_initial[] = {
32163   _swigc__p_FILE,
32164   _swigc__p_Hex__BiCylinder,
32165   _swigc__p_Hex__Document,
32166   _swigc__p_Hex__Edge,
32167   _swigc__p_Hex__Elements,
32168   _swigc__p_Hex__EltBase,
32169   _swigc__p_Hex__Group,
32170   _swigc__p_Hex__Hex,
32171   _swigc__p_Hex__Hex__EltBase,
32172   _swigc__p_Hex__Hexa,
32173   _swigc__p_Hex__Law,
32174   _swigc__p_Hex__NewShape,
32175   _swigc__p_Hex__Propagation,
32176   _swigc__p_Hex__Quad,
32177   _swigc__p_Hex__Shape,
32178   _swigc__p_Hex__Vector,
32179   _swigc__p_Hex__Vertex,
32180   _swigc__p_Hex__XmlWriter,
32181   _swigc__p_a_Hex__DIM3__double,
32182   _swigc__p_allocator_type,
32183   _swigc__p_char,
32184   _swigc__p_const_reference,
32185   _swigc__p_difference_type,
32186   _swigc__p_double,
32187   _swigc__p_int,
32188   _swigc__p_p_PyObject,
32189   _swigc__p_reference,
32190   _swigc__p_size_type,
32191   _swigc__p_std__invalid_argument,
32192   _swigc__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t,
32193   _swigc__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t,
32194   _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t,
32195   _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type,
32196   _swigc__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t,
32197   _swigc__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t,
32198   _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t,
32199   _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type,
32200   _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t,
32201   _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type,
32202   _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t,
32203   _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type,
32204   _swigc__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t,
32205   _swigc__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t,
32206   _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t,
32207   _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type,
32208   _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t,
32209   _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type,
32210   _swigc__p_std__vectorTint_std__allocatorTint_t_t,
32211   _swigc__p_std__vectorTint_std__allocatorTint_t_t__allocator_type,
32212   _swigc__p_std__vectorTstd__string_std__allocatorTstd__string_t_t,
32213   _swigc__p_string,
32214   _swigc__p_swig__PySwigIterator,
32215   _swigc__p_value_type,
32216   _swigc__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type,
32217   _swigc__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type,
32218   _swigc__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type,
32219   _swigc__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type,
32220   _swigc__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type,
32221 };
32222
32223
32224 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32225
32226 static swig_const_info swig_const_table[] = {
32227 {0, 0, 0, 0.0, 0, 0}};
32228
32229 #ifdef __cplusplus
32230 }
32231 #endif
32232 /* -----------------------------------------------------------------------------
32233  * Type initialization:
32234  * This problem is tough by the requirement that no dynamic
32235  * memory is used. Also, since swig_type_info structures store pointers to
32236  * swig_cast_info structures and swig_cast_info structures store pointers back
32237  * to swig_type_info structures, we need some lookup code at initialization.
32238  * The idea is that swig generates all the structures that are needed.
32239  * The runtime then collects these partially filled structures.
32240  * The SWIG_InitializeModule function takes these initial arrays out of
32241  * swig_module, and does all the lookup, filling in the swig_module.types
32242  * array with the correct data and linking the correct swig_cast_info
32243  * structures together.
32244  *
32245  * The generated swig_type_info structures are assigned staticly to an initial
32246  * array. We just loop through that array, and handle each type individually.
32247  * First we lookup if this type has been already loaded, and if so, use the
32248  * loaded structure instead of the generated one. Then we have to fill in the
32249  * cast linked list. The cast data is initially stored in something like a
32250  * two-dimensional array. Each row corresponds to a type (there are the same
32251  * number of rows as there are in the swig_type_initial array). Each entry in
32252  * a column is one of the swig_cast_info structures for that type.
32253  * The cast_initial array is actually an array of arrays, because each row has
32254  * a variable number of columns. So to actually build the cast linked list,
32255  * we find the array of casts associated with the type, and loop through it
32256  * adding the casts to the list. The one last trick we need to do is making
32257  * sure the type pointer in the swig_cast_info struct is correct.
32258  *
32259  * First off, we lookup the cast->type name to see if it is already loaded.
32260  * There are three cases to handle:
32261  *  1) If the cast->type has already been loaded AND the type we are adding
32262  *     casting info to has not been loaded (it is in this module), THEN we
32263  *     replace the cast->type pointer with the type pointer that has already
32264  *     been loaded.
32265  *  2) If BOTH types (the one we are adding casting info to, and the
32266  *     cast->type) are loaded, THEN the cast info has already been loaded by
32267  *     the previous module so we just ignore it.
32268  *  3) Finally, if cast->type has not already been loaded, then we add that
32269  *     swig_cast_info to the linked list (because the cast->type) pointer will
32270  *     be correct.
32271  * ----------------------------------------------------------------------------- */
32272
32273 #ifdef __cplusplus
32274 extern "C" {
32275 #if 0
32276 } /* c-mode */
32277 #endif
32278 #endif
32279
32280 #if 0
32281 #define SWIGRUNTIME_DEBUG
32282 #endif
32283
32284
32285 SWIGRUNTIME void
32286 SWIG_InitializeModule(void *clientdata) {
32287   size_t i;
32288   swig_module_info *module_head, *iter;
32289   int found;
32290
32291   clientdata = clientdata;
32292
32293   /* check to see if the circular list has been setup, if not, set it up */
32294   if (swig_module.next==0) {
32295     /* Initialize the swig_module */
32296     swig_module.type_initial = swig_type_initial;
32297     swig_module.cast_initial = swig_cast_initial;
32298     swig_module.next = &swig_module;
32299   }
32300
32301   /* Try and load any already created modules */
32302   module_head = SWIG_GetModule(clientdata);
32303   if (!module_head) {
32304     /* This is the first module loaded for this interpreter */
32305     /* so set the swig module into the interpreter */
32306     SWIG_SetModule(clientdata, &swig_module);
32307     module_head = &swig_module;
32308   } else {
32309     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
32310     found=0;
32311     iter=module_head;
32312     do {
32313       if (iter==&swig_module) {
32314         found=1;
32315         break;
32316       }
32317       iter=iter->next;
32318     } while (iter!= module_head);
32319
32320     /* if the is found in the list, then all is done and we may leave */
32321     if (found) return;
32322     /* otherwise we must add out module into the list */
32323     swig_module.next = module_head->next;
32324     module_head->next = &swig_module;
32325   }
32326
32327   /* Now work on filling in swig_module.types */
32328 #ifdef SWIGRUNTIME_DEBUG
32329   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
32330 #endif
32331   for (i = 0; i < swig_module.size; ++i) {
32332     swig_type_info *type = 0;
32333     swig_type_info *ret;
32334     swig_cast_info *cast;
32335
32336 #ifdef SWIGRUNTIME_DEBUG
32337     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
32338 #endif
32339
32340     /* if there is another module already loaded */
32341     if (swig_module.next != &swig_module) {
32342       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
32343     }
32344     if (type) {
32345       /* Overwrite clientdata field */
32346 #ifdef SWIGRUNTIME_DEBUG
32347       printf("SWIG_InitializeModule: found type %s\n", type->name);
32348 #endif
32349       if (swig_module.type_initial[i]->clientdata) {
32350         type->clientdata = swig_module.type_initial[i]->clientdata;
32351 #ifdef SWIGRUNTIME_DEBUG
32352         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
32353 #endif
32354       }
32355     } else {
32356       type = swig_module.type_initial[i];
32357     }
32358
32359     /* Insert casting types */
32360     cast = swig_module.cast_initial[i];
32361     while (cast->type) {
32362       /* Don't need to add information already in the list */
32363       ret = 0;
32364 #ifdef SWIGRUNTIME_DEBUG
32365       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
32366 #endif
32367       if (swig_module.next != &swig_module) {
32368         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
32369 #ifdef SWIGRUNTIME_DEBUG
32370         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
32371 #endif
32372       }
32373       if (ret) {
32374         if (type == swig_module.type_initial[i]) {
32375 #ifdef SWIGRUNTIME_DEBUG
32376           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
32377 #endif
32378           cast->type = ret;
32379           ret = 0;
32380         } else {
32381           /* Check for casting already in the list */
32382           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
32383 #ifdef SWIGRUNTIME_DEBUG
32384           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
32385 #endif
32386           if (!ocast) ret = 0;
32387         }
32388       }
32389
32390       if (!ret) {
32391 #ifdef SWIGRUNTIME_DEBUG
32392         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
32393 #endif
32394         if (type->cast) {
32395           type->cast->prev = cast;
32396           cast->next = type->cast;
32397         }
32398         type->cast = cast;
32399       }
32400       cast++;
32401     }
32402     /* Set entry in modules->types array equal to the type */
32403     swig_module.types[i] = type;
32404   }
32405   swig_module.types[i] = 0;
32406
32407 #ifdef SWIGRUNTIME_DEBUG
32408   printf("**** SWIG_InitializeModule: Cast List ******\n");
32409   for (i = 0; i < swig_module.size; ++i) {
32410     int j = 0;
32411     swig_cast_info *cast = swig_module.cast_initial[i];
32412     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
32413     while (cast->type) {
32414       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
32415       cast++;
32416       ++j;
32417     }
32418     printf("---- Total casts: %d\n",j);
32419   }
32420   printf("**** SWIG_InitializeModule: Cast List ******\n");
32421 #endif
32422 }
32423
32424 /* This function will propagate the clientdata field of type to
32425 * any new swig_type_info structures that have been added into the list
32426 * of equivalent types.  It is like calling
32427 * SWIG_TypeClientData(type, clientdata) a second time.
32428 */
32429 SWIGRUNTIME void
32430 SWIG_PropagateClientData(void) {
32431   size_t i;
32432   swig_cast_info *equiv;
32433   static int init_run = 0;
32434
32435   if (init_run) return;
32436   init_run = 1;
32437
32438   for (i = 0; i < swig_module.size; i++) {
32439     if (swig_module.types[i]->clientdata) {
32440       equiv = swig_module.types[i]->cast;
32441       while (equiv) {
32442         if (!equiv->converter) {
32443           if (equiv->type && !equiv->type->clientdata)
32444           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
32445         }
32446         equiv = equiv->next;
32447       }
32448     }
32449   }
32450 }
32451
32452 #ifdef __cplusplus
32453 #if 0
32454 {
32455   /* c-mode */
32456 #endif
32457 }
32458 #endif
32459
32460
32461
32462 #ifdef __cplusplus
32463 extern "C" {
32464 #endif
32465
32466   /* Python-specific SWIG API */
32467 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
32468 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32469 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
32470
32471   /* -----------------------------------------------------------------------------
32472    * global variable support code.
32473    * ----------------------------------------------------------------------------- */
32474
32475   typedef struct swig_globalvar {
32476     char       *name;                  /* Name of global variable */
32477     PyObject *(*get_attr)(void);       /* Return the current value */
32478     int       (*set_attr)(PyObject *); /* Set the value */
32479     struct swig_globalvar *next;
32480   } swig_globalvar;
32481
32482   typedef struct swig_varlinkobject {
32483     PyObject_HEAD
32484     swig_globalvar *vars;
32485   } swig_varlinkobject;
32486
32487   SWIGINTERN PyObject *
32488   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
32489     return PyString_FromString("<Swig global variables>");
32490   }
32491
32492   SWIGINTERN PyObject *
32493   swig_varlink_str(swig_varlinkobject *v) {
32494     PyObject *str = PyString_FromString("(");
32495     swig_globalvar  *var;
32496     for (var = v->vars; var; var=var->next) {
32497       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
32498       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
32499     }
32500     PyString_ConcatAndDel(&str,PyString_FromString(")"));
32501     return str;
32502   }
32503
32504   SWIGINTERN int
32505   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
32506     PyObject *str = swig_varlink_str(v);
32507     fprintf(fp,"Swig global variables ");
32508     fprintf(fp,"%s\n", PyString_AsString(str));
32509     Py_DECREF(str);
32510     return 0;
32511   }
32512
32513   SWIGINTERN void
32514   swig_varlink_dealloc(swig_varlinkobject *v) {
32515     swig_globalvar *var = v->vars;
32516     while (var) {
32517       swig_globalvar *n = var->next;
32518       free(var->name);
32519       free(var);
32520       var = n;
32521     }
32522   }
32523
32524   SWIGINTERN PyObject *
32525   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32526     PyObject *res = NULL;
32527     swig_globalvar *var = v->vars;
32528     while (var) {
32529       if (strcmp(var->name,n) == 0) {
32530         res = (*var->get_attr)();
32531         break;
32532       }
32533       var = var->next;
32534     }
32535     if (res == NULL && !PyErr_Occurred()) {
32536       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32537     }
32538     return res;
32539   }
32540
32541   SWIGINTERN int
32542   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32543     int res = 1;
32544     swig_globalvar *var = v->vars;
32545     while (var) {
32546       if (strcmp(var->name,n) == 0) {
32547         res = (*var->set_attr)(p);
32548         break;
32549       }
32550       var = var->next;
32551     }
32552     if (res == 1 && !PyErr_Occurred()) {
32553       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32554     }
32555     return res;
32556   }
32557
32558   SWIGINTERN PyTypeObject*
32559   swig_varlink_type(void) {
32560     static char varlink__doc__[] = "Swig var link object";
32561     static PyTypeObject varlink_type;
32562     static int type_init = 0;
32563     if (!type_init) {
32564       const PyTypeObject tmp
32565       = {
32566         PyObject_HEAD_INIT(NULL)
32567         0,                                  /* Number of items in variable part (ob_size) */
32568         (char *)"swigvarlink",              /* Type name (tp_name) */
32569         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
32570         0,                                  /* Itemsize (tp_itemsize) */
32571         (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */
32572         (printfunc) swig_varlink_print,     /* Print (tp_print) */
32573         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32574         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32575         0,                                  /* tp_compare */
32576         (reprfunc) swig_varlink_repr,       /* tp_repr */
32577         0,                                  /* tp_as_number */
32578         0,                                  /* tp_as_sequence */
32579         0,                                  /* tp_as_mapping */
32580         0,                                  /* tp_hash */
32581         0,                                  /* tp_call */
32582         (reprfunc)swig_varlink_str,        /* tp_str */
32583         0,                                  /* tp_getattro */
32584         0,                                  /* tp_setattro */
32585         0,                                  /* tp_as_buffer */
32586         0,                                  /* tp_flags */
32587         varlink__doc__,                     /* tp_doc */
32588         0,                                  /* tp_traverse */
32589         0,                                  /* tp_clear */
32590         0,                                  /* tp_richcompare */
32591         0,                                  /* tp_weaklistoffset */
32592 #if PY_VERSION_HEX >= 0x02020000
32593         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32594 #endif
32595 #if PY_VERSION_HEX >= 0x02030000
32596         0,                                  /* tp_del */
32597 #endif
32598 #ifdef COUNT_ALLOCS
32599         0,0,0,0                             /* tp_alloc -> tp_next */
32600 #endif
32601       };
32602       varlink_type = tmp;
32603       varlink_type.ob_type = &PyType_Type;
32604       type_init = 1;
32605     }
32606     return &varlink_type;
32607   }
32608
32609   /* Create a variable linking object for use later */
32610   SWIGINTERN PyObject *
32611   SWIG_Python_newvarlink(void) {
32612     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
32613     if (result) {
32614       result->vars = 0;
32615     }
32616     return ((PyObject*) result);
32617   }
32618
32619   SWIGINTERN void
32620   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32621     swig_varlinkobject *v = (swig_varlinkobject *) p;
32622     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32623     if (gv) {
32624       size_t size = strlen(name)+1;
32625       gv->name = (char *)malloc(size);
32626       if (gv->name) {
32627         strncpy(gv->name,name,size);
32628         gv->get_attr = get_attr;
32629         gv->set_attr = set_attr;
32630         gv->next = v->vars;
32631       }
32632     }
32633     v->vars = gv;
32634   }
32635
32636   SWIGINTERN PyObject *
32637   SWIG_globals(void) {
32638     static PyObject *_SWIG_globals = 0;
32639     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
32640     return _SWIG_globals;
32641   }
32642
32643   /* -----------------------------------------------------------------------------
32644    * constants/methods manipulation
32645    * ----------------------------------------------------------------------------- */
32646
32647   /* Install Constants */
32648   SWIGINTERN void
32649   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32650     PyObject *obj = 0;
32651     size_t i;
32652     for (i = 0; constants[i].type; ++i) {
32653       switch(constants[i].type) {
32654       case SWIG_PY_POINTER:
32655         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32656         break;
32657       case SWIG_PY_BINARY:
32658         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32659         break;
32660       default:
32661         obj = 0;
32662         break;
32663       }
32664       if (obj) {
32665         PyDict_SetItemString(d, constants[i].name, obj);
32666         Py_DECREF(obj);
32667       }
32668     }
32669   }
32670
32671   /* -----------------------------------------------------------------------------*/
32672   /* Fix SwigMethods to carry the callback ptrs when needed */
32673   /* -----------------------------------------------------------------------------*/
32674
32675   SWIGINTERN void
32676   SWIG_Python_FixMethods(PyMethodDef *methods,
32677     swig_const_info *const_table,
32678     swig_type_info **types,
32679     swig_type_info **types_initial) {
32680     size_t i;
32681     for (i = 0; methods[i].ml_name; ++i) {
32682       const char *c = methods[i].ml_doc;
32683       if (c && (c = strstr(c, "swig_ptr: "))) {
32684         int j;
32685         swig_const_info *ci = 0;
32686         const char *name = c + 10;
32687         for (j = 0; const_table[j].type; ++j) {
32688           if (strncmp(const_table[j].name, name,
32689               strlen(const_table[j].name)) == 0) {
32690             ci = &(const_table[j]);
32691             break;
32692           }
32693         }
32694         if (ci) {
32695           size_t shift = (ci->ptype) - types;
32696           swig_type_info *ty = types_initial[shift];
32697           size_t ldoc = (c - methods[i].ml_doc);
32698           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32699           char *ndoc = (char*)malloc(ldoc + lptr + 10);
32700           if (ndoc) {
32701             char *buff = ndoc;
32702             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
32703             if (ptr) {
32704               strncpy(buff, methods[i].ml_doc, ldoc);
32705               buff += ldoc;
32706               strncpy(buff, "swig_ptr: ", 10);
32707               buff += 10;
32708               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32709               methods[i].ml_doc = ndoc;
32710             }
32711           }
32712         }
32713       }
32714     }
32715   }
32716
32717 #ifdef __cplusplus
32718 }
32719 #endif
32720
32721 /* -----------------------------------------------------------------------------*
32722  *  Partial Init method
32723  * -----------------------------------------------------------------------------*/
32724
32725 #ifdef __cplusplus
32726 extern "C"
32727 #endif
32728 SWIGEXPORT void SWIG_init(void) {
32729   PyObject *m, *d;
32730
32731   /* Fix SwigMethods to carry the callback ptrs when needed */
32732   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
32733
32734   m = Py_InitModule((char *) SWIG_name, SwigMethods);
32735   d = PyModule_GetDict(m);
32736
32737   SWIG_InitializeModule(0);
32738   SWIG_InstallConstants(d,swig_const_table);
32739
32740
32741   SWIG_Python_SetConstant(d, "HOK",SWIG_From_int(static_cast< int >(0)));
32742   SWIG_Python_SetConstant(d, "HERR",SWIG_From_int(static_cast< int >(1)));
32743   SWIG_Python_SetConstant(d, "NOTHING",SWIG_From_int(static_cast< int >(-1)));
32744   SWIG_Python_SetConstant(d, "EOL",SWIG_From_char(static_cast< char >('\n')));
32745   SWIG_Python_SetConstant(d, "EOS",SWIG_From_int(static_cast< int >(0)));
32746   SWIG_Python_SetConstant(d, "CHVIDE",SWIG_FromCharPtr(""));
32747   SWIG_Python_SetConstant(d, "ZEROR",SWIG_From_double(static_cast< double >(0.0)));
32748   SWIG_Python_SetConstant(d, "UNR",SWIG_From_double(static_cast< double >(1.0)));
32749   SWIG_Python_SetConstant(d, "DEMI",SWIG_From_double(static_cast< double >(0.5)));
32750   SWIG_Python_SetConstant(d, "DIM2",SWIG_From_int(static_cast< int >(2)));
32751   SWIG_Python_SetConstant(d, "M_PI",SWIG_From_double(static_cast< double >(3.14159265358979323846)));
32752   SWIG_Python_SetConstant(d, "Degre2Radian",SWIG_From_double(static_cast< double >(3.14159265358979323846/180)));
32753   SWIG_Python_SetConstant(d, "dir_x",SWIG_From_int(static_cast< int >(Hex::dir_x)));
32754   SWIG_Python_SetConstant(d, "dir_y",SWIG_From_int(static_cast< int >(Hex::dir_y)));
32755   SWIG_Python_SetConstant(d, "dir_z",SWIG_From_int(static_cast< int >(Hex::dir_z)));
32756   SWIG_Python_SetConstant(d, "DIM3",SWIG_From_int(static_cast< int >(Hex::DIM3)));
32757   SWIG_Python_SetConstant(d, "EL_NONE",SWIG_From_int(static_cast< int >(Hex::EL_NONE)));
32758   SWIG_Python_SetConstant(d, "EL_VERTEX",SWIG_From_int(static_cast< int >(Hex::EL_VERTEX)));
32759   SWIG_Python_SetConstant(d, "EL_EDGE",SWIG_From_int(static_cast< int >(Hex::EL_EDGE)));
32760   SWIG_Python_SetConstant(d, "EL_QUAD",SWIG_From_int(static_cast< int >(Hex::EL_QUAD)));
32761   SWIG_Python_SetConstant(d, "EL_HEXA",SWIG_From_int(static_cast< int >(Hex::EL_HEXA)));
32762   SWIG_Python_SetConstant(d, "EL_VECTOR",SWIG_From_int(static_cast< int >(Hex::EL_VECTOR)));
32763   SWIG_Python_SetConstant(d, "EL_GRID",SWIG_From_int(static_cast< int >(Hex::EL_GRID)));
32764   SWIG_Python_SetConstant(d, "EL_CYLINDER",SWIG_From_int(static_cast< int >(Hex::EL_CYLINDER)));
32765   SWIG_Python_SetConstant(d, "EL_PIPE",SWIG_From_int(static_cast< int >(Hex::EL_PIPE)));
32766   SWIG_Python_SetConstant(d, "EL_GROUP",SWIG_From_int(static_cast< int >(Hex::EL_GROUP)));
32767   SWIG_Python_SetConstant(d, "EL_LAW",SWIG_From_int(static_cast< int >(Hex::EL_LAW)));
32768   SWIG_Python_SetConstant(d, "EL_SHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SHAPE)));
32769   SWIG_Python_SetConstant(d, "EL_SUBSHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SUBSHAPE)));
32770   SWIG_Python_SetConstant(d, "EL_PROPAGATION",SWIG_From_int(static_cast< int >(Hex::EL_PROPAGATION)));
32771   SWIG_Python_SetConstant(d, "EL_DOCU",SWIG_From_int(static_cast< int >(Hex::EL_DOCU)));
32772   SWIG_Python_SetConstant(d, "EL_REMOVED",SWIG_From_int(static_cast< int >(Hex::EL_REMOVED)));
32773   SWIG_Python_SetConstant(d, "EL_MAXI",SWIG_From_int(static_cast< int >(Hex::EL_MAXI)));
32774   PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
32775   SWIG_addvarlink(SWIG_globals(),(char*)"ABR_TYPES",ABR_TYPES_get, ABR_TYPES_set);
32776   SWIG_Python_SetConstant(d, "HexaCell",SWIG_From_int(static_cast< int >(Hex::HexaCell)));
32777   SWIG_Python_SetConstant(d, "QuadCell",SWIG_From_int(static_cast< int >(Hex::QuadCell)));
32778   SWIG_Python_SetConstant(d, "EdgeCell",SWIG_From_int(static_cast< int >(Hex::EdgeCell)));
32779   SWIG_Python_SetConstant(d, "HexaNode",SWIG_From_int(static_cast< int >(Hex::HexaNode)));
32780   SWIG_Python_SetConstant(d, "QuadNode",SWIG_From_int(static_cast< int >(Hex::QuadNode)));
32781   SWIG_Python_SetConstant(d, "EdgeNode",SWIG_From_int(static_cast< int >(Hex::EdgeNode)));
32782   SWIG_Python_SetConstant(d, "VertexNode",SWIG_From_int(static_cast< int >(Hex::VertexNode)));
32783   SWIG_Python_SetConstant(d, "SH_NONE",SWIG_From_int(static_cast< int >(Hex::SH_NONE)));
32784   SWIG_Python_SetConstant(d, "SH_IMPORT",SWIG_From_int(static_cast< int >(Hex::SH_IMPORT)));
32785   SWIG_Python_SetConstant(d, "SH_CYLINDER",SWIG_From_int(static_cast< int >(Hex::SH_CYLINDER)));
32786   SWIG_Python_SetConstant(d, "SH_INTER",SWIG_From_int(static_cast< int >(Hex::SH_INTER)));
32787   SWIG_Python_SetConstant(d, "SH_SPHERE",SWIG_From_int(static_cast< int >(Hex::SH_SPHERE)));
32788   SWIG_Python_SetConstant(d, "SH_CLOUD",SWIG_From_int(static_cast< int >(Hex::SH_CLOUD)));
32789   SWIG_Python_SetConstant(d, "SH_EXTRUD",SWIG_From_int(static_cast< int >(Hex::SH_EXTRUD)));
32790   SWIG_Python_SetConstant(d, "CYL_NOFILL",SWIG_From_int(static_cast< int >(Hex::CYL_NOFILL)));
32791   SWIG_Python_SetConstant(d, "CYL_CL4",SWIG_From_int(static_cast< int >(Hex::CYL_CL4)));
32792   SWIG_Python_SetConstant(d, "CYL_CL6",SWIG_From_int(static_cast< int >(Hex::CYL_CL6)));
32793   SWIG_Python_SetConstant(d, "CYL_CLOSED",SWIG_From_int(static_cast< int >(Hex::CYL_CLOSED)));
32794   SWIG_Python_SetConstant(d, "CYL_PEER",SWIG_From_int(static_cast< int >(Hex::CYL_PEER)));
32795   SWIG_Python_SetConstant(d, "CYL_ODD",SWIG_From_int(static_cast< int >(Hex::CYL_ODD)));
32796   SWIG_Python_SetConstant(d, "GR_NONE",SWIG_From_int(static_cast< int >(Hex::GR_NONE)));
32797   SWIG_Python_SetConstant(d, "GR_CARTESIAN",SWIG_From_int(static_cast< int >(Hex::GR_CARTESIAN)));
32798   SWIG_Python_SetConstant(d, "GR_CYLINDRIC",SWIG_From_int(static_cast< int >(Hex::GR_CYLINDRIC)));
32799   SWIG_Python_SetConstant(d, "GR_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_SPHERIC)));
32800   SWIG_Python_SetConstant(d, "GR_JOINT",SWIG_From_int(static_cast< int >(Hex::GR_JOINT)));
32801   SWIG_Python_SetConstant(d, "GR_BICYL",SWIG_From_int(static_cast< int >(Hex::GR_BICYL)));
32802   SWIG_Python_SetConstant(d, "GR_BIPIPE",SWIG_From_int(static_cast< int >(Hex::GR_BIPIPE)));
32803   SWIG_Python_SetConstant(d, "GR_REPLACE",SWIG_From_int(static_cast< int >(Hex::GR_REPLACE)));
32804   SWIG_Python_SetConstant(d, "GR_HEMISPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_HEMISPHERIC)));
32805   SWIG_Python_SetConstant(d, "GR_RIND",SWIG_From_int(static_cast< int >(Hex::GR_RIND)));
32806   SWIG_Python_SetConstant(d, "GR_PART_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_PART_SPHERIC)));
32807   SWIG_Python_SetConstant(d, "GR_PART_RIND",SWIG_From_int(static_cast< int >(Hex::GR_PART_RIND)));
32808   SWIG_Python_SetConstant(d, "S_E",SWIG_From_int(static_cast< int >(Hex::S_E)));
32809   SWIG_Python_SetConstant(d, "S_NE",SWIG_From_int(static_cast< int >(Hex::S_NE)));
32810   SWIG_Python_SetConstant(d, "S_N",SWIG_From_int(static_cast< int >(Hex::S_N)));
32811   SWIG_Python_SetConstant(d, "S_NW",SWIG_From_int(static_cast< int >(Hex::S_NW)));
32812   SWIG_Python_SetConstant(d, "S_W",SWIG_From_int(static_cast< int >(Hex::S_W)));
32813   SWIG_Python_SetConstant(d, "S_SW",SWIG_From_int(static_cast< int >(Hex::S_SW)));
32814   SWIG_Python_SetConstant(d, "S_S",SWIG_From_int(static_cast< int >(Hex::S_S)));
32815   SWIG_Python_SetConstant(d, "S_SE",SWIG_From_int(static_cast< int >(Hex::S_SE)));
32816   SWIG_Python_SetConstant(d, "S_MAXI",SWIG_From_int(static_cast< int >(Hex::S_MAXI)));
32817   SWIG_Python_SetConstant(d, "Uniform",SWIG_From_int(static_cast< int >(Hex::Uniform)));
32818   SWIG_Python_SetConstant(d, "Arithmetic",SWIG_From_int(static_cast< int >(Hex::Arithmetic)));
32819   SWIG_Python_SetConstant(d, "Geometric",SWIG_From_int(static_cast< int >(Hex::Geometric)));
32820   SWIG_Python_SetConstant(d, "OR_FRONT",SWIG_From_int(static_cast< int >(Hex::OR_FRONT)));
32821   SWIG_Python_SetConstant(d, "OR_LEFT",SWIG_From_int(static_cast< int >(Hex::OR_LEFT)));
32822   SWIG_Python_SetConstant(d, "OR_RIGHT",SWIG_From_int(static_cast< int >(Hex::OR_RIGHT)));
32823   SWIG_Python_SetConstant(d, "OR_BACK",SWIG_From_int(static_cast< int >(Hex::OR_BACK)));
32824   SWIG_Python_SetConstant(d, "IS_NONE",SWIG_From_int(static_cast< int >(Hex::IS_NONE)));
32825   SWIG_Python_SetConstant(d, "IS_MARRIED",SWIG_From_int(static_cast< int >(Hex::IS_MARRIED)));
32826   SWIG_Python_SetConstant(d, "NO_COUNTED",SWIG_From_int(static_cast< int >(Hex::NO_COUNTED)));
32827   SWIG_Python_SetConstant(d, "NO_USED",SWIG_From_int(static_cast< int >(Hex::NO_USED)));
32828   SWIG_Python_SetConstant(d, "IS_USED",SWIG_From_int(static_cast< int >(Hex::IS_USED)));
32829   SWIG_Python_SetConstant(d, "V_AMONT",SWIG_From_int(static_cast< int >(Hex::V_AMONT)));
32830   SWIG_Python_SetConstant(d, "V_AVAL",SWIG_From_int(static_cast< int >(Hex::V_AVAL)));
32831   SWIG_Python_SetConstant(d, "V_TWO",SWIG_From_int(static_cast< int >(Hex::V_TWO)));
32832   SWIG_Python_SetConstant(d, "E_A",SWIG_From_int(static_cast< int >(Hex::E_A)));
32833   SWIG_Python_SetConstant(d, "E_B",SWIG_From_int(static_cast< int >(Hex::E_B)));
32834   SWIG_Python_SetConstant(d, "E_C",SWIG_From_int(static_cast< int >(Hex::E_C)));
32835   SWIG_Python_SetConstant(d, "E_D",SWIG_From_int(static_cast< int >(Hex::E_D)));
32836   SWIG_Python_SetConstant(d, "QUAD4",SWIG_From_int(static_cast< int >(Hex::QUAD4)));
32837   SWIG_Python_SetConstant(d, "Q_A",SWIG_From_int(static_cast< int >(Hex::Q_A)));
32838   SWIG_Python_SetConstant(d, "Q_B",SWIG_From_int(static_cast< int >(Hex::Q_B)));
32839   SWIG_Python_SetConstant(d, "Q_C",SWIG_From_int(static_cast< int >(Hex::Q_C)));
32840   SWIG_Python_SetConstant(d, "Q_D",SWIG_From_int(static_cast< int >(Hex::Q_D)));
32841   SWIG_Python_SetConstant(d, "Q_E",SWIG_From_int(static_cast< int >(Hex::Q_E)));
32842   SWIG_Python_SetConstant(d, "Q_F",SWIG_From_int(static_cast< int >(Hex::Q_F)));
32843   SWIG_Python_SetConstant(d, "HQ_MAXI",SWIG_From_int(static_cast< int >(Hex::HQ_MAXI)));
32844   SWIG_Python_SetConstant(d, "E_AC",SWIG_From_int(static_cast< int >(Hex::E_AC)));
32845   SWIG_Python_SetConstant(d, "E_AD",SWIG_From_int(static_cast< int >(Hex::E_AD)));
32846   SWIG_Python_SetConstant(d, "E_BC",SWIG_From_int(static_cast< int >(Hex::E_BC)));
32847   SWIG_Python_SetConstant(d, "E_BD",SWIG_From_int(static_cast< int >(Hex::E_BD)));
32848   SWIG_Python_SetConstant(d, "E_AE",SWIG_From_int(static_cast< int >(Hex::E_AE)));
32849   SWIG_Python_SetConstant(d, "E_AF",SWIG_From_int(static_cast< int >(Hex::E_AF)));
32850   SWIG_Python_SetConstant(d, "E_BE",SWIG_From_int(static_cast< int >(Hex::E_BE)));
32851   SWIG_Python_SetConstant(d, "E_BF",SWIG_From_int(static_cast< int >(Hex::E_BF)));
32852   SWIG_Python_SetConstant(d, "E_CE",SWIG_From_int(static_cast< int >(Hex::E_CE)));
32853   SWIG_Python_SetConstant(d, "E_CF",SWIG_From_int(static_cast< int >(Hex::E_CF)));
32854   SWIG_Python_SetConstant(d, "E_DE",SWIG_From_int(static_cast< int >(Hex::E_DE)));
32855   SWIG_Python_SetConstant(d, "E_DF",SWIG_From_int(static_cast< int >(Hex::E_DF)));
32856   SWIG_Python_SetConstant(d, "HE_MAXI",SWIG_From_int(static_cast< int >(Hex::HE_MAXI)));
32857   SWIG_Python_SetConstant(d, "V_ACE",SWIG_From_int(static_cast< int >(Hex::V_ACE)));
32858   SWIG_Python_SetConstant(d, "V_ACF",SWIG_From_int(static_cast< int >(Hex::V_ACF)));
32859   SWIG_Python_SetConstant(d, "V_ADE",SWIG_From_int(static_cast< int >(Hex::V_ADE)));
32860   SWIG_Python_SetConstant(d, "V_ADF",SWIG_From_int(static_cast< int >(Hex::V_ADF)));
32861   SWIG_Python_SetConstant(d, "V_BCE",SWIG_From_int(static_cast< int >(Hex::V_BCE)));
32862   SWIG_Python_SetConstant(d, "V_BCF",SWIG_From_int(static_cast< int >(Hex::V_BCF)));
32863   SWIG_Python_SetConstant(d, "V_BDE",SWIG_From_int(static_cast< int >(Hex::V_BDE)));
32864   SWIG_Python_SetConstant(d, "V_BDF",SWIG_From_int(static_cast< int >(Hex::V_BDF)));
32865   SWIG_Python_SetConstant(d, "HV_MAXI",SWIG_From_int(static_cast< int >(Hex::HV_MAXI)));
32866   SWIG_Python_SetConstant(d, "Q_INSIDE",SWIG_From_int(static_cast< int >(Hex::Q_INSIDE)));
32867   SWIG_Python_SetConstant(d, "Q_DIRECT",SWIG_From_int(static_cast< int >(Hex::Q_DIRECT)));
32868   SWIG_Python_SetConstant(d, "Q_INVERSE",SWIG_From_int(static_cast< int >(Hex::Q_INVERSE)));
32869   SWIG_Python_SetConstant(d, "Q_UNDEFINED",SWIG_From_int(static_cast< int >(Hex::Q_UNDEFINED)));
32870   SWIG_Python_SetConstant(d, "Q_WAITING",SWIG_From_int(static_cast< int >(Hex::Q_WAITING)));
32871   SWIG_Python_SetConstant(d, "KS_Line",SWIG_From_int(static_cast< int >(Hex::KS_Line)));
32872   SWIG_Python_SetConstant(d, "KS_Circle",SWIG_From_int(static_cast< int >(Hex::KS_Circle)));
32873   SWIG_Python_SetConstant(d, "KS_Ellipse",SWIG_From_int(static_cast< int >(Hex::KS_Ellipse)));
32874   SWIG_Python_SetConstant(d, "KS_Hyperbola",SWIG_From_int(static_cast< int >(Hex::KS_Hyperbola)));
32875   SWIG_Python_SetConstant(d, "KS_Parabola",SWIG_From_int(static_cast< int >(Hex::KS_Parabola)));
32876   SWIG_Python_SetConstant(d, "KS_BezierCurve",SWIG_From_int(static_cast< int >(Hex::KS_BezierCurve)));
32877   SWIG_Python_SetConstant(d, "KS_BSplineCurve",SWIG_From_int(static_cast< int >(Hex::KS_BSplineCurve)));
32878   SWIG_Python_SetConstant(d, "KS_OtherCurve",SWIG_From_int(static_cast< int >(Hex::KS_OtherCurve)));
32879   SWIG_Python_SetConstant(d, "KS_None",SWIG_From_int(static_cast< int >(Hex::KS_None)));
32880   SWIG_Python_SetConstant(d, "CylSmall",SWIG_From_int(static_cast< int >(Hex::CylSmall)));
32881   SWIG_Python_SetConstant(d, "CylBig",SWIG_From_int(static_cast< int >(Hex::CylBig)));
32882   SWIG_Python_SetConstant(d, "NxInt",SWIG_From_int(static_cast< int >(Hex::NxInt)));
32883   SWIG_Python_SetConstant(d, "NxExt",SWIG_From_int(static_cast< int >(Hex::NxExt)));
32884   SWIG_addvarlink(SWIG_globals(),(char*)"Epsil",Epsil_get, Epsil_set);
32885   SWIG_addvarlink(SWIG_globals(),(char*)"UnEpsil",UnEpsil_get, UnEpsil_set);
32886   SWIG_addvarlink(SWIG_globals(),(char*)"Epsil2",Epsil2_get, Epsil2_set);
32887 }
32888