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_findVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24622   PyObject *resultobj = 0;
24623   Hex::Document *arg1 = (Hex::Document *) 0 ;
24624   double arg2 ;
24625   double arg3 ;
24626   double arg4 ;
24627   Hex::Vertex *result = 0 ;
24628   void *argp1 = 0 ;
24629   int res1 = 0 ;
24630   double val2 ;
24631   int ecode2 = 0 ;
24632   double val3 ;
24633   int ecode3 = 0 ;
24634   double val4 ;
24635   int ecode4 = 0 ;
24636   PyObject * obj0 = 0 ;
24637   PyObject * obj1 = 0 ;
24638   PyObject * obj2 = 0 ;
24639   PyObject * obj3 = 0 ;
24640
24641   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_findVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24642   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24643   if (!SWIG_IsOK(res1)) {
24644     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24645   }
24646   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24647   ecode2 = SWIG_AsVal_double(obj1, &val2);
24648   if (!SWIG_IsOK(ecode2)) {
24649     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "double""'");
24650   }
24651   arg2 = static_cast< double >(val2);
24652   ecode3 = SWIG_AsVal_double(obj2, &val3);
24653   if (!SWIG_IsOK(ecode3)) {
24654     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_findVertex" "', argument " "3"" of type '" "double""'");
24655   }
24656   arg3 = static_cast< double >(val3);
24657   ecode4 = SWIG_AsVal_double(obj3, &val4);
24658   if (!SWIG_IsOK(ecode4)) {
24659     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_findVertex" "', argument " "4"" of type '" "double""'");
24660   }
24661   arg4 = static_cast< double >(val4);
24662   result = (Hex::Vertex *)(arg1)->findVertex(arg2,arg3,arg4);
24663   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24664   return resultobj;
24665 fail:
24666   return NULL;
24667 }
24668
24669
24670 SWIGINTERN PyObject *_wrap_Document_findEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24671   PyObject *resultobj = 0;
24672   Hex::Document *arg1 = (Hex::Document *) 0 ;
24673   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24674   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24675   Hex::Edge *result = 0 ;
24676   void *argp1 = 0 ;
24677   int res1 = 0 ;
24678   void *argp2 = 0 ;
24679   int res2 = 0 ;
24680   void *argp3 = 0 ;
24681   int res3 = 0 ;
24682   PyObject * obj0 = 0 ;
24683   PyObject * obj1 = 0 ;
24684   PyObject * obj2 = 0 ;
24685
24686   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findEdge",&obj0,&obj1,&obj2)) SWIG_fail;
24687   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24688   if (!SWIG_IsOK(res1)) {
24689     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24690   }
24691   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24692   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24693   if (!SWIG_IsOK(res2)) {
24694     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findEdge" "', argument " "2"" of type '" "Hex::Vertex *""'");
24695   }
24696   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24697   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24698   if (!SWIG_IsOK(res3)) {
24699     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findEdge" "', argument " "3"" of type '" "Hex::Vertex *""'");
24700   }
24701   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24702   result = (Hex::Edge *)(arg1)->findEdge(arg2,arg3);
24703   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
24704   return resultobj;
24705 fail:
24706   return NULL;
24707 }
24708
24709
24710 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24711   PyObject *resultobj = 0;
24712   Hex::Document *arg1 = (Hex::Document *) 0 ;
24713   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24714   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24715   Hex::Quad *result = 0 ;
24716   void *argp1 = 0 ;
24717   int res1 = 0 ;
24718   void *argp2 = 0 ;
24719   int res2 = 0 ;
24720   void *argp3 = 0 ;
24721   int res3 = 0 ;
24722   PyObject * obj0 = 0 ;
24723   PyObject * obj1 = 0 ;
24724   PyObject * obj2 = 0 ;
24725
24726   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
24727   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24728   if (!SWIG_IsOK(res1)) {
24729     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24730   }
24731   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24732   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24733   if (!SWIG_IsOK(res2)) {
24734     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Vertex *""'");
24735   }
24736   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24737   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24738   if (!SWIG_IsOK(res3)) {
24739     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
24740   }
24741   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24742   result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
24743   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
24744   return resultobj;
24745 fail:
24746   return NULL;
24747 }
24748
24749
24750 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24751   PyObject *resultobj = 0;
24752   Hex::Document *arg1 = (Hex::Document *) 0 ;
24753   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
24754   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
24755   Hex::Quad *result = 0 ;
24756   void *argp1 = 0 ;
24757   int res1 = 0 ;
24758   void *argp2 = 0 ;
24759   int res2 = 0 ;
24760   void *argp3 = 0 ;
24761   int res3 = 0 ;
24762   PyObject * obj0 = 0 ;
24763   PyObject * obj1 = 0 ;
24764   PyObject * obj2 = 0 ;
24765
24766   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
24767   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24768   if (!SWIG_IsOK(res1)) {
24769     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24770   }
24771   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24772   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
24773   if (!SWIG_IsOK(res2)) {
24774     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Edge *""'");
24775   }
24776   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
24777   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
24778   if (!SWIG_IsOK(res3)) {
24779     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Edge *""'");
24780   }
24781   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
24782   result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
24783   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
24784   return resultobj;
24785 fail:
24786   return NULL;
24787 }
24788
24789
24790 SWIGINTERN PyObject *_wrap_Document_findQuad(PyObject *self, PyObject *args) {
24791   int argc;
24792   PyObject *argv[4];
24793   int ii;
24794
24795   if (!PyTuple_Check(args)) SWIG_fail;
24796   argc = PyObject_Length(args);
24797   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
24798     argv[ii] = PyTuple_GET_ITEM(args,ii);
24799   }
24800   if (argc == 3) {
24801     int _v;
24802     void *vptr = 0;
24803     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24804     _v = SWIG_CheckState(res);
24805     if (_v) {
24806       void *vptr = 0;
24807       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
24808       _v = SWIG_CheckState(res);
24809       if (_v) {
24810         void *vptr = 0;
24811         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
24812         _v = SWIG_CheckState(res);
24813         if (_v) {
24814           return _wrap_Document_findQuad__SWIG_0(self, args);
24815         }
24816       }
24817     }
24818   }
24819   if (argc == 3) {
24820     int _v;
24821     void *vptr = 0;
24822     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24823     _v = SWIG_CheckState(res);
24824     if (_v) {
24825       void *vptr = 0;
24826       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Edge, 0);
24827       _v = SWIG_CheckState(res);
24828       if (_v) {
24829         void *vptr = 0;
24830         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
24831         _v = SWIG_CheckState(res);
24832         if (_v) {
24833           return _wrap_Document_findQuad__SWIG_1(self, args);
24834         }
24835       }
24836     }
24837   }
24838
24839 fail:
24840   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");
24841   return NULL;
24842 }
24843
24844
24845 SWIGINTERN PyObject *_wrap_Document_findHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24846   PyObject *resultobj = 0;
24847   Hex::Document *arg1 = (Hex::Document *) 0 ;
24848   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24849   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24850   Hex::Hexa *result = 0 ;
24851   void *argp1 = 0 ;
24852   int res1 = 0 ;
24853   void *argp2 = 0 ;
24854   int res2 = 0 ;
24855   void *argp3 = 0 ;
24856   int res3 = 0 ;
24857   PyObject * obj0 = 0 ;
24858   PyObject * obj1 = 0 ;
24859   PyObject * obj2 = 0 ;
24860
24861   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findHexa",&obj0,&obj1,&obj2)) SWIG_fail;
24862   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24863   if (!SWIG_IsOK(res1)) {
24864     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findHexa" "', argument " "1"" of type '" "Hex::Document *""'");
24865   }
24866   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24867   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24868   if (!SWIG_IsOK(res2)) {
24869     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findHexa" "', argument " "2"" of type '" "Hex::Vertex *""'");
24870   }
24871   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24872   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24873   if (!SWIG_IsOK(res3)) {
24874     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findHexa" "', argument " "3"" of type '" "Hex::Vertex *""'");
24875   }
24876   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24877   result = (Hex::Hexa *)(arg1)->findHexa(arg2,arg3);
24878   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
24879   return resultobj;
24880 fail:
24881   return NULL;
24882 }
24883
24884
24885 SWIGINTERN PyObject *_wrap_Document_findGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24886   PyObject *resultobj = 0;
24887   Hex::Document *arg1 = (Hex::Document *) 0 ;
24888   cpchar arg2 = (cpchar) 0 ;
24889   Hex::Group *result = 0 ;
24890   void *argp1 = 0 ;
24891   int res1 = 0 ;
24892   int res2 ;
24893   char *buf2 = 0 ;
24894   int alloc2 = 0 ;
24895   PyObject * obj0 = 0 ;
24896   PyObject * obj1 = 0 ;
24897
24898   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findGroup",&obj0,&obj1)) SWIG_fail;
24899   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24900   if (!SWIG_IsOK(res1)) {
24901     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findGroup" "', argument " "1"" of type '" "Hex::Document *""'");
24902   }
24903   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24904   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24905   if (!SWIG_IsOK(res2)) {
24906     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findGroup" "', argument " "2"" of type '" "cpchar""'");
24907   }
24908   arg2 = reinterpret_cast< cpchar >(buf2);
24909   result = (Hex::Group *)(arg1)->findGroup(arg2);
24910   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
24911   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24912   return resultobj;
24913 fail:
24914   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24915   return NULL;
24916 }
24917
24918
24919 SWIGINTERN PyObject *_wrap_Document_findLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24920   PyObject *resultobj = 0;
24921   Hex::Document *arg1 = (Hex::Document *) 0 ;
24922   cpchar arg2 = (cpchar) 0 ;
24923   Hex::Law *result = 0 ;
24924   void *argp1 = 0 ;
24925   int res1 = 0 ;
24926   int res2 ;
24927   char *buf2 = 0 ;
24928   int alloc2 = 0 ;
24929   PyObject * obj0 = 0 ;
24930   PyObject * obj1 = 0 ;
24931
24932   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findLaw",&obj0,&obj1)) SWIG_fail;
24933   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24934   if (!SWIG_IsOK(res1)) {
24935     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findLaw" "', argument " "1"" of type '" "Hex::Document *""'");
24936   }
24937   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24938   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24939   if (!SWIG_IsOK(res2)) {
24940     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findLaw" "', argument " "2"" of type '" "cpchar""'");
24941   }
24942   arg2 = reinterpret_cast< cpchar >(buf2);
24943   result = (Hex::Law *)(arg1)->findLaw(arg2);
24944   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
24945   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24946   return resultobj;
24947 fail:
24948   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24949   return NULL;
24950 }
24951
24952
24953 SWIGINTERN PyObject *_wrap_Document_findPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24954   PyObject *resultobj = 0;
24955   Hex::Document *arg1 = (Hex::Document *) 0 ;
24956   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
24957   Hex::Propagation *result = 0 ;
24958   void *argp1 = 0 ;
24959   int res1 = 0 ;
24960   void *argp2 = 0 ;
24961   int res2 = 0 ;
24962   PyObject * obj0 = 0 ;
24963   PyObject * obj1 = 0 ;
24964
24965   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findPropagation",&obj0,&obj1)) SWIG_fail;
24966   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24967   if (!SWIG_IsOK(res1)) {
24968     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
24969   }
24970   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24971   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
24972   if (!SWIG_IsOK(res2)) {
24973     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findPropagation" "', argument " "2"" of type '" "Hex::Edge *""'");
24974   }
24975   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
24976   result = (Hex::Propagation *)(arg1)->findPropagation(arg2);
24977   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, 0 |  0 );
24978   return resultobj;
24979 fail:
24980   return NULL;
24981 }
24982
24983
24984 SWIGINTERN PyObject *_wrap_Document_removeHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24985   PyObject *resultobj = 0;
24986   Hex::Document *arg1 = (Hex::Document *) 0 ;
24987   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
24988   int result;
24989   void *argp1 = 0 ;
24990   int res1 = 0 ;
24991   void *argp2 = 0 ;
24992   int res2 = 0 ;
24993   PyObject * obj0 = 0 ;
24994   PyObject * obj1 = 0 ;
24995
24996   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeHexa",&obj0,&obj1)) SWIG_fail;
24997   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24998   if (!SWIG_IsOK(res1)) {
24999     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25000   }
25001   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25002   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25003   if (!SWIG_IsOK(res2)) {
25004     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
25005   }
25006   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
25007   result = (int)(arg1)->removeHexa(arg2);
25008   resultobj = SWIG_From_int(static_cast< int >(result));
25009   return resultobj;
25010 fail:
25011   return NULL;
25012 }
25013
25014
25015 SWIGINTERN PyObject *_wrap_Document_removeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25016   PyObject *resultobj = 0;
25017   Hex::Document *arg1 = (Hex::Document *) 0 ;
25018   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25019   int result;
25020   void *argp1 = 0 ;
25021   int res1 = 0 ;
25022   void *argp2 = 0 ;
25023   int res2 = 0 ;
25024   PyObject * obj0 = 0 ;
25025   PyObject * obj1 = 0 ;
25026
25027   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeQuad",&obj0,&obj1)) SWIG_fail;
25028   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25029   if (!SWIG_IsOK(res1)) {
25030     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
25031   }
25032   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25033   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25034   if (!SWIG_IsOK(res2)) {
25035     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
25036   }
25037   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25038   result = (int)(arg1)->removeQuad(arg2);
25039   resultobj = SWIG_From_int(static_cast< int >(result));
25040   return resultobj;
25041 fail:
25042   return NULL;
25043 }
25044
25045
25046 SWIGINTERN PyObject *_wrap_Document_removeConnectedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25047   PyObject *resultobj = 0;
25048   Hex::Document *arg1 = (Hex::Document *) 0 ;
25049   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
25050   int result;
25051   void *argp1 = 0 ;
25052   int res1 = 0 ;
25053   void *argp2 = 0 ;
25054   int res2 = 0 ;
25055   PyObject * obj0 = 0 ;
25056   PyObject * obj1 = 0 ;
25057
25058   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeConnectedHexa",&obj0,&obj1)) SWIG_fail;
25059   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25060   if (!SWIG_IsOK(res1)) {
25061     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeConnectedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25062   }
25063   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25064   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25065   if (!SWIG_IsOK(res2)) {
25066     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeConnectedHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
25067   }
25068   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
25069   result = (int)(arg1)->removeConnectedHexa(arg2);
25070   resultobj = SWIG_From_int(static_cast< int >(result));
25071   return resultobj;
25072 fail:
25073   return NULL;
25074 }
25075
25076
25077 SWIGINTERN PyObject *_wrap_Document_removeElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25078   PyObject *resultobj = 0;
25079   Hex::Document *arg1 = (Hex::Document *) 0 ;
25080   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
25081   int result;
25082   void *argp1 = 0 ;
25083   int res1 = 0 ;
25084   void *argp2 = 0 ;
25085   int res2 = 0 ;
25086   PyObject * obj0 = 0 ;
25087   PyObject * obj1 = 0 ;
25088
25089   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeElements",&obj0,&obj1)) SWIG_fail;
25090   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25091   if (!SWIG_IsOK(res1)) {
25092     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeElements" "', argument " "1"" of type '" "Hex::Document *""'");
25093   }
25094   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25095   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
25096   if (!SWIG_IsOK(res2)) {
25097     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeElements" "', argument " "2"" of type '" "Hex::Elements *""'");
25098   }
25099   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
25100   result = (int)(arg1)->removeElements(arg2);
25101   resultobj = SWIG_From_int(static_cast< int >(result));
25102   return resultobj;
25103 fail:
25104   return NULL;
25105 }
25106
25107
25108 SWIGINTERN PyObject *_wrap_Document_removeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25109   PyObject *resultobj = 0;
25110   Hex::Document *arg1 = (Hex::Document *) 0 ;
25111   Hex::Group *arg2 = (Hex::Group *) 0 ;
25112   int result;
25113   void *argp1 = 0 ;
25114   int res1 = 0 ;
25115   void *argp2 = 0 ;
25116   int res2 = 0 ;
25117   PyObject * obj0 = 0 ;
25118   PyObject * obj1 = 0 ;
25119
25120   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeGroup",&obj0,&obj1)) SWIG_fail;
25121   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25122   if (!SWIG_IsOK(res1)) {
25123     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
25124   }
25125   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25126   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Group, 0 |  0 );
25127   if (!SWIG_IsOK(res2)) {
25128     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeGroup" "', argument " "2"" of type '" "Hex::Group *""'");
25129   }
25130   arg2 = reinterpret_cast< Hex::Group * >(argp2);
25131   result = (int)(arg1)->removeGroup(arg2);
25132   resultobj = SWIG_From_int(static_cast< int >(result));
25133   return resultobj;
25134 fail:
25135   return NULL;
25136 }
25137
25138
25139 SWIGINTERN PyObject *_wrap_Document_removeLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25140   PyObject *resultobj = 0;
25141   Hex::Document *arg1 = (Hex::Document *) 0 ;
25142   Hex::Law *arg2 = (Hex::Law *) 0 ;
25143   int result;
25144   void *argp1 = 0 ;
25145   int res1 = 0 ;
25146   void *argp2 = 0 ;
25147   int res2 = 0 ;
25148   PyObject * obj0 = 0 ;
25149   PyObject * obj1 = 0 ;
25150
25151   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeLaw",&obj0,&obj1)) SWIG_fail;
25152   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25153   if (!SWIG_IsOK(res1)) {
25154     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeLaw" "', argument " "1"" of type '" "Hex::Document *""'");
25155   }
25156   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25157   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
25158   if (!SWIG_IsOK(res2)) {
25159     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeLaw" "', argument " "2"" of type '" "Hex::Law *""'");
25160   }
25161   arg2 = reinterpret_cast< Hex::Law * >(argp2);
25162   result = (int)(arg1)->removeLaw(arg2);
25163   resultobj = SWIG_From_int(static_cast< int >(result));
25164   return resultobj;
25165 fail:
25166   return NULL;
25167 }
25168
25169
25170 SWIGINTERN PyObject *_wrap_Document_makeCartesianTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25171   PyObject *resultobj = 0;
25172   Hex::Document *arg1 = (Hex::Document *) 0 ;
25173   int arg2 ;
25174   int arg3 ;
25175   int arg4 ;
25176   Hex::Elements *result = 0 ;
25177   void *argp1 = 0 ;
25178   int res1 = 0 ;
25179   int val2 ;
25180   int ecode2 = 0 ;
25181   int val3 ;
25182   int ecode3 = 0 ;
25183   int val4 ;
25184   int ecode4 = 0 ;
25185   PyObject * obj0 = 0 ;
25186   PyObject * obj1 = 0 ;
25187   PyObject * obj2 = 0 ;
25188   PyObject * obj3 = 0 ;
25189
25190   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCartesianTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25191   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25192   if (!SWIG_IsOK(res1)) {
25193     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianTop" "', argument " "1"" of type '" "Hex::Document *""'");
25194   }
25195   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25196   ecode2 = SWIG_AsVal_int(obj1, &val2);
25197   if (!SWIG_IsOK(ecode2)) {
25198     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCartesianTop" "', argument " "2"" of type '" "int""'");
25199   }
25200   arg2 = static_cast< int >(val2);
25201   ecode3 = SWIG_AsVal_int(obj2, &val3);
25202   if (!SWIG_IsOK(ecode3)) {
25203     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCartesianTop" "', argument " "3"" of type '" "int""'");
25204   }
25205   arg3 = static_cast< int >(val3);
25206   ecode4 = SWIG_AsVal_int(obj3, &val4);
25207   if (!SWIG_IsOK(ecode4)) {
25208     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCartesianTop" "', argument " "4"" of type '" "int""'");
25209   }
25210   arg4 = static_cast< int >(val4);
25211   result = (Hex::Elements *)(arg1)->makeCartesianTop(arg2,arg3,arg4);
25212   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25213   return resultobj;
25214 fail:
25215   return NULL;
25216 }
25217
25218
25219 SWIGINTERN PyObject *_wrap_Document_makeCartesianUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25220   PyObject *resultobj = 0;
25221   Hex::Document *arg1 = (Hex::Document *) 0 ;
25222   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25223   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25224   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25225   Hex::Vector *arg5 = (Hex::Vector *) 0 ;
25226   double arg6 ;
25227   double arg7 ;
25228   double arg8 ;
25229   int arg9 ;
25230   int arg10 ;
25231   int arg11 ;
25232   Hex::Elements *result = 0 ;
25233   void *argp1 = 0 ;
25234   int res1 = 0 ;
25235   void *argp2 = 0 ;
25236   int res2 = 0 ;
25237   void *argp3 = 0 ;
25238   int res3 = 0 ;
25239   void *argp4 = 0 ;
25240   int res4 = 0 ;
25241   void *argp5 = 0 ;
25242   int res5 = 0 ;
25243   double val6 ;
25244   int ecode6 = 0 ;
25245   double val7 ;
25246   int ecode7 = 0 ;
25247   double val8 ;
25248   int ecode8 = 0 ;
25249   int val9 ;
25250   int ecode9 = 0 ;
25251   int val10 ;
25252   int ecode10 = 0 ;
25253   int val11 ;
25254   int ecode11 = 0 ;
25255   PyObject * obj0 = 0 ;
25256   PyObject * obj1 = 0 ;
25257   PyObject * obj2 = 0 ;
25258   PyObject * obj3 = 0 ;
25259   PyObject * obj4 = 0 ;
25260   PyObject * obj5 = 0 ;
25261   PyObject * obj6 = 0 ;
25262   PyObject * obj7 = 0 ;
25263   PyObject * obj8 = 0 ;
25264   PyObject * obj9 = 0 ;
25265   PyObject * obj10 = 0 ;
25266
25267   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCartesianUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
25268   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25269   if (!SWIG_IsOK(res1)) {
25270     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianUni" "', argument " "1"" of type '" "Hex::Document *""'");
25271   }
25272   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25273   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25274   if (!SWIG_IsOK(res2)) {
25275     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesianUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
25276   }
25277   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25278   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25279   if (!SWIG_IsOK(res3)) {
25280     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesianUni" "', argument " "3"" of type '" "Hex::Vector *""'");
25281   }
25282   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25283   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25284   if (!SWIG_IsOK(res4)) {
25285     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesianUni" "', argument " "4"" of type '" "Hex::Vector *""'");
25286   }
25287   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25288   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25289   if (!SWIG_IsOK(res5)) {
25290     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesianUni" "', argument " "5"" of type '" "Hex::Vector *""'");
25291   }
25292   arg5 = reinterpret_cast< Hex::Vector * >(argp5);
25293   ecode6 = SWIG_AsVal_double(obj5, &val6);
25294   if (!SWIG_IsOK(ecode6)) {
25295     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCartesianUni" "', argument " "6"" of type '" "double""'");
25296   }
25297   arg6 = static_cast< double >(val6);
25298   ecode7 = SWIG_AsVal_double(obj6, &val7);
25299   if (!SWIG_IsOK(ecode7)) {
25300     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCartesianUni" "', argument " "7"" of type '" "double""'");
25301   }
25302   arg7 = static_cast< double >(val7);
25303   ecode8 = SWIG_AsVal_double(obj7, &val8);
25304   if (!SWIG_IsOK(ecode8)) {
25305     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCartesianUni" "', argument " "8"" of type '" "double""'");
25306   }
25307   arg8 = static_cast< double >(val8);
25308   ecode9 = SWIG_AsVal_int(obj8, &val9);
25309   if (!SWIG_IsOK(ecode9)) {
25310     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCartesianUni" "', argument " "9"" of type '" "int""'");
25311   }
25312   arg9 = static_cast< int >(val9);
25313   ecode10 = SWIG_AsVal_int(obj9, &val10);
25314   if (!SWIG_IsOK(ecode10)) {
25315     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCartesianUni" "', argument " "10"" of type '" "int""'");
25316   }
25317   arg10 = static_cast< int >(val10);
25318   ecode11 = SWIG_AsVal_int(obj10, &val11);
25319   if (!SWIG_IsOK(ecode11)) {
25320     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCartesianUni" "', argument " "11"" of type '" "int""'");
25321   }
25322   arg11 = static_cast< int >(val11);
25323   result = (Hex::Elements *)(arg1)->makeCartesianUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25324   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25325   return resultobj;
25326 fail:
25327   return NULL;
25328 }
25329
25330
25331 SWIGINTERN PyObject *_wrap_Document_makeCartesian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25332   PyObject *resultobj = 0;
25333   Hex::Document *arg1 = (Hex::Document *) 0 ;
25334   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25335   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25336   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25337   Hex::Vector *arg5 = (Hex::Vector *) 0 ;
25338   Hex::RealVector arg6 ;
25339   Hex::RealVector arg7 ;
25340   Hex::RealVector arg8 ;
25341   Hex::Elements *result = 0 ;
25342   void *argp1 = 0 ;
25343   int res1 = 0 ;
25344   void *argp2 = 0 ;
25345   int res2 = 0 ;
25346   void *argp3 = 0 ;
25347   int res3 = 0 ;
25348   void *argp4 = 0 ;
25349   int res4 = 0 ;
25350   void *argp5 = 0 ;
25351   int res5 = 0 ;
25352   PyObject * obj0 = 0 ;
25353   PyObject * obj1 = 0 ;
25354   PyObject * obj2 = 0 ;
25355   PyObject * obj3 = 0 ;
25356   PyObject * obj4 = 0 ;
25357   PyObject * obj5 = 0 ;
25358   PyObject * obj6 = 0 ;
25359   PyObject * obj7 = 0 ;
25360
25361   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_makeCartesian",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
25362   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25363   if (!SWIG_IsOK(res1)) {
25364     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesian" "', argument " "1"" of type '" "Hex::Document *""'");
25365   }
25366   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25367   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25368   if (!SWIG_IsOK(res2)) {
25369     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesian" "', argument " "2"" of type '" "Hex::Vertex *""'");
25370   }
25371   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25372   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25373   if (!SWIG_IsOK(res3)) {
25374     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesian" "', argument " "3"" of type '" "Hex::Vector *""'");
25375   }
25376   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25377   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25378   if (!SWIG_IsOK(res4)) {
25379     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesian" "', argument " "4"" of type '" "Hex::Vector *""'");
25380   }
25381   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25382   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25383   if (!SWIG_IsOK(res5)) {
25384     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesian" "', argument " "5"" of type '" "Hex::Vector *""'");
25385   }
25386   arg5 = reinterpret_cast< Hex::Vector * >(argp5);
25387   {
25388     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25389     int res = swig::asptr(obj5, &ptr);
25390     if (!SWIG_IsOK(res) || !ptr) {
25391       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "6"" of type '" "Hex::RealVector""'");
25392     }
25393     arg6 = *ptr;
25394     if (SWIG_IsNewObj(res)) delete ptr;
25395   }
25396   {
25397     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25398     int res = swig::asptr(obj6, &ptr);
25399     if (!SWIG_IsOK(res) || !ptr) {
25400       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "7"" of type '" "Hex::RealVector""'");
25401     }
25402     arg7 = *ptr;
25403     if (SWIG_IsNewObj(res)) delete ptr;
25404   }
25405   {
25406     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25407     int res = swig::asptr(obj7, &ptr);
25408     if (!SWIG_IsOK(res) || !ptr) {
25409       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "8"" of type '" "Hex::RealVector""'");
25410     }
25411     arg8 = *ptr;
25412     if (SWIG_IsNewObj(res)) delete ptr;
25413   }
25414   result = (Hex::Elements *)(arg1)->makeCartesian(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
25415   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25416   return resultobj;
25417 fail:
25418   return NULL;
25419 }
25420
25421
25422 SWIGINTERN PyObject *_wrap_Document_makeCylinderTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25423   PyObject *resultobj = 0;
25424   Hex::Document *arg1 = (Hex::Document *) 0 ;
25425   int arg2 ;
25426   int arg3 ;
25427   int arg4 ;
25428   Hex::Elements *result = 0 ;
25429   void *argp1 = 0 ;
25430   int res1 = 0 ;
25431   int val2 ;
25432   int ecode2 = 0 ;
25433   int val3 ;
25434   int ecode3 = 0 ;
25435   int val4 ;
25436   int ecode4 = 0 ;
25437   PyObject * obj0 = 0 ;
25438   PyObject * obj1 = 0 ;
25439   PyObject * obj2 = 0 ;
25440   PyObject * obj3 = 0 ;
25441
25442   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCylinderTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25443   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25444   if (!SWIG_IsOK(res1)) {
25445     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderTop" "', argument " "1"" of type '" "Hex::Document *""'");
25446   }
25447   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25448   ecode2 = SWIG_AsVal_int(obj1, &val2);
25449   if (!SWIG_IsOK(ecode2)) {
25450     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCylinderTop" "', argument " "2"" of type '" "int""'");
25451   }
25452   arg2 = static_cast< int >(val2);
25453   ecode3 = SWIG_AsVal_int(obj2, &val3);
25454   if (!SWIG_IsOK(ecode3)) {
25455     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCylinderTop" "', argument " "3"" of type '" "int""'");
25456   }
25457   arg3 = static_cast< int >(val3);
25458   ecode4 = SWIG_AsVal_int(obj3, &val4);
25459   if (!SWIG_IsOK(ecode4)) {
25460     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinderTop" "', argument " "4"" of type '" "int""'");
25461   }
25462   arg4 = static_cast< int >(val4);
25463   result = (Hex::Elements *)(arg1)->makeCylinderTop(arg2,arg3,arg4);
25464   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25465   return resultobj;
25466 fail:
25467   return NULL;
25468 }
25469
25470
25471 SWIGINTERN PyObject *_wrap_Document_makeCylinderUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25472   PyObject *resultobj = 0;
25473   Hex::Document *arg1 = (Hex::Document *) 0 ;
25474   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25475   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25476   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25477   double arg5 ;
25478   double arg6 ;
25479   double arg7 ;
25480   double arg8 ;
25481   int arg9 ;
25482   int arg10 ;
25483   int arg11 ;
25484   Hex::Elements *result = 0 ;
25485   void *argp1 = 0 ;
25486   int res1 = 0 ;
25487   void *argp2 = 0 ;
25488   int res2 = 0 ;
25489   void *argp3 = 0 ;
25490   int res3 = 0 ;
25491   void *argp4 = 0 ;
25492   int res4 = 0 ;
25493   double val5 ;
25494   int ecode5 = 0 ;
25495   double val6 ;
25496   int ecode6 = 0 ;
25497   double val7 ;
25498   int ecode7 = 0 ;
25499   double val8 ;
25500   int ecode8 = 0 ;
25501   int val9 ;
25502   int ecode9 = 0 ;
25503   int val10 ;
25504   int ecode10 = 0 ;
25505   int val11 ;
25506   int ecode11 = 0 ;
25507   PyObject * obj0 = 0 ;
25508   PyObject * obj1 = 0 ;
25509   PyObject * obj2 = 0 ;
25510   PyObject * obj3 = 0 ;
25511   PyObject * obj4 = 0 ;
25512   PyObject * obj5 = 0 ;
25513   PyObject * obj6 = 0 ;
25514   PyObject * obj7 = 0 ;
25515   PyObject * obj8 = 0 ;
25516   PyObject * obj9 = 0 ;
25517   PyObject * obj10 = 0 ;
25518
25519   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCylinderUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
25520   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25521   if (!SWIG_IsOK(res1)) {
25522     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderUni" "', argument " "1"" of type '" "Hex::Document *""'");
25523   }
25524   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25525   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25526   if (!SWIG_IsOK(res2)) {
25527     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinderUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
25528   }
25529   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25530   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25531   if (!SWIG_IsOK(res3)) {
25532     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinderUni" "', argument " "3"" of type '" "Hex::Vector *""'");
25533   }
25534   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25535   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25536   if (!SWIG_IsOK(res4)) {
25537     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinderUni" "', argument " "4"" of type '" "Hex::Vector *""'");
25538   }
25539   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25540   ecode5 = SWIG_AsVal_double(obj4, &val5);
25541   if (!SWIG_IsOK(ecode5)) {
25542     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinderUni" "', argument " "5"" of type '" "double""'");
25543   }
25544   arg5 = static_cast< double >(val5);
25545   ecode6 = SWIG_AsVal_double(obj5, &val6);
25546   if (!SWIG_IsOK(ecode6)) {
25547     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCylinderUni" "', argument " "6"" of type '" "double""'");
25548   }
25549   arg6 = static_cast< double >(val6);
25550   ecode7 = SWIG_AsVal_double(obj6, &val7);
25551   if (!SWIG_IsOK(ecode7)) {
25552     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCylinderUni" "', argument " "7"" of type '" "double""'");
25553   }
25554   arg7 = static_cast< double >(val7);
25555   ecode8 = SWIG_AsVal_double(obj7, &val8);
25556   if (!SWIG_IsOK(ecode8)) {
25557     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinderUni" "', argument " "8"" of type '" "double""'");
25558   }
25559   arg8 = static_cast< double >(val8);
25560   ecode9 = SWIG_AsVal_int(obj8, &val9);
25561   if (!SWIG_IsOK(ecode9)) {
25562     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinderUni" "', argument " "9"" of type '" "int""'");
25563   }
25564   arg9 = static_cast< int >(val9);
25565   ecode10 = SWIG_AsVal_int(obj9, &val10);
25566   if (!SWIG_IsOK(ecode10)) {
25567     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCylinderUni" "', argument " "10"" of type '" "int""'");
25568   }
25569   arg10 = static_cast< int >(val10);
25570   ecode11 = SWIG_AsVal_int(obj10, &val11);
25571   if (!SWIG_IsOK(ecode11)) {
25572     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCylinderUni" "', argument " "11"" of type '" "int""'");
25573   }
25574   arg11 = static_cast< int >(val11);
25575   result = (Hex::Elements *)(arg1)->makeCylinderUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25576   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25577   return resultobj;
25578 fail:
25579   return NULL;
25580 }
25581
25582
25583 SWIGINTERN PyObject *_wrap_Document_makeCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25584   PyObject *resultobj = 0;
25585   Hex::Document *arg1 = (Hex::Document *) 0 ;
25586   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25587   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25588   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25589   Hex::RealVector arg5 ;
25590   Hex::RealVector arg6 ;
25591   Hex::RealVector arg7 ;
25592   Hex::Elements *result = 0 ;
25593   void *argp1 = 0 ;
25594   int res1 = 0 ;
25595   void *argp2 = 0 ;
25596   int res2 = 0 ;
25597   void *argp3 = 0 ;
25598   int res3 = 0 ;
25599   void *argp4 = 0 ;
25600   int res4 = 0 ;
25601   PyObject * obj0 = 0 ;
25602   PyObject * obj1 = 0 ;
25603   PyObject * obj2 = 0 ;
25604   PyObject * obj3 = 0 ;
25605   PyObject * obj4 = 0 ;
25606   PyObject * obj5 = 0 ;
25607   PyObject * obj6 = 0 ;
25608
25609   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeCylinder",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25610   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25611   if (!SWIG_IsOK(res1)) {
25612     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
25613   }
25614   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25615   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25616   if (!SWIG_IsOK(res2)) {
25617     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinder" "', argument " "2"" of type '" "Hex::Vertex *""'");
25618   }
25619   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25620   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25621   if (!SWIG_IsOK(res3)) {
25622     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinder" "', argument " "3"" of type '" "Hex::Vector *""'");
25623   }
25624   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25625   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25626   if (!SWIG_IsOK(res4)) {
25627     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinder" "', argument " "4"" of type '" "Hex::Vector *""'");
25628   }
25629   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25630   {
25631     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25632     int res = swig::asptr(obj4, &ptr);
25633     if (!SWIG_IsOK(res) || !ptr) {
25634       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "5"" of type '" "Hex::RealVector""'");
25635     }
25636     arg5 = *ptr;
25637     if (SWIG_IsNewObj(res)) delete ptr;
25638   }
25639   {
25640     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25641     int res = swig::asptr(obj5, &ptr);
25642     if (!SWIG_IsOK(res) || !ptr) {
25643       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "6"" of type '" "Hex::RealVector""'");
25644     }
25645     arg6 = *ptr;
25646     if (SWIG_IsNewObj(res)) delete ptr;
25647   }
25648   {
25649     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25650     int res = swig::asptr(obj6, &ptr);
25651     if (!SWIG_IsOK(res) || !ptr) {
25652       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "7"" of type '" "Hex::RealVector""'");
25653     }
25654     arg7 = *ptr;
25655     if (SWIG_IsNewObj(res)) delete ptr;
25656   }
25657   result = (Hex::Elements *)(arg1)->makeCylinder(arg2,arg3,arg4,arg5,arg6,arg7);
25658   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25659   return resultobj;
25660 fail:
25661   return NULL;
25662 }
25663
25664
25665 SWIGINTERN PyObject *_wrap_Document_makePipeTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25666   PyObject *resultobj = 0;
25667   Hex::Document *arg1 = (Hex::Document *) 0 ;
25668   int arg2 ;
25669   int arg3 ;
25670   int arg4 ;
25671   Hex::Elements *result = 0 ;
25672   void *argp1 = 0 ;
25673   int res1 = 0 ;
25674   int val2 ;
25675   int ecode2 = 0 ;
25676   int val3 ;
25677   int ecode3 = 0 ;
25678   int val4 ;
25679   int ecode4 = 0 ;
25680   PyObject * obj0 = 0 ;
25681   PyObject * obj1 = 0 ;
25682   PyObject * obj2 = 0 ;
25683   PyObject * obj3 = 0 ;
25684
25685   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makePipeTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25686   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25687   if (!SWIG_IsOK(res1)) {
25688     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeTop" "', argument " "1"" of type '" "Hex::Document *""'");
25689   }
25690   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25691   ecode2 = SWIG_AsVal_int(obj1, &val2);
25692   if (!SWIG_IsOK(ecode2)) {
25693     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makePipeTop" "', argument " "2"" of type '" "int""'");
25694   }
25695   arg2 = static_cast< int >(val2);
25696   ecode3 = SWIG_AsVal_int(obj2, &val3);
25697   if (!SWIG_IsOK(ecode3)) {
25698     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makePipeTop" "', argument " "3"" of type '" "int""'");
25699   }
25700   arg3 = static_cast< int >(val3);
25701   ecode4 = SWIG_AsVal_int(obj3, &val4);
25702   if (!SWIG_IsOK(ecode4)) {
25703     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipeTop" "', argument " "4"" of type '" "int""'");
25704   }
25705   arg4 = static_cast< int >(val4);
25706   result = (Hex::Elements *)(arg1)->makePipeTop(arg2,arg3,arg4);
25707   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25708   return resultobj;
25709 fail:
25710   return NULL;
25711 }
25712
25713
25714 SWIGINTERN PyObject *_wrap_Document_makePipeUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25715   PyObject *resultobj = 0;
25716   Hex::Document *arg1 = (Hex::Document *) 0 ;
25717   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25718   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25719   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25720   double arg5 ;
25721   double arg6 ;
25722   double arg7 ;
25723   double arg8 ;
25724   int arg9 ;
25725   int arg10 ;
25726   int arg11 ;
25727   Hex::Elements *result = 0 ;
25728   void *argp1 = 0 ;
25729   int res1 = 0 ;
25730   void *argp2 = 0 ;
25731   int res2 = 0 ;
25732   void *argp3 = 0 ;
25733   int res3 = 0 ;
25734   void *argp4 = 0 ;
25735   int res4 = 0 ;
25736   double val5 ;
25737   int ecode5 = 0 ;
25738   double val6 ;
25739   int ecode6 = 0 ;
25740   double val7 ;
25741   int ecode7 = 0 ;
25742   double val8 ;
25743   int ecode8 = 0 ;
25744   int val9 ;
25745   int ecode9 = 0 ;
25746   int val10 ;
25747   int ecode10 = 0 ;
25748   int val11 ;
25749   int ecode11 = 0 ;
25750   PyObject * obj0 = 0 ;
25751   PyObject * obj1 = 0 ;
25752   PyObject * obj2 = 0 ;
25753   PyObject * obj3 = 0 ;
25754   PyObject * obj4 = 0 ;
25755   PyObject * obj5 = 0 ;
25756   PyObject * obj6 = 0 ;
25757   PyObject * obj7 = 0 ;
25758   PyObject * obj8 = 0 ;
25759   PyObject * obj9 = 0 ;
25760   PyObject * obj10 = 0 ;
25761
25762   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipeUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
25763   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25764   if (!SWIG_IsOK(res1)) {
25765     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeUni" "', argument " "1"" of type '" "Hex::Document *""'");
25766   }
25767   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25768   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25769   if (!SWIG_IsOK(res2)) {
25770     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipeUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
25771   }
25772   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25773   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25774   if (!SWIG_IsOK(res3)) {
25775     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipeUni" "', argument " "3"" of type '" "Hex::Vector *""'");
25776   }
25777   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25778   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25779   if (!SWIG_IsOK(res4)) {
25780     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipeUni" "', argument " "4"" of type '" "Hex::Vector *""'");
25781   }
25782   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25783   ecode5 = SWIG_AsVal_double(obj4, &val5);
25784   if (!SWIG_IsOK(ecode5)) {
25785     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipeUni" "', argument " "5"" of type '" "double""'");
25786   }
25787   arg5 = static_cast< double >(val5);
25788   ecode6 = SWIG_AsVal_double(obj5, &val6);
25789   if (!SWIG_IsOK(ecode6)) {
25790     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipeUni" "', argument " "6"" of type '" "double""'");
25791   }
25792   arg6 = static_cast< double >(val6);
25793   ecode7 = SWIG_AsVal_double(obj6, &val7);
25794   if (!SWIG_IsOK(ecode7)) {
25795     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makePipeUni" "', argument " "7"" of type '" "double""'");
25796   }
25797   arg7 = static_cast< double >(val7);
25798   ecode8 = SWIG_AsVal_double(obj7, &val8);
25799   if (!SWIG_IsOK(ecode8)) {
25800     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makePipeUni" "', argument " "8"" of type '" "double""'");
25801   }
25802   arg8 = static_cast< double >(val8);
25803   ecode9 = SWIG_AsVal_int(obj8, &val9);
25804   if (!SWIG_IsOK(ecode9)) {
25805     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipeUni" "', argument " "9"" of type '" "int""'");
25806   }
25807   arg9 = static_cast< int >(val9);
25808   ecode10 = SWIG_AsVal_int(obj9, &val10);
25809   if (!SWIG_IsOK(ecode10)) {
25810     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipeUni" "', argument " "10"" of type '" "int""'");
25811   }
25812   arg10 = static_cast< int >(val10);
25813   ecode11 = SWIG_AsVal_int(obj10, &val11);
25814   if (!SWIG_IsOK(ecode11)) {
25815     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipeUni" "', argument " "11"" of type '" "int""'");
25816   }
25817   arg11 = static_cast< int >(val11);
25818   result = (Hex::Elements *)(arg1)->makePipeUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25819   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25820   return resultobj;
25821 fail:
25822   return NULL;
25823 }
25824
25825
25826 SWIGINTERN PyObject *_wrap_Document_makePipe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25827   PyObject *resultobj = 0;
25828   Hex::Document *arg1 = (Hex::Document *) 0 ;
25829   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25830   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
25831   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
25832   Hex::RealVector arg5 ;
25833   Hex::RealVector arg6 ;
25834   Hex::RealVector arg7 ;
25835   Hex::Elements *result = 0 ;
25836   void *argp1 = 0 ;
25837   int res1 = 0 ;
25838   void *argp2 = 0 ;
25839   int res2 = 0 ;
25840   void *argp3 = 0 ;
25841   int res3 = 0 ;
25842   void *argp4 = 0 ;
25843   int res4 = 0 ;
25844   PyObject * obj0 = 0 ;
25845   PyObject * obj1 = 0 ;
25846   PyObject * obj2 = 0 ;
25847   PyObject * obj3 = 0 ;
25848   PyObject * obj4 = 0 ;
25849   PyObject * obj5 = 0 ;
25850   PyObject * obj6 = 0 ;
25851
25852   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makePipe",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25853   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25854   if (!SWIG_IsOK(res1)) {
25855     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipe" "', argument " "1"" of type '" "Hex::Document *""'");
25856   }
25857   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25858   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25859   if (!SWIG_IsOK(res2)) {
25860     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipe" "', argument " "2"" of type '" "Hex::Vertex *""'");
25861   }
25862   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25863   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25864   if (!SWIG_IsOK(res3)) {
25865     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipe" "', argument " "3"" of type '" "Hex::Vector *""'");
25866   }
25867   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
25868   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
25869   if (!SWIG_IsOK(res4)) {
25870     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipe" "', argument " "4"" of type '" "Hex::Vector *""'");
25871   }
25872   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
25873   {
25874     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25875     int res = swig::asptr(obj4, &ptr);
25876     if (!SWIG_IsOK(res) || !ptr) {
25877       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "5"" of type '" "Hex::RealVector""'");
25878     }
25879     arg5 = *ptr;
25880     if (SWIG_IsNewObj(res)) delete ptr;
25881   }
25882   {
25883     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25884     int res = swig::asptr(obj5, &ptr);
25885     if (!SWIG_IsOK(res) || !ptr) {
25886       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "6"" of type '" "Hex::RealVector""'");
25887     }
25888     arg6 = *ptr;
25889     if (SWIG_IsNewObj(res)) delete ptr;
25890   }
25891   {
25892     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
25893     int res = swig::asptr(obj6, &ptr);
25894     if (!SWIG_IsOK(res) || !ptr) {
25895       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "7"" of type '" "Hex::RealVector""'");
25896     }
25897     arg7 = *ptr;
25898     if (SWIG_IsNewObj(res)) delete ptr;
25899   }
25900   result = (Hex::Elements *)(arg1)->makePipe(arg2,arg3,arg4,arg5,arg6,arg7);
25901   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25902   return resultobj;
25903 fail:
25904   return NULL;
25905 }
25906
25907
25908 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25909   PyObject *resultobj = 0;
25910   Hex::Document *arg1 = (Hex::Document *) 0 ;
25911   int arg2 ;
25912   int arg3 ;
25913   Hex::Elements *result = 0 ;
25914   void *argp1 = 0 ;
25915   int res1 = 0 ;
25916   int val2 ;
25917   int ecode2 = 0 ;
25918   int val3 ;
25919   int ecode3 = 0 ;
25920   PyObject * obj0 = 0 ;
25921   PyObject * obj1 = 0 ;
25922   PyObject * obj2 = 0 ;
25923
25924   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSphericalTop",&obj0,&obj1,&obj2)) SWIG_fail;
25925   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25926   if (!SWIG_IsOK(res1)) {
25927     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
25928   }
25929   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25930   ecode2 = SWIG_AsVal_int(obj1, &val2);
25931   if (!SWIG_IsOK(ecode2)) {
25932     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
25933   }
25934   arg2 = static_cast< int >(val2);
25935   ecode3 = SWIG_AsVal_int(obj2, &val3);
25936   if (!SWIG_IsOK(ecode3)) {
25937     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphericalTop" "', argument " "3"" of type '" "int""'");
25938   }
25939   arg3 = static_cast< int >(val3);
25940   result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2,arg3);
25941   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25942   return resultobj;
25943 fail:
25944   return NULL;
25945 }
25946
25947
25948 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25949   PyObject *resultobj = 0;
25950   Hex::Document *arg1 = (Hex::Document *) 0 ;
25951   int arg2 ;
25952   Hex::Elements *result = 0 ;
25953   void *argp1 = 0 ;
25954   int res1 = 0 ;
25955   int val2 ;
25956   int ecode2 = 0 ;
25957   PyObject * obj0 = 0 ;
25958   PyObject * obj1 = 0 ;
25959
25960   if (!PyArg_ParseTuple(args,(char *)"OO:Document_makeSphericalTop",&obj0,&obj1)) SWIG_fail;
25961   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25962   if (!SWIG_IsOK(res1)) {
25963     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
25964   }
25965   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25966   ecode2 = SWIG_AsVal_int(obj1, &val2);
25967   if (!SWIG_IsOK(ecode2)) {
25968     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
25969   }
25970   arg2 = static_cast< int >(val2);
25971   result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2);
25972   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
25973   return resultobj;
25974 fail:
25975   return NULL;
25976 }
25977
25978
25979 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop(PyObject *self, PyObject *args) {
25980   int argc;
25981   PyObject *argv[4];
25982   int ii;
25983
25984   if (!PyTuple_Check(args)) SWIG_fail;
25985   argc = PyObject_Length(args);
25986   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
25987     argv[ii] = PyTuple_GET_ITEM(args,ii);
25988   }
25989   if (argc == 2) {
25990     int _v;
25991     void *vptr = 0;
25992     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25993     _v = SWIG_CheckState(res);
25994     if (_v) {
25995       {
25996         int res = SWIG_AsVal_int(argv[1], NULL);
25997         _v = SWIG_CheckState(res);
25998       }
25999       if (_v) {
26000         return _wrap_Document_makeSphericalTop__SWIG_1(self, args);
26001       }
26002     }
26003   }
26004   if (argc == 3) {
26005     int _v;
26006     void *vptr = 0;
26007     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26008     _v = SWIG_CheckState(res);
26009     if (_v) {
26010       {
26011         int res = SWIG_AsVal_int(argv[1], NULL);
26012         _v = SWIG_CheckState(res);
26013       }
26014       if (_v) {
26015         {
26016           int res = SWIG_AsVal_int(argv[2], NULL);
26017           _v = SWIG_CheckState(res);
26018         }
26019         if (_v) {
26020           return _wrap_Document_makeSphericalTop__SWIG_0(self, args);
26021         }
26022       }
26023     }
26024   }
26025
26026 fail:
26027   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");
26028   return NULL;
26029 }
26030
26031
26032 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26033   PyObject *resultobj = 0;
26034   Hex::Document *arg1 = (Hex::Document *) 0 ;
26035   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26036   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26037   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26038   double arg5 ;
26039   int arg6 ;
26040   int arg7 ;
26041   Hex::Elements *result = 0 ;
26042   void *argp1 = 0 ;
26043   int res1 = 0 ;
26044   void *argp2 = 0 ;
26045   int res2 = 0 ;
26046   void *argp3 = 0 ;
26047   int res3 = 0 ;
26048   void *argp4 = 0 ;
26049   int res4 = 0 ;
26050   double val5 ;
26051   int ecode5 = 0 ;
26052   int val6 ;
26053   int ecode6 = 0 ;
26054   int val7 ;
26055   int ecode7 = 0 ;
26056   PyObject * obj0 = 0 ;
26057   PyObject * obj1 = 0 ;
26058   PyObject * obj2 = 0 ;
26059   PyObject * obj3 = 0 ;
26060   PyObject * obj4 = 0 ;
26061   PyObject * obj5 = 0 ;
26062   PyObject * obj6 = 0 ;
26063
26064   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26065   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26066   if (!SWIG_IsOK(res1)) {
26067     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
26068   }
26069   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26070   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26071   if (!SWIG_IsOK(res2)) {
26072     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26073   }
26074   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26075   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26076   if (!SWIG_IsOK(res3)) {
26077     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26078   }
26079   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26080   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26081   if (!SWIG_IsOK(res4)) {
26082     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26083   }
26084   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26085   ecode5 = SWIG_AsVal_double(obj4, &val5);
26086   if (!SWIG_IsOK(ecode5)) {
26087     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
26088   }
26089   arg5 = static_cast< double >(val5);
26090   ecode6 = SWIG_AsVal_int(obj5, &val6);
26091   if (!SWIG_IsOK(ecode6)) {
26092     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
26093   }
26094   arg6 = static_cast< int >(val6);
26095   ecode7 = SWIG_AsVal_int(obj6, &val7);
26096   if (!SWIG_IsOK(ecode7)) {
26097     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphericalUni" "', argument " "7"" of type '" "int""'");
26098   }
26099   arg7 = static_cast< int >(val7);
26100   result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6,arg7);
26101   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26102   return resultobj;
26103 fail:
26104   return NULL;
26105 }
26106
26107
26108 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26109   PyObject *resultobj = 0;
26110   Hex::Document *arg1 = (Hex::Document *) 0 ;
26111   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26112   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26113   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26114   double arg5 ;
26115   int arg6 ;
26116   Hex::Elements *result = 0 ;
26117   void *argp1 = 0 ;
26118   int res1 = 0 ;
26119   void *argp2 = 0 ;
26120   int res2 = 0 ;
26121   void *argp3 = 0 ;
26122   int res3 = 0 ;
26123   void *argp4 = 0 ;
26124   int res4 = 0 ;
26125   double val5 ;
26126   int ecode5 = 0 ;
26127   int val6 ;
26128   int ecode6 = 0 ;
26129   PyObject * obj0 = 0 ;
26130   PyObject * obj1 = 0 ;
26131   PyObject * obj2 = 0 ;
26132   PyObject * obj3 = 0 ;
26133   PyObject * obj4 = 0 ;
26134   PyObject * obj5 = 0 ;
26135
26136   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
26137   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26138   if (!SWIG_IsOK(res1)) {
26139     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
26140   }
26141   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26142   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26143   if (!SWIG_IsOK(res2)) {
26144     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26145   }
26146   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26147   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26148   if (!SWIG_IsOK(res3)) {
26149     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26150   }
26151   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26152   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26153   if (!SWIG_IsOK(res4)) {
26154     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26155   }
26156   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26157   ecode5 = SWIG_AsVal_double(obj4, &val5);
26158   if (!SWIG_IsOK(ecode5)) {
26159     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
26160   }
26161   arg5 = static_cast< double >(val5);
26162   ecode6 = SWIG_AsVal_int(obj5, &val6);
26163   if (!SWIG_IsOK(ecode6)) {
26164     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
26165   }
26166   arg6 = static_cast< int >(val6);
26167   result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6);
26168   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26169   return resultobj;
26170 fail:
26171   return NULL;
26172 }
26173
26174
26175 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni(PyObject *self, PyObject *args) {
26176   int argc;
26177   PyObject *argv[8];
26178   int ii;
26179
26180   if (!PyTuple_Check(args)) SWIG_fail;
26181   argc = PyObject_Length(args);
26182   for (ii = 0; (ii < argc) && (ii < 7); ii++) {
26183     argv[ii] = PyTuple_GET_ITEM(args,ii);
26184   }
26185   if (argc == 6) {
26186     int _v;
26187     void *vptr = 0;
26188     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26189     _v = SWIG_CheckState(res);
26190     if (_v) {
26191       void *vptr = 0;
26192       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26193       _v = SWIG_CheckState(res);
26194       if (_v) {
26195         void *vptr = 0;
26196         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26197         _v = SWIG_CheckState(res);
26198         if (_v) {
26199           void *vptr = 0;
26200           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26201           _v = SWIG_CheckState(res);
26202           if (_v) {
26203             {
26204               int res = SWIG_AsVal_double(argv[4], NULL);
26205               _v = SWIG_CheckState(res);
26206             }
26207             if (_v) {
26208               {
26209                 int res = SWIG_AsVal_int(argv[5], NULL);
26210                 _v = SWIG_CheckState(res);
26211               }
26212               if (_v) {
26213                 return _wrap_Document_makeSphericalUni__SWIG_1(self, args);
26214               }
26215             }
26216           }
26217         }
26218       }
26219     }
26220   }
26221   if (argc == 7) {
26222     int _v;
26223     void *vptr = 0;
26224     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26225     _v = SWIG_CheckState(res);
26226     if (_v) {
26227       void *vptr = 0;
26228       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26229       _v = SWIG_CheckState(res);
26230       if (_v) {
26231         void *vptr = 0;
26232         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26233         _v = SWIG_CheckState(res);
26234         if (_v) {
26235           void *vptr = 0;
26236           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26237           _v = SWIG_CheckState(res);
26238           if (_v) {
26239             {
26240               int res = SWIG_AsVal_double(argv[4], NULL);
26241               _v = SWIG_CheckState(res);
26242             }
26243             if (_v) {
26244               {
26245                 int res = SWIG_AsVal_int(argv[5], NULL);
26246                 _v = SWIG_CheckState(res);
26247               }
26248               if (_v) {
26249                 {
26250                   int res = SWIG_AsVal_int(argv[6], NULL);
26251                   _v = SWIG_CheckState(res);
26252                 }
26253                 if (_v) {
26254                   return _wrap_Document_makeSphericalUni__SWIG_0(self, args);
26255                 }
26256               }
26257             }
26258           }
26259         }
26260       }
26261     }
26262   }
26263
26264 fail:
26265   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");
26266   return NULL;
26267 }
26268
26269
26270 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26271   PyObject *resultobj = 0;
26272   Hex::Document *arg1 = (Hex::Document *) 0 ;
26273   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26274   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26275   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26276   Hex::RealVector arg5 ;
26277   int arg6 ;
26278   Hex::Elements *result = 0 ;
26279   void *argp1 = 0 ;
26280   int res1 = 0 ;
26281   void *argp2 = 0 ;
26282   int res2 = 0 ;
26283   void *argp3 = 0 ;
26284   int res3 = 0 ;
26285   void *argp4 = 0 ;
26286   int res4 = 0 ;
26287   int val6 ;
26288   int ecode6 = 0 ;
26289   PyObject * obj0 = 0 ;
26290   PyObject * obj1 = 0 ;
26291   PyObject * obj2 = 0 ;
26292   PyObject * obj3 = 0 ;
26293   PyObject * obj4 = 0 ;
26294   PyObject * obj5 = 0 ;
26295
26296   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
26297   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26298   if (!SWIG_IsOK(res1)) {
26299     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
26300   }
26301   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26302   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26303   if (!SWIG_IsOK(res2)) {
26304     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
26305   }
26306   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26307   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26308   if (!SWIG_IsOK(res3)) {
26309     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
26310   }
26311   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26312   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26313   if (!SWIG_IsOK(res4)) {
26314     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
26315   }
26316   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26317   {
26318     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26319     int res = swig::asptr(obj4, &ptr);
26320     if (!SWIG_IsOK(res) || !ptr) {
26321       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
26322     }
26323     arg5 = *ptr;
26324     if (SWIG_IsNewObj(res)) delete ptr;
26325   }
26326   ecode6 = SWIG_AsVal_int(obj5, &val6);
26327   if (!SWIG_IsOK(ecode6)) {
26328     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSpherical" "', argument " "6"" of type '" "int""'");
26329   }
26330   arg6 = static_cast< int >(val6);
26331   result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5,arg6);
26332   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26333   return resultobj;
26334 fail:
26335   return NULL;
26336 }
26337
26338
26339 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26340   PyObject *resultobj = 0;
26341   Hex::Document *arg1 = (Hex::Document *) 0 ;
26342   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26343   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26344   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26345   Hex::RealVector arg5 ;
26346   Hex::Elements *result = 0 ;
26347   void *argp1 = 0 ;
26348   int res1 = 0 ;
26349   void *argp2 = 0 ;
26350   int res2 = 0 ;
26351   void *argp3 = 0 ;
26352   int res3 = 0 ;
26353   void *argp4 = 0 ;
26354   int res4 = 0 ;
26355   PyObject * obj0 = 0 ;
26356   PyObject * obj1 = 0 ;
26357   PyObject * obj2 = 0 ;
26358   PyObject * obj3 = 0 ;
26359   PyObject * obj4 = 0 ;
26360
26361   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26362   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26363   if (!SWIG_IsOK(res1)) {
26364     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
26365   }
26366   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26367   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26368   if (!SWIG_IsOK(res2)) {
26369     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
26370   }
26371   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26372   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26373   if (!SWIG_IsOK(res3)) {
26374     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
26375   }
26376   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26377   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26378   if (!SWIG_IsOK(res4)) {
26379     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
26380   }
26381   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26382   {
26383     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26384     int res = swig::asptr(obj4, &ptr);
26385     if (!SWIG_IsOK(res) || !ptr) {
26386       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
26387     }
26388     arg5 = *ptr;
26389     if (SWIG_IsNewObj(res)) delete ptr;
26390   }
26391   result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5);
26392   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26393   return resultobj;
26394 fail:
26395   return NULL;
26396 }
26397
26398
26399 SWIGINTERN PyObject *_wrap_Document_makeSpherical(PyObject *self, PyObject *args) {
26400   int argc;
26401   PyObject *argv[7];
26402   int ii;
26403
26404   if (!PyTuple_Check(args)) SWIG_fail;
26405   argc = PyObject_Length(args);
26406   for (ii = 0; (ii < argc) && (ii < 6); ii++) {
26407     argv[ii] = PyTuple_GET_ITEM(args,ii);
26408   }
26409   if (argc == 5) {
26410     int _v;
26411     void *vptr = 0;
26412     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26413     _v = SWIG_CheckState(res);
26414     if (_v) {
26415       void *vptr = 0;
26416       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26417       _v = SWIG_CheckState(res);
26418       if (_v) {
26419         void *vptr = 0;
26420         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26421         _v = SWIG_CheckState(res);
26422         if (_v) {
26423           void *vptr = 0;
26424           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26425           _v = SWIG_CheckState(res);
26426           if (_v) {
26427             int res = swig::asptr(argv[4], (std::vector<double,std::allocator<double > >**)(0));
26428             _v = SWIG_CheckState(res);
26429             if (_v) {
26430               return _wrap_Document_makeSpherical__SWIG_1(self, args);
26431             }
26432           }
26433         }
26434       }
26435     }
26436   }
26437   if (argc == 6) {
26438     int _v;
26439     void *vptr = 0;
26440     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
26441     _v = SWIG_CheckState(res);
26442     if (_v) {
26443       void *vptr = 0;
26444       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
26445       _v = SWIG_CheckState(res);
26446       if (_v) {
26447         void *vptr = 0;
26448         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26449         _v = SWIG_CheckState(res);
26450         if (_v) {
26451           void *vptr = 0;
26452           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
26453           _v = SWIG_CheckState(res);
26454           if (_v) {
26455             int res = swig::asptr(argv[4], (std::vector<double,std::allocator<double > >**)(0));
26456             _v = SWIG_CheckState(res);
26457             if (_v) {
26458               {
26459                 int res = SWIG_AsVal_int(argv[5], NULL);
26460                 _v = SWIG_CheckState(res);
26461               }
26462               if (_v) {
26463                 return _wrap_Document_makeSpherical__SWIG_0(self, args);
26464               }
26465             }
26466           }
26467         }
26468       }
26469     }
26470   }
26471
26472 fail:
26473   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");
26474   return NULL;
26475 }
26476
26477
26478 SWIGINTERN PyObject *_wrap_Document_makeSphereTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26479   PyObject *resultobj = 0;
26480   Hex::Document *arg1 = (Hex::Document *) 0 ;
26481   int arg2 ;
26482   int arg3 ;
26483   int arg4 ;
26484   Hex::Elements *result = 0 ;
26485   void *argp1 = 0 ;
26486   int res1 = 0 ;
26487   int val2 ;
26488   int ecode2 = 0 ;
26489   int val3 ;
26490   int ecode3 = 0 ;
26491   int val4 ;
26492   int ecode4 = 0 ;
26493   PyObject * obj0 = 0 ;
26494   PyObject * obj1 = 0 ;
26495   PyObject * obj2 = 0 ;
26496   PyObject * obj3 = 0 ;
26497
26498   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSphereTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26499   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26500   if (!SWIG_IsOK(res1)) {
26501     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereTop" "', argument " "1"" of type '" "Hex::Document *""'");
26502   }
26503   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26504   ecode2 = SWIG_AsVal_int(obj1, &val2);
26505   if (!SWIG_IsOK(ecode2)) {
26506     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphereTop" "', argument " "2"" of type '" "int""'");
26507   }
26508   arg2 = static_cast< int >(val2);
26509   ecode3 = SWIG_AsVal_int(obj2, &val3);
26510   if (!SWIG_IsOK(ecode3)) {
26511     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphereTop" "', argument " "3"" of type '" "int""'");
26512   }
26513   arg3 = static_cast< int >(val3);
26514   ecode4 = SWIG_AsVal_int(obj3, &val4);
26515   if (!SWIG_IsOK(ecode4)) {
26516     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeSphereTop" "', argument " "4"" of type '" "int""'");
26517   }
26518   arg4 = static_cast< int >(val4);
26519   result = (Hex::Elements *)(arg1)->makeSphereTop(arg2,arg3,arg4);
26520   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26521   return resultobj;
26522 fail:
26523   return NULL;
26524 }
26525
26526
26527 SWIGINTERN PyObject *_wrap_Document_makeSphereUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26528   PyObject *resultobj = 0;
26529   Hex::Document *arg1 = (Hex::Document *) 0 ;
26530   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26531   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26532   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26533   double arg5 ;
26534   double arg6 ;
26535   double arg7 ;
26536   Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
26537   int arg9 ;
26538   int arg10 ;
26539   int arg11 ;
26540   Hex::Elements *result = 0 ;
26541   void *argp1 = 0 ;
26542   int res1 = 0 ;
26543   void *argp2 = 0 ;
26544   int res2 = 0 ;
26545   void *argp3 = 0 ;
26546   int res3 = 0 ;
26547   void *argp4 = 0 ;
26548   int res4 = 0 ;
26549   double val5 ;
26550   int ecode5 = 0 ;
26551   double val6 ;
26552   int ecode6 = 0 ;
26553   double val7 ;
26554   int ecode7 = 0 ;
26555   void *argp8 = 0 ;
26556   int res8 = 0 ;
26557   int val9 ;
26558   int ecode9 = 0 ;
26559   int val10 ;
26560   int ecode10 = 0 ;
26561   int val11 ;
26562   int ecode11 = 0 ;
26563   PyObject * obj0 = 0 ;
26564   PyObject * obj1 = 0 ;
26565   PyObject * obj2 = 0 ;
26566   PyObject * obj3 = 0 ;
26567   PyObject * obj4 = 0 ;
26568   PyObject * obj5 = 0 ;
26569   PyObject * obj6 = 0 ;
26570   PyObject * obj7 = 0 ;
26571   PyObject * obj8 = 0 ;
26572   PyObject * obj9 = 0 ;
26573   PyObject * obj10 = 0 ;
26574
26575   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeSphereUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
26576   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26577   if (!SWIG_IsOK(res1)) {
26578     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereUni" "', argument " "1"" of type '" "Hex::Document *""'");
26579   }
26580   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26581   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26582   if (!SWIG_IsOK(res2)) {
26583     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphereUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26584   }
26585   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26586   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26587   if (!SWIG_IsOK(res3)) {
26588     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphereUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26589   }
26590   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26591   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26592   if (!SWIG_IsOK(res4)) {
26593     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphereUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26594   }
26595   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26596   ecode5 = SWIG_AsVal_double(obj4, &val5);
26597   if (!SWIG_IsOK(ecode5)) {
26598     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphereUni" "', argument " "5"" of type '" "double""'");
26599   }
26600   arg5 = static_cast< double >(val5);
26601   ecode6 = SWIG_AsVal_double(obj5, &val6);
26602   if (!SWIG_IsOK(ecode6)) {
26603     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphereUni" "', argument " "6"" of type '" "double""'");
26604   }
26605   arg6 = static_cast< double >(val6);
26606   ecode7 = SWIG_AsVal_double(obj6, &val7);
26607   if (!SWIG_IsOK(ecode7)) {
26608     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphereUni" "', argument " "7"" of type '" "double""'");
26609   }
26610   arg7 = static_cast< double >(val7);
26611   res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26612   if (!SWIG_IsOK(res8)) {
26613     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makeSphereUni" "', argument " "8"" of type '" "Hex::Vertex *""'");
26614   }
26615   arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
26616   ecode9 = SWIG_AsVal_int(obj8, &val9);
26617   if (!SWIG_IsOK(ecode9)) {
26618     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeSphereUni" "', argument " "9"" of type '" "int""'");
26619   }
26620   arg9 = static_cast< int >(val9);
26621   ecode10 = SWIG_AsVal_int(obj9, &val10);
26622   if (!SWIG_IsOK(ecode10)) {
26623     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeSphereUni" "', argument " "10"" of type '" "int""'");
26624   }
26625   arg10 = static_cast< int >(val10);
26626   ecode11 = SWIG_AsVal_int(obj10, &val11);
26627   if (!SWIG_IsOK(ecode11)) {
26628     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeSphereUni" "', argument " "11"" of type '" "int""'");
26629   }
26630   arg11 = static_cast< int >(val11);
26631   result = (Hex::Elements *)(arg1)->makeSphereUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26632   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26633   return resultobj;
26634 fail:
26635   return NULL;
26636 }
26637
26638
26639 SWIGINTERN PyObject *_wrap_Document_makeSphere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26640   PyObject *resultobj = 0;
26641   Hex::Document *arg1 = (Hex::Document *) 0 ;
26642   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26643   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26644   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26645   Hex::RealVector arg5 ;
26646   Hex::RealVector arg6 ;
26647   Hex::RealVector arg7 ;
26648   Hex::Elements *result = 0 ;
26649   void *argp1 = 0 ;
26650   int res1 = 0 ;
26651   void *argp2 = 0 ;
26652   int res2 = 0 ;
26653   void *argp3 = 0 ;
26654   int res3 = 0 ;
26655   void *argp4 = 0 ;
26656   int res4 = 0 ;
26657   PyObject * obj0 = 0 ;
26658   PyObject * obj1 = 0 ;
26659   PyObject * obj2 = 0 ;
26660   PyObject * obj3 = 0 ;
26661   PyObject * obj4 = 0 ;
26662   PyObject * obj5 = 0 ;
26663   PyObject * obj6 = 0 ;
26664
26665   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphere",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26666   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26667   if (!SWIG_IsOK(res1)) {
26668     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphere" "', argument " "1"" of type '" "Hex::Document *""'");
26669   }
26670   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26671   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26672   if (!SWIG_IsOK(res2)) {
26673     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphere" "', argument " "2"" of type '" "Hex::Vertex *""'");
26674   }
26675   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26676   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26677   if (!SWIG_IsOK(res3)) {
26678     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphere" "', argument " "3"" of type '" "Hex::Vector *""'");
26679   }
26680   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26681   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26682   if (!SWIG_IsOK(res4)) {
26683     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphere" "', argument " "4"" of type '" "Hex::Vector *""'");
26684   }
26685   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26686   {
26687     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26688     int res = swig::asptr(obj4, &ptr);
26689     if (!SWIG_IsOK(res) || !ptr) {
26690       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "5"" of type '" "Hex::RealVector""'");
26691     }
26692     arg5 = *ptr;
26693     if (SWIG_IsNewObj(res)) delete ptr;
26694   }
26695   {
26696     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26697     int res = swig::asptr(obj5, &ptr);
26698     if (!SWIG_IsOK(res) || !ptr) {
26699       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "6"" of type '" "Hex::RealVector""'");
26700     }
26701     arg6 = *ptr;
26702     if (SWIG_IsNewObj(res)) delete ptr;
26703   }
26704   {
26705     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26706     int res = swig::asptr(obj6, &ptr);
26707     if (!SWIG_IsOK(res) || !ptr) {
26708       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "7"" of type '" "Hex::RealVector""'");
26709     }
26710     arg7 = *ptr;
26711     if (SWIG_IsNewObj(res)) delete ptr;
26712   }
26713   result = (Hex::Elements *)(arg1)->makeSphere(arg2,arg3,arg4,arg5,arg6,arg7);
26714   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26715   return resultobj;
26716 fail:
26717   return NULL;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_Document_makeRindTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26722   PyObject *resultobj = 0;
26723   Hex::Document *arg1 = (Hex::Document *) 0 ;
26724   int arg2 ;
26725   int arg3 ;
26726   int arg4 ;
26727   Hex::Elements *result = 0 ;
26728   void *argp1 = 0 ;
26729   int res1 = 0 ;
26730   int val2 ;
26731   int ecode2 = 0 ;
26732   int val3 ;
26733   int ecode3 = 0 ;
26734   int val4 ;
26735   int ecode4 = 0 ;
26736   PyObject * obj0 = 0 ;
26737   PyObject * obj1 = 0 ;
26738   PyObject * obj2 = 0 ;
26739   PyObject * obj3 = 0 ;
26740
26741   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeRindTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26742   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26743   if (!SWIG_IsOK(res1)) {
26744     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindTop" "', argument " "1"" of type '" "Hex::Document *""'");
26745   }
26746   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26747   ecode2 = SWIG_AsVal_int(obj1, &val2);
26748   if (!SWIG_IsOK(ecode2)) {
26749     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeRindTop" "', argument " "2"" of type '" "int""'");
26750   }
26751   arg2 = static_cast< int >(val2);
26752   ecode3 = SWIG_AsVal_int(obj2, &val3);
26753   if (!SWIG_IsOK(ecode3)) {
26754     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeRindTop" "', argument " "3"" of type '" "int""'");
26755   }
26756   arg3 = static_cast< int >(val3);
26757   ecode4 = SWIG_AsVal_int(obj3, &val4);
26758   if (!SWIG_IsOK(ecode4)) {
26759     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeRindTop" "', argument " "4"" of type '" "int""'");
26760   }
26761   arg4 = static_cast< int >(val4);
26762   result = (Hex::Elements *)(arg1)->makeRindTop(arg2,arg3,arg4);
26763   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26764   return resultobj;
26765 fail:
26766   return NULL;
26767 }
26768
26769
26770 SWIGINTERN PyObject *_wrap_Document_makeRindUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26771   PyObject *resultobj = 0;
26772   Hex::Document *arg1 = (Hex::Document *) 0 ;
26773   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26774   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26775   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26776   double arg5 ;
26777   double arg6 ;
26778   double arg7 ;
26779   double arg8 ;
26780   Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
26781   int arg10 ;
26782   int arg11 ;
26783   int arg12 ;
26784   Hex::Elements *result = 0 ;
26785   void *argp1 = 0 ;
26786   int res1 = 0 ;
26787   void *argp2 = 0 ;
26788   int res2 = 0 ;
26789   void *argp3 = 0 ;
26790   int res3 = 0 ;
26791   void *argp4 = 0 ;
26792   int res4 = 0 ;
26793   double val5 ;
26794   int ecode5 = 0 ;
26795   double val6 ;
26796   int ecode6 = 0 ;
26797   double val7 ;
26798   int ecode7 = 0 ;
26799   double val8 ;
26800   int ecode8 = 0 ;
26801   void *argp9 = 0 ;
26802   int res9 = 0 ;
26803   int val10 ;
26804   int ecode10 = 0 ;
26805   int val11 ;
26806   int ecode11 = 0 ;
26807   int val12 ;
26808   int ecode12 = 0 ;
26809   PyObject * obj0 = 0 ;
26810   PyObject * obj1 = 0 ;
26811   PyObject * obj2 = 0 ;
26812   PyObject * obj3 = 0 ;
26813   PyObject * obj4 = 0 ;
26814   PyObject * obj5 = 0 ;
26815   PyObject * obj6 = 0 ;
26816   PyObject * obj7 = 0 ;
26817   PyObject * obj8 = 0 ;
26818   PyObject * obj9 = 0 ;
26819   PyObject * obj10 = 0 ;
26820   PyObject * obj11 = 0 ;
26821
26822   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Document_makeRindUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
26823   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26824   if (!SWIG_IsOK(res1)) {
26825     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindUni" "', argument " "1"" of type '" "Hex::Document *""'");
26826   }
26827   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26828   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26829   if (!SWIG_IsOK(res2)) {
26830     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRindUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
26831   }
26832   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26833   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26834   if (!SWIG_IsOK(res3)) {
26835     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRindUni" "', argument " "3"" of type '" "Hex::Vector *""'");
26836   }
26837   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26838   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26839   if (!SWIG_IsOK(res4)) {
26840     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRindUni" "', argument " "4"" of type '" "Hex::Vector *""'");
26841   }
26842   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26843   ecode5 = SWIG_AsVal_double(obj4, &val5);
26844   if (!SWIG_IsOK(ecode5)) {
26845     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeRindUni" "', argument " "5"" of type '" "double""'");
26846   }
26847   arg5 = static_cast< double >(val5);
26848   ecode6 = SWIG_AsVal_double(obj5, &val6);
26849   if (!SWIG_IsOK(ecode6)) {
26850     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeRindUni" "', argument " "6"" of type '" "double""'");
26851   }
26852   arg6 = static_cast< double >(val6);
26853   ecode7 = SWIG_AsVal_double(obj6, &val7);
26854   if (!SWIG_IsOK(ecode7)) {
26855     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeRindUni" "', argument " "7"" of type '" "double""'");
26856   }
26857   arg7 = static_cast< double >(val7);
26858   ecode8 = SWIG_AsVal_double(obj7, &val8);
26859   if (!SWIG_IsOK(ecode8)) {
26860     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeRindUni" "', argument " "8"" of type '" "double""'");
26861   }
26862   arg8 = static_cast< double >(val8);
26863   res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26864   if (!SWIG_IsOK(res9)) {
26865     SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Document_makeRindUni" "', argument " "9"" of type '" "Hex::Vertex *""'");
26866   }
26867   arg9 = reinterpret_cast< Hex::Vertex * >(argp9);
26868   ecode10 = SWIG_AsVal_int(obj9, &val10);
26869   if (!SWIG_IsOK(ecode10)) {
26870     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeRindUni" "', argument " "10"" of type '" "int""'");
26871   }
26872   arg10 = static_cast< int >(val10);
26873   ecode11 = SWIG_AsVal_int(obj10, &val11);
26874   if (!SWIG_IsOK(ecode11)) {
26875     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeRindUni" "', argument " "11"" of type '" "int""'");
26876   }
26877   arg11 = static_cast< int >(val11);
26878   ecode12 = SWIG_AsVal_int(obj11, &val12);
26879   if (!SWIG_IsOK(ecode12)) {
26880     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Document_makeRindUni" "', argument " "12"" of type '" "int""'");
26881   }
26882   arg12 = static_cast< int >(val12);
26883   result = (Hex::Elements *)(arg1)->makeRindUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
26884   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26885   return resultobj;
26886 fail:
26887   return NULL;
26888 }
26889
26890
26891 SWIGINTERN PyObject *_wrap_Document_makeRind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26892   PyObject *resultobj = 0;
26893   Hex::Document *arg1 = (Hex::Document *) 0 ;
26894   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26895   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26896   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26897   Hex::RealVector arg5 ;
26898   Hex::RealVector arg6 ;
26899   Hex::RealVector arg7 ;
26900   Hex::Elements *result = 0 ;
26901   void *argp1 = 0 ;
26902   int res1 = 0 ;
26903   void *argp2 = 0 ;
26904   int res2 = 0 ;
26905   void *argp3 = 0 ;
26906   int res3 = 0 ;
26907   void *argp4 = 0 ;
26908   int res4 = 0 ;
26909   PyObject * obj0 = 0 ;
26910   PyObject * obj1 = 0 ;
26911   PyObject * obj2 = 0 ;
26912   PyObject * obj3 = 0 ;
26913   PyObject * obj4 = 0 ;
26914   PyObject * obj5 = 0 ;
26915   PyObject * obj6 = 0 ;
26916
26917   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeRind",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26918   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26919   if (!SWIG_IsOK(res1)) {
26920     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRind" "', argument " "1"" of type '" "Hex::Document *""'");
26921   }
26922   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26923   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26924   if (!SWIG_IsOK(res2)) {
26925     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRind" "', argument " "2"" of type '" "Hex::Vertex *""'");
26926   }
26927   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26928   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26929   if (!SWIG_IsOK(res3)) {
26930     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRind" "', argument " "3"" of type '" "Hex::Vector *""'");
26931   }
26932   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26933   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26934   if (!SWIG_IsOK(res4)) {
26935     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRind" "', argument " "4"" of type '" "Hex::Vector *""'");
26936   }
26937   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26938   {
26939     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26940     int res = swig::asptr(obj4, &ptr);
26941     if (!SWIG_IsOK(res) || !ptr) {
26942       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "5"" of type '" "Hex::RealVector""'");
26943     }
26944     arg5 = *ptr;
26945     if (SWIG_IsNewObj(res)) delete ptr;
26946   }
26947   {
26948     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26949     int res = swig::asptr(obj5, &ptr);
26950     if (!SWIG_IsOK(res) || !ptr) {
26951       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "6"" of type '" "Hex::RealVector""'");
26952     }
26953     arg6 = *ptr;
26954     if (SWIG_IsNewObj(res)) delete ptr;
26955   }
26956   {
26957     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
26958     int res = swig::asptr(obj6, &ptr);
26959     if (!SWIG_IsOK(res) || !ptr) {
26960       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "7"" of type '" "Hex::RealVector""'");
26961     }
26962     arg7 = *ptr;
26963     if (SWIG_IsNewObj(res)) delete ptr;
26964   }
26965   result = (Hex::Elements *)(arg1)->makeRind(arg2,arg3,arg4,arg5,arg6,arg7);
26966   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26967   return resultobj;
26968 fail:
26969   return NULL;
26970 }
26971
26972
26973 SWIGINTERN PyObject *_wrap_Document_makeCylinders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26974   PyObject *resultobj = 0;
26975   Hex::Document *arg1 = (Hex::Document *) 0 ;
26976   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26977   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26978   double arg4 ;
26979   double arg5 ;
26980   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
26981   Hex::Vector *arg7 = (Hex::Vector *) 0 ;
26982   double arg8 ;
26983   double arg9 ;
26984   Hex::BiCylinder *result = 0 ;
26985   void *argp1 = 0 ;
26986   int res1 = 0 ;
26987   void *argp2 = 0 ;
26988   int res2 = 0 ;
26989   void *argp3 = 0 ;
26990   int res3 = 0 ;
26991   double val4 ;
26992   int ecode4 = 0 ;
26993   double val5 ;
26994   int ecode5 = 0 ;
26995   void *argp6 = 0 ;
26996   int res6 = 0 ;
26997   void *argp7 = 0 ;
26998   int res7 = 0 ;
26999   double val8 ;
27000   int ecode8 = 0 ;
27001   double val9 ;
27002   int ecode9 = 0 ;
27003   PyObject * obj0 = 0 ;
27004   PyObject * obj1 = 0 ;
27005   PyObject * obj2 = 0 ;
27006   PyObject * obj3 = 0 ;
27007   PyObject * obj4 = 0 ;
27008   PyObject * obj5 = 0 ;
27009   PyObject * obj6 = 0 ;
27010   PyObject * obj7 = 0 ;
27011   PyObject * obj8 = 0 ;
27012
27013   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_makeCylinders",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
27014   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27015   if (!SWIG_IsOK(res1)) {
27016     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinders" "', argument " "1"" of type '" "Hex::Document *""'");
27017   }
27018   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27019   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27020   if (!SWIG_IsOK(res2)) {
27021     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinders" "', argument " "2"" of type '" "Hex::Vertex *""'");
27022   }
27023   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27024   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27025   if (!SWIG_IsOK(res3)) {
27026     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinders" "', argument " "3"" of type '" "Hex::Vector *""'");
27027   }
27028   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27029   ecode4 = SWIG_AsVal_double(obj3, &val4);
27030   if (!SWIG_IsOK(ecode4)) {
27031     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinders" "', argument " "4"" of type '" "double""'");
27032   }
27033   arg4 = static_cast< double >(val4);
27034   ecode5 = SWIG_AsVal_double(obj4, &val5);
27035   if (!SWIG_IsOK(ecode5)) {
27036     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinders" "', argument " "5"" of type '" "double""'");
27037   }
27038   arg5 = static_cast< double >(val5);
27039   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27040   if (!SWIG_IsOK(res6)) {
27041     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_makeCylinders" "', argument " "6"" of type '" "Hex::Vertex *""'");
27042   }
27043   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27044   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27045   if (!SWIG_IsOK(res7)) {
27046     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makeCylinders" "', argument " "7"" of type '" "Hex::Vector *""'");
27047   }
27048   arg7 = reinterpret_cast< Hex::Vector * >(argp7);
27049   ecode8 = SWIG_AsVal_double(obj7, &val8);
27050   if (!SWIG_IsOK(ecode8)) {
27051     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinders" "', argument " "8"" of type '" "double""'");
27052   }
27053   arg8 = static_cast< double >(val8);
27054   ecode9 = SWIG_AsVal_double(obj8, &val9);
27055   if (!SWIG_IsOK(ecode9)) {
27056     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinders" "', argument " "9"" of type '" "double""'");
27057   }
27058   arg9 = static_cast< double >(val9);
27059   result = (Hex::BiCylinder *)(arg1)->makeCylinders(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
27060   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
27061   return resultobj;
27062 fail:
27063   return NULL;
27064 }
27065
27066
27067 SWIGINTERN PyObject *_wrap_Document_makePipes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27068   PyObject *resultobj = 0;
27069   Hex::Document *arg1 = (Hex::Document *) 0 ;
27070   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27071   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27072   double arg4 ;
27073   double arg5 ;
27074   double arg6 ;
27075   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27076   Hex::Vector *arg8 = (Hex::Vector *) 0 ;
27077   double arg9 ;
27078   double arg10 ;
27079   double arg11 ;
27080   Hex::BiCylinder *result = 0 ;
27081   void *argp1 = 0 ;
27082   int res1 = 0 ;
27083   void *argp2 = 0 ;
27084   int res2 = 0 ;
27085   void *argp3 = 0 ;
27086   int res3 = 0 ;
27087   double val4 ;
27088   int ecode4 = 0 ;
27089   double val5 ;
27090   int ecode5 = 0 ;
27091   double val6 ;
27092   int ecode6 = 0 ;
27093   void *argp7 = 0 ;
27094   int res7 = 0 ;
27095   void *argp8 = 0 ;
27096   int res8 = 0 ;
27097   double val9 ;
27098   int ecode9 = 0 ;
27099   double val10 ;
27100   int ecode10 = 0 ;
27101   double val11 ;
27102   int ecode11 = 0 ;
27103   PyObject * obj0 = 0 ;
27104   PyObject * obj1 = 0 ;
27105   PyObject * obj2 = 0 ;
27106   PyObject * obj3 = 0 ;
27107   PyObject * obj4 = 0 ;
27108   PyObject * obj5 = 0 ;
27109   PyObject * obj6 = 0 ;
27110   PyObject * obj7 = 0 ;
27111   PyObject * obj8 = 0 ;
27112   PyObject * obj9 = 0 ;
27113   PyObject * obj10 = 0 ;
27114
27115   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
27116   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27117   if (!SWIG_IsOK(res1)) {
27118     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipes" "', argument " "1"" of type '" "Hex::Document *""'");
27119   }
27120   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27121   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27122   if (!SWIG_IsOK(res2)) {
27123     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipes" "', argument " "2"" of type '" "Hex::Vertex *""'");
27124   }
27125   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27126   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27127   if (!SWIG_IsOK(res3)) {
27128     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipes" "', argument " "3"" of type '" "Hex::Vector *""'");
27129   }
27130   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27131   ecode4 = SWIG_AsVal_double(obj3, &val4);
27132   if (!SWIG_IsOK(ecode4)) {
27133     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipes" "', argument " "4"" of type '" "double""'");
27134   }
27135   arg4 = static_cast< double >(val4);
27136   ecode5 = SWIG_AsVal_double(obj4, &val5);
27137   if (!SWIG_IsOK(ecode5)) {
27138     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipes" "', argument " "5"" of type '" "double""'");
27139   }
27140   arg5 = static_cast< double >(val5);
27141   ecode6 = SWIG_AsVal_double(obj5, &val6);
27142   if (!SWIG_IsOK(ecode6)) {
27143     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipes" "', argument " "6"" of type '" "double""'");
27144   }
27145   arg6 = static_cast< double >(val6);
27146   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27147   if (!SWIG_IsOK(res7)) {
27148     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makePipes" "', argument " "7"" of type '" "Hex::Vertex *""'");
27149   }
27150   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27151   res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27152   if (!SWIG_IsOK(res8)) {
27153     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makePipes" "', argument " "8"" of type '" "Hex::Vector *""'");
27154   }
27155   arg8 = reinterpret_cast< Hex::Vector * >(argp8);
27156   ecode9 = SWIG_AsVal_double(obj8, &val9);
27157   if (!SWIG_IsOK(ecode9)) {
27158     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipes" "', argument " "9"" of type '" "double""'");
27159   }
27160   arg9 = static_cast< double >(val9);
27161   ecode10 = SWIG_AsVal_double(obj9, &val10);
27162   if (!SWIG_IsOK(ecode10)) {
27163     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipes" "', argument " "10"" of type '" "double""'");
27164   }
27165   arg10 = static_cast< double >(val10);
27166   ecode11 = SWIG_AsVal_double(obj10, &val11);
27167   if (!SWIG_IsOK(ecode11)) {
27168     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipes" "', argument " "11"" of type '" "double""'");
27169   }
27170   arg11 = static_cast< double >(val11);
27171   result = (Hex::BiCylinder *)(arg1)->makePipes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
27172   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
27173   return resultobj;
27174 fail:
27175   return NULL;
27176 }
27177
27178
27179 SWIGINTERN PyObject *_wrap_Document_extrudeQuadTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27180   PyObject *resultobj = 0;
27181   Hex::Document *arg1 = (Hex::Document *) 0 ;
27182   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27183   int arg3 ;
27184   Hex::Elements *result = 0 ;
27185   void *argp1 = 0 ;
27186   int res1 = 0 ;
27187   void *argp2 = 0 ;
27188   int res2 = 0 ;
27189   int val3 ;
27190   int ecode3 = 0 ;
27191   PyObject * obj0 = 0 ;
27192   PyObject * obj1 = 0 ;
27193   PyObject * obj2 = 0 ;
27194
27195   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadTop",&obj0,&obj1,&obj2)) SWIG_fail;
27196   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27197   if (!SWIG_IsOK(res1)) {
27198     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadTop" "', argument " "1"" of type '" "Hex::Document *""'");
27199   }
27200   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27201   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27202   if (!SWIG_IsOK(res2)) {
27203     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadTop" "', argument " "2"" of type '" "Hex::Quad *""'");
27204   }
27205   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27206   ecode3 = SWIG_AsVal_int(obj2, &val3);
27207   if (!SWIG_IsOK(ecode3)) {
27208     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadTop" "', argument " "3"" of type '" "int""'");
27209   }
27210   arg3 = static_cast< int >(val3);
27211   result = (Hex::Elements *)(arg1)->extrudeQuadTop(arg2,arg3);
27212   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27213   return resultobj;
27214 fail:
27215   return NULL;
27216 }
27217
27218
27219 SWIGINTERN PyObject *_wrap_Document_extrudeQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27220   PyObject *resultobj = 0;
27221   Hex::Document *arg1 = (Hex::Document *) 0 ;
27222   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27223   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27224   double arg4 ;
27225   int arg5 ;
27226   Hex::Elements *result = 0 ;
27227   void *argp1 = 0 ;
27228   int res1 = 0 ;
27229   void *argp2 = 0 ;
27230   int res2 = 0 ;
27231   void *argp3 = 0 ;
27232   int res3 = 0 ;
27233   double val4 ;
27234   int ecode4 = 0 ;
27235   int val5 ;
27236   int ecode5 = 0 ;
27237   PyObject * obj0 = 0 ;
27238   PyObject * obj1 = 0 ;
27239   PyObject * obj2 = 0 ;
27240   PyObject * obj3 = 0 ;
27241   PyObject * obj4 = 0 ;
27242
27243   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27244   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27245   if (!SWIG_IsOK(res1)) {
27246     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
27247   }
27248   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27249   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27250   if (!SWIG_IsOK(res2)) {
27251     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
27252   }
27253   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27254   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27255   if (!SWIG_IsOK(res3)) {
27256     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadUni" "', argument " "3"" of type '" "Hex::Vector *""'");
27257   }
27258   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27259   ecode4 = SWIG_AsVal_double(obj3, &val4);
27260   if (!SWIG_IsOK(ecode4)) {
27261     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadUni" "', argument " "4"" of type '" "double""'");
27262   }
27263   arg4 = static_cast< double >(val4);
27264   ecode5 = SWIG_AsVal_int(obj4, &val5);
27265   if (!SWIG_IsOK(ecode5)) {
27266     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadUni" "', argument " "5"" of type '" "int""'");
27267   }
27268   arg5 = static_cast< int >(val5);
27269   result = (Hex::Elements *)(arg1)->extrudeQuadUni(arg2,arg3,arg4,arg5);
27270   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27271   return resultobj;
27272 fail:
27273   return NULL;
27274 }
27275
27276
27277 SWIGINTERN PyObject *_wrap_Document_extrudeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27278   PyObject *resultobj = 0;
27279   Hex::Document *arg1 = (Hex::Document *) 0 ;
27280   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27281   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27282   Hex::RealVector arg4 ;
27283   Hex::Elements *result = 0 ;
27284   void *argp1 = 0 ;
27285   int res1 = 0 ;
27286   void *argp2 = 0 ;
27287   int res2 = 0 ;
27288   void *argp3 = 0 ;
27289   int res3 = 0 ;
27290   PyObject * obj0 = 0 ;
27291   PyObject * obj1 = 0 ;
27292   PyObject * obj2 = 0 ;
27293   PyObject * obj3 = 0 ;
27294
27295   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27296   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27297   if (!SWIG_IsOK(res1)) {
27298     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27299   }
27300   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27301   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27302   if (!SWIG_IsOK(res2)) {
27303     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
27304   }
27305   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27306   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27307   if (!SWIG_IsOK(res3)) {
27308     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuad" "', argument " "3"" of type '" "Hex::Vector *""'");
27309   }
27310   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27311   {
27312     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27313     int res = swig::asptr(obj3, &ptr);
27314     if (!SWIG_IsOK(res) || !ptr) {
27315       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuad" "', argument " "4"" of type '" "Hex::RealVector""'");
27316     }
27317     arg4 = *ptr;
27318     if (SWIG_IsNewObj(res)) delete ptr;
27319   }
27320   result = (Hex::Elements *)(arg1)->extrudeQuad(arg2,arg3,arg4);
27321   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27322   return resultobj;
27323 fail:
27324   return NULL;
27325 }
27326
27327
27328 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27329   PyObject *resultobj = 0;
27330   Hex::Document *arg1 = (Hex::Document *) 0 ;
27331   Hex::Quads arg2 ;
27332   int arg3 ;
27333   Hex::Elements *result = 0 ;
27334   void *argp1 = 0 ;
27335   int res1 = 0 ;
27336   int val3 ;
27337   int ecode3 = 0 ;
27338   PyObject * obj0 = 0 ;
27339   PyObject * obj1 = 0 ;
27340   PyObject * obj2 = 0 ;
27341
27342   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadsTop",&obj0,&obj1,&obj2)) SWIG_fail;
27343   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27344   if (!SWIG_IsOK(res1)) {
27345     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsTop" "', argument " "1"" of type '" "Hex::Document *""'");
27346   }
27347   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27348   {
27349     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27350     int res = swig::asptr(obj1, &ptr);
27351     if (!SWIG_IsOK(res) || !ptr) {
27352       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsTop" "', argument " "2"" of type '" "Hex::Quads""'");
27353     }
27354     arg2 = *ptr;
27355     if (SWIG_IsNewObj(res)) delete ptr;
27356   }
27357   ecode3 = SWIG_AsVal_int(obj2, &val3);
27358   if (!SWIG_IsOK(ecode3)) {
27359     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadsTop" "', argument " "3"" of type '" "int""'");
27360   }
27361   arg3 = static_cast< int >(val3);
27362   result = (Hex::Elements *)(arg1)->extrudeQuadsTop(arg2,arg3);
27363   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27364   return resultobj;
27365 fail:
27366   return NULL;
27367 }
27368
27369
27370 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27371   PyObject *resultobj = 0;
27372   Hex::Document *arg1 = (Hex::Document *) 0 ;
27373   Hex::Quads arg2 ;
27374   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27375   double arg4 ;
27376   int arg5 ;
27377   Hex::Elements *result = 0 ;
27378   void *argp1 = 0 ;
27379   int res1 = 0 ;
27380   void *argp3 = 0 ;
27381   int res3 = 0 ;
27382   double val4 ;
27383   int ecode4 = 0 ;
27384   int val5 ;
27385   int ecode5 = 0 ;
27386   PyObject * obj0 = 0 ;
27387   PyObject * obj1 = 0 ;
27388   PyObject * obj2 = 0 ;
27389   PyObject * obj3 = 0 ;
27390   PyObject * obj4 = 0 ;
27391
27392   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27393   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27394   if (!SWIG_IsOK(res1)) {
27395     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
27396   }
27397   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27398   {
27399     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27400     int res = swig::asptr(obj1, &ptr);
27401     if (!SWIG_IsOK(res) || !ptr) {
27402       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
27403     }
27404     arg2 = *ptr;
27405     if (SWIG_IsNewObj(res)) delete ptr;
27406   }
27407   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27408   if (!SWIG_IsOK(res3)) {
27409     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadsUni" "', argument " "3"" of type '" "Hex::Vector *""'");
27410   }
27411   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27412   ecode4 = SWIG_AsVal_double(obj3, &val4);
27413   if (!SWIG_IsOK(ecode4)) {
27414     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadsUni" "', argument " "4"" of type '" "double""'");
27415   }
27416   arg4 = static_cast< double >(val4);
27417   ecode5 = SWIG_AsVal_int(obj4, &val5);
27418   if (!SWIG_IsOK(ecode5)) {
27419     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadsUni" "', argument " "5"" of type '" "int""'");
27420   }
27421   arg5 = static_cast< int >(val5);
27422   result = (Hex::Elements *)(arg1)->extrudeQuadsUni(arg2,arg3,arg4,arg5);
27423   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27424   return resultobj;
27425 fail:
27426   return NULL;
27427 }
27428
27429
27430 SWIGINTERN PyObject *_wrap_Document_extrudeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27431   PyObject *resultobj = 0;
27432   Hex::Document *arg1 = (Hex::Document *) 0 ;
27433   Hex::Quads arg2 ;
27434   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
27435   Hex::RealVector arg4 ;
27436   Hex::Elements *result = 0 ;
27437   void *argp1 = 0 ;
27438   int res1 = 0 ;
27439   void *argp3 = 0 ;
27440   int res3 = 0 ;
27441   PyObject * obj0 = 0 ;
27442   PyObject * obj1 = 0 ;
27443   PyObject * obj2 = 0 ;
27444   PyObject * obj3 = 0 ;
27445
27446   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27447   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27448   if (!SWIG_IsOK(res1)) {
27449     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
27450   }
27451   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27452   {
27453     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27454     int res = swig::asptr(obj1, &ptr);
27455     if (!SWIG_IsOK(res) || !ptr) {
27456       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "2"" of type '" "Hex::Quads""'");
27457     }
27458     arg2 = *ptr;
27459     if (SWIG_IsNewObj(res)) delete ptr;
27460   }
27461   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27462   if (!SWIG_IsOK(res3)) {
27463     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuads" "', argument " "3"" of type '" "Hex::Vector *""'");
27464   }
27465   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
27466   {
27467     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27468     int res = swig::asptr(obj3, &ptr);
27469     if (!SWIG_IsOK(res) || !ptr) {
27470       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "4"" of type '" "Hex::RealVector""'");
27471     }
27472     arg4 = *ptr;
27473     if (SWIG_IsNewObj(res)) delete ptr;
27474   }
27475   result = (Hex::Elements *)(arg1)->extrudeQuads(arg2,arg3,arg4);
27476   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27477   return resultobj;
27478 fail:
27479   return NULL;
27480 }
27481
27482
27483 SWIGINTERN PyObject *_wrap_Document_revolutionQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27484   PyObject *resultobj = 0;
27485   Hex::Document *arg1 = (Hex::Document *) 0 ;
27486   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27487   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27488   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27489   double arg5 ;
27490   int arg6 ;
27491   Hex::Elements *result = 0 ;
27492   void *argp1 = 0 ;
27493   int res1 = 0 ;
27494   void *argp2 = 0 ;
27495   int res2 = 0 ;
27496   void *argp3 = 0 ;
27497   int res3 = 0 ;
27498   void *argp4 = 0 ;
27499   int res4 = 0 ;
27500   double val5 ;
27501   int ecode5 = 0 ;
27502   int val6 ;
27503   int ecode6 = 0 ;
27504   PyObject * obj0 = 0 ;
27505   PyObject * obj1 = 0 ;
27506   PyObject * obj2 = 0 ;
27507   PyObject * obj3 = 0 ;
27508   PyObject * obj4 = 0 ;
27509   PyObject * obj5 = 0 ;
27510
27511   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27512   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27513   if (!SWIG_IsOK(res1)) {
27514     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
27515   }
27516   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27517   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27518   if (!SWIG_IsOK(res2)) {
27519     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
27520   }
27521   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27522   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27523   if (!SWIG_IsOK(res3)) {
27524     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
27525   }
27526   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27527   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27528   if (!SWIG_IsOK(res4)) {
27529     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadUni" "', argument " "4"" of type '" "Hex::Vector *""'");
27530   }
27531   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27532   ecode5 = SWIG_AsVal_double(obj4, &val5);
27533   if (!SWIG_IsOK(ecode5)) {
27534     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadUni" "', argument " "5"" of type '" "double""'");
27535   }
27536   arg5 = static_cast< double >(val5);
27537   ecode6 = SWIG_AsVal_int(obj5, &val6);
27538   if (!SWIG_IsOK(ecode6)) {
27539     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadUni" "', argument " "6"" of type '" "int""'");
27540   }
27541   arg6 = static_cast< int >(val6);
27542   result = (Hex::Elements *)(arg1)->revolutionQuadUni(arg2,arg3,arg4,arg5,arg6);
27543   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27544   return resultobj;
27545 fail:
27546   return NULL;
27547 }
27548
27549
27550 SWIGINTERN PyObject *_wrap_Document_revolutionQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27551   PyObject *resultobj = 0;
27552   Hex::Document *arg1 = (Hex::Document *) 0 ;
27553   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27554   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27555   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27556   Hex::RealVector arg5 ;
27557   Hex::Elements *result = 0 ;
27558   void *argp1 = 0 ;
27559   int res1 = 0 ;
27560   void *argp2 = 0 ;
27561   int res2 = 0 ;
27562   void *argp3 = 0 ;
27563   int res3 = 0 ;
27564   void *argp4 = 0 ;
27565   int res4 = 0 ;
27566   PyObject * obj0 = 0 ;
27567   PyObject * obj1 = 0 ;
27568   PyObject * obj2 = 0 ;
27569   PyObject * obj3 = 0 ;
27570   PyObject * obj4 = 0 ;
27571
27572   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27573   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27574   if (!SWIG_IsOK(res1)) {
27575     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27576   }
27577   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27578   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27579   if (!SWIG_IsOK(res2)) {
27580     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
27581   }
27582   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27583   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27584   if (!SWIG_IsOK(res3)) {
27585     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
27586   }
27587   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27588   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27589   if (!SWIG_IsOK(res4)) {
27590     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuad" "', argument " "4"" of type '" "Hex::Vector *""'");
27591   }
27592   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27593   {
27594     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27595     int res = swig::asptr(obj4, &ptr);
27596     if (!SWIG_IsOK(res) || !ptr) {
27597       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuad" "', argument " "5"" of type '" "Hex::RealVector""'");
27598     }
27599     arg5 = *ptr;
27600     if (SWIG_IsNewObj(res)) delete ptr;
27601   }
27602   result = (Hex::Elements *)(arg1)->revolutionQuad(arg2,arg3,arg4,arg5);
27603   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27604   return resultobj;
27605 fail:
27606   return NULL;
27607 }
27608
27609
27610 SWIGINTERN PyObject *_wrap_Document_revolutionQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27611   PyObject *resultobj = 0;
27612   Hex::Document *arg1 = (Hex::Document *) 0 ;
27613   Hex::Quads arg2 ;
27614   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27615   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27616   double arg5 ;
27617   int arg6 ;
27618   Hex::Elements *result = 0 ;
27619   void *argp1 = 0 ;
27620   int res1 = 0 ;
27621   void *argp3 = 0 ;
27622   int res3 = 0 ;
27623   void *argp4 = 0 ;
27624   int res4 = 0 ;
27625   double val5 ;
27626   int ecode5 = 0 ;
27627   int val6 ;
27628   int ecode6 = 0 ;
27629   PyObject * obj0 = 0 ;
27630   PyObject * obj1 = 0 ;
27631   PyObject * obj2 = 0 ;
27632   PyObject * obj3 = 0 ;
27633   PyObject * obj4 = 0 ;
27634   PyObject * obj5 = 0 ;
27635
27636   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27637   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27638   if (!SWIG_IsOK(res1)) {
27639     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
27640   }
27641   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27642   {
27643     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27644     int res = swig::asptr(obj1, &ptr);
27645     if (!SWIG_IsOK(res) || !ptr) {
27646       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
27647     }
27648     arg2 = *ptr;
27649     if (SWIG_IsNewObj(res)) delete ptr;
27650   }
27651   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27652   if (!SWIG_IsOK(res3)) {
27653     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadsUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
27654   }
27655   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27656   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27657   if (!SWIG_IsOK(res4)) {
27658     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadsUni" "', argument " "4"" of type '" "Hex::Vector *""'");
27659   }
27660   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27661   ecode5 = SWIG_AsVal_double(obj4, &val5);
27662   if (!SWIG_IsOK(ecode5)) {
27663     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadsUni" "', argument " "5"" of type '" "double""'");
27664   }
27665   arg5 = static_cast< double >(val5);
27666   ecode6 = SWIG_AsVal_int(obj5, &val6);
27667   if (!SWIG_IsOK(ecode6)) {
27668     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadsUni" "', argument " "6"" of type '" "int""'");
27669   }
27670   arg6 = static_cast< int >(val6);
27671   result = (Hex::Elements *)(arg1)->revolutionQuadsUni(arg2,arg3,arg4,arg5,arg6);
27672   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27673   return resultobj;
27674 fail:
27675   return NULL;
27676 }
27677
27678
27679 SWIGINTERN PyObject *_wrap_Document_revolutionQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27680   PyObject *resultobj = 0;
27681   Hex::Document *arg1 = (Hex::Document *) 0 ;
27682   Hex::Quads arg2 ;
27683   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
27684   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
27685   Hex::RealVector arg5 ;
27686   Hex::Elements *result = 0 ;
27687   void *argp1 = 0 ;
27688   int res1 = 0 ;
27689   void *argp3 = 0 ;
27690   int res3 = 0 ;
27691   void *argp4 = 0 ;
27692   int res4 = 0 ;
27693   PyObject * obj0 = 0 ;
27694   PyObject * obj1 = 0 ;
27695   PyObject * obj2 = 0 ;
27696   PyObject * obj3 = 0 ;
27697   PyObject * obj4 = 0 ;
27698
27699   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27700   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27701   if (!SWIG_IsOK(res1)) {
27702     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuads" "', argument " "1"" of type '" "Hex::Document *""'");
27703   }
27704   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27705   {
27706     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27707     int res = swig::asptr(obj1, &ptr);
27708     if (!SWIG_IsOK(res) || !ptr) {
27709       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "2"" of type '" "Hex::Quads""'");
27710     }
27711     arg2 = *ptr;
27712     if (SWIG_IsNewObj(res)) delete ptr;
27713   }
27714   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27715   if (!SWIG_IsOK(res3)) {
27716     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuads" "', argument " "3"" of type '" "Hex::Vertex *""'");
27717   }
27718   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27719   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
27720   if (!SWIG_IsOK(res4)) {
27721     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuads" "', argument " "4"" of type '" "Hex::Vector *""'");
27722   }
27723   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
27724   {
27725     std::vector<double,std::allocator<double > > *ptr = (std::vector<double,std::allocator<double > > *)0;
27726     int res = swig::asptr(obj4, &ptr);
27727     if (!SWIG_IsOK(res) || !ptr) {
27728       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "5"" of type '" "Hex::RealVector""'");
27729     }
27730     arg5 = *ptr;
27731     if (SWIG_IsNewObj(res)) delete ptr;
27732   }
27733   result = (Hex::Elements *)(arg1)->revolutionQuads(arg2,arg3,arg4,arg5);
27734   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27735   return resultobj;
27736 fail:
27737   return NULL;
27738 }
27739
27740
27741 SWIGINTERN PyObject *_wrap_Document_joinQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27742   PyObject *resultobj = 0;
27743   Hex::Document *arg1 = (Hex::Document *) 0 ;
27744   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27745   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
27746   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27747   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27748   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27749   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27750   int arg8 ;
27751   Hex::Elements *result = 0 ;
27752   void *argp1 = 0 ;
27753   int res1 = 0 ;
27754   void *argp2 = 0 ;
27755   int res2 = 0 ;
27756   void *argp3 = 0 ;
27757   int res3 = 0 ;
27758   void *argp4 = 0 ;
27759   int res4 = 0 ;
27760   void *argp5 = 0 ;
27761   int res5 = 0 ;
27762   void *argp6 = 0 ;
27763   int res6 = 0 ;
27764   void *argp7 = 0 ;
27765   int res7 = 0 ;
27766   int val8 ;
27767   int ecode8 = 0 ;
27768   PyObject * obj0 = 0 ;
27769   PyObject * obj1 = 0 ;
27770   PyObject * obj2 = 0 ;
27771   PyObject * obj3 = 0 ;
27772   PyObject * obj4 = 0 ;
27773   PyObject * obj5 = 0 ;
27774   PyObject * obj6 = 0 ;
27775   PyObject * obj7 = 0 ;
27776
27777   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
27778   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27779   if (!SWIG_IsOK(res1)) {
27780     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
27781   }
27782   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27783   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27784   if (!SWIG_IsOK(res2)) {
27785     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
27786   }
27787   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27788   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27789   if (!SWIG_IsOK(res3)) {
27790     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadUni" "', argument " "3"" of type '" "Hex::Quad *""'");
27791   }
27792   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
27793   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27794   if (!SWIG_IsOK(res4)) {
27795     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
27796   }
27797   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27798   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27799   if (!SWIG_IsOK(res5)) {
27800     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
27801   }
27802   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27803   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27804   if (!SWIG_IsOK(res6)) {
27805     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
27806   }
27807   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27808   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27809   if (!SWIG_IsOK(res7)) {
27810     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
27811   }
27812   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27813   ecode8 = SWIG_AsVal_int(obj7, &val8);
27814   if (!SWIG_IsOK(ecode8)) {
27815     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadUni" "', argument " "8"" of type '" "int""'");
27816   }
27817   arg8 = static_cast< int >(val8);
27818   result = (Hex::Elements *)(arg1)->joinQuadUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
27819   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27820   return resultobj;
27821 fail:
27822   return NULL;
27823 }
27824
27825
27826 SWIGINTERN PyObject *_wrap_Document_joinQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27827   PyObject *resultobj = 0;
27828   Hex::Document *arg1 = (Hex::Document *) 0 ;
27829   Hex::Quads arg2 ;
27830   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
27831   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27832   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27833   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27834   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27835   int arg8 ;
27836   Hex::Elements *result = 0 ;
27837   void *argp1 = 0 ;
27838   int res1 = 0 ;
27839   void *argp3 = 0 ;
27840   int res3 = 0 ;
27841   void *argp4 = 0 ;
27842   int res4 = 0 ;
27843   void *argp5 = 0 ;
27844   int res5 = 0 ;
27845   void *argp6 = 0 ;
27846   int res6 = 0 ;
27847   void *argp7 = 0 ;
27848   int res7 = 0 ;
27849   int val8 ;
27850   int ecode8 = 0 ;
27851   PyObject * obj0 = 0 ;
27852   PyObject * obj1 = 0 ;
27853   PyObject * obj2 = 0 ;
27854   PyObject * obj3 = 0 ;
27855   PyObject * obj4 = 0 ;
27856   PyObject * obj5 = 0 ;
27857   PyObject * obj6 = 0 ;
27858   PyObject * obj7 = 0 ;
27859
27860   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
27861   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27862   if (!SWIG_IsOK(res1)) {
27863     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
27864   }
27865   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27866   {
27867     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
27868     int res = swig::asptr(obj1, &ptr);
27869     if (!SWIG_IsOK(res) || !ptr) {
27870       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
27871     }
27872     arg2 = *ptr;
27873     if (SWIG_IsNewObj(res)) delete ptr;
27874   }
27875   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27876   if (!SWIG_IsOK(res3)) {
27877     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadsUni" "', argument " "3"" of type '" "Hex::Quad *""'");
27878   }
27879   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
27880   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27881   if (!SWIG_IsOK(res4)) {
27882     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadsUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
27883   }
27884   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27885   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27886   if (!SWIG_IsOK(res5)) {
27887     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadsUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
27888   }
27889   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27890   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27891   if (!SWIG_IsOK(res6)) {
27892     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadsUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
27893   }
27894   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27895   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27896   if (!SWIG_IsOK(res7)) {
27897     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadsUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
27898   }
27899   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27900   ecode8 = SWIG_AsVal_int(obj7, &val8);
27901   if (!SWIG_IsOK(ecode8)) {
27902     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadsUni" "', argument " "8"" of type '" "int""'");
27903   }
27904   arg8 = static_cast< int >(val8);
27905   result = (Hex::Elements *)(arg1)->joinQuadsUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
27906   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27907   return resultobj;
27908 fail:
27909   return NULL;
27910 }
27911
27912
27913 SWIGINTERN PyObject *_wrap_Document_joinQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27914   PyObject *resultobj = 0;
27915   Hex::Document *arg1 = (Hex::Document *) 0 ;
27916   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27917   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
27918   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27919   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27920   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27921   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27922   Hex::RealVector *arg8 = 0 ;
27923   Hex::Elements *result = 0 ;
27924   void *argp1 = 0 ;
27925   int res1 = 0 ;
27926   void *argp2 = 0 ;
27927   int res2 = 0 ;
27928   void *argp3 = 0 ;
27929   int res3 = 0 ;
27930   void *argp4 = 0 ;
27931   int res4 = 0 ;
27932   void *argp5 = 0 ;
27933   int res5 = 0 ;
27934   void *argp6 = 0 ;
27935   int res6 = 0 ;
27936   void *argp7 = 0 ;
27937   int res7 = 0 ;
27938   void *argp8 = 0 ;
27939   int res8 = 0 ;
27940   PyObject * obj0 = 0 ;
27941   PyObject * obj1 = 0 ;
27942   PyObject * obj2 = 0 ;
27943   PyObject * obj3 = 0 ;
27944   PyObject * obj4 = 0 ;
27945   PyObject * obj5 = 0 ;
27946   PyObject * obj6 = 0 ;
27947   PyObject * obj7 = 0 ;
27948
27949   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuad",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
27950   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27951   if (!SWIG_IsOK(res1)) {
27952     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27953   }
27954   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27955   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27956   if (!SWIG_IsOK(res2)) {
27957     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
27958   }
27959   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27960   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27961   if (!SWIG_IsOK(res3)) {
27962     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuad" "', argument " "3"" of type '" "Hex::Quad *""'");
27963   }
27964   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
27965   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27966   if (!SWIG_IsOK(res4)) {
27967     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuad" "', argument " "4"" of type '" "Hex::Vertex *""'");
27968   }
27969   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27970   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27971   if (!SWIG_IsOK(res5)) {
27972     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuad" "', argument " "5"" of type '" "Hex::Vertex *""'");
27973   }
27974   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27975   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27976   if (!SWIG_IsOK(res6)) {
27977     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuad" "', argument " "6"" of type '" "Hex::Vertex *""'");
27978   }
27979   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27980   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27981   if (!SWIG_IsOK(res7)) {
27982     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuad" "', argument " "7"" of type '" "Hex::Vertex *""'");
27983   }
27984   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27985   res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t,  0 );
27986   if (!SWIG_IsOK(res8)) {
27987     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
27988   }
27989   if (!argp8) {
27990     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
27991   }
27992   arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
27993   result = (Hex::Elements *)(arg1)->joinQuad(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
27994   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
27995   return resultobj;
27996 fail:
27997   return NULL;
27998 }
27999
28000
28001 SWIGINTERN PyObject *_wrap_Document_joinQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28002   PyObject *resultobj = 0;
28003   Hex::Document *arg1 = (Hex::Document *) 0 ;
28004   Hex::Quads arg2 ;
28005   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
28006   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
28007   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
28008   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
28009   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
28010   Hex::RealVector *arg8 = 0 ;
28011   Hex::Elements *result = 0 ;
28012   void *argp1 = 0 ;
28013   int res1 = 0 ;
28014   void *argp3 = 0 ;
28015   int res3 = 0 ;
28016   void *argp4 = 0 ;
28017   int res4 = 0 ;
28018   void *argp5 = 0 ;
28019   int res5 = 0 ;
28020   void *argp6 = 0 ;
28021   int res6 = 0 ;
28022   void *argp7 = 0 ;
28023   int res7 = 0 ;
28024   void *argp8 = 0 ;
28025   int res8 = 0 ;
28026   PyObject * obj0 = 0 ;
28027   PyObject * obj1 = 0 ;
28028   PyObject * obj2 = 0 ;
28029   PyObject * obj3 = 0 ;
28030   PyObject * obj4 = 0 ;
28031   PyObject * obj5 = 0 ;
28032   PyObject * obj6 = 0 ;
28033   PyObject * obj7 = 0 ;
28034
28035   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
28036   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28037   if (!SWIG_IsOK(res1)) {
28038     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuads" "', argument " "1"" of type '" "Hex::Document *""'");
28039   }
28040   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28041   {
28042     std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
28043     int res = swig::asptr(obj1, &ptr);
28044     if (!SWIG_IsOK(res) || !ptr) {
28045       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuads" "', argument " "2"" of type '" "Hex::Quads""'");
28046     }
28047     arg2 = *ptr;
28048     if (SWIG_IsNewObj(res)) delete ptr;
28049   }
28050   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28051   if (!SWIG_IsOK(res3)) {
28052     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
28053   }
28054   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
28055   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28056   if (!SWIG_IsOK(res4)) {
28057     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuads" "', argument " "4"" of type '" "Hex::Vertex *""'");
28058   }
28059   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
28060   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28061   if (!SWIG_IsOK(res5)) {
28062     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuads" "', argument " "5"" of type '" "Hex::Vertex *""'");
28063   }
28064   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
28065   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28066   if (!SWIG_IsOK(res6)) {
28067     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuads" "', argument " "6"" of type '" "Hex::Vertex *""'");
28068   }
28069   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
28070   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28071   if (!SWIG_IsOK(res7)) {
28072     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
28073   }
28074   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
28075   res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t,  0 );
28076   if (!SWIG_IsOK(res8)) {
28077     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
28078   }
28079   if (!argp8) {
28080     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
28081   }
28082   arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
28083   result = (Hex::Elements *)(arg1)->joinQuads(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
28084   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28085   return resultobj;
28086 fail:
28087   return NULL;
28088 }
28089
28090
28091 SWIGINTERN PyObject *_wrap_Document_cutUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28092   PyObject *resultobj = 0;
28093   Hex::Document *arg1 = (Hex::Document *) 0 ;
28094   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28095   int arg3 ;
28096   Hex::Elements *result = 0 ;
28097   void *argp1 = 0 ;
28098   int res1 = 0 ;
28099   void *argp2 = 0 ;
28100   int res2 = 0 ;
28101   int val3 ;
28102   int ecode3 = 0 ;
28103   PyObject * obj0 = 0 ;
28104   PyObject * obj1 = 0 ;
28105   PyObject * obj2 = 0 ;
28106
28107   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cutUni",&obj0,&obj1,&obj2)) SWIG_fail;
28108   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28109   if (!SWIG_IsOK(res1)) {
28110     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cutUni" "', argument " "1"" of type '" "Hex::Document *""'");
28111   }
28112   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28113   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
28114   if (!SWIG_IsOK(res2)) {
28115     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cutUni" "', argument " "2"" of type '" "Hex::Edge *""'");
28116   }
28117   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28118   ecode3 = SWIG_AsVal_int(obj2, &val3);
28119   if (!SWIG_IsOK(ecode3)) {
28120     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_cutUni" "', argument " "3"" of type '" "int""'");
28121   }
28122   arg3 = static_cast< int >(val3);
28123   result = (Hex::Elements *)(arg1)->cutUni(arg2,arg3);
28124   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28125   return resultobj;
28126 fail:
28127   return NULL;
28128 }
28129
28130
28131 SWIGINTERN PyObject *_wrap_Document_cut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28132   PyObject *resultobj = 0;
28133   Hex::Document *arg1 = (Hex::Document *) 0 ;
28134   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28135   Hex::RealVector *arg3 = 0 ;
28136   Hex::Elements *result = 0 ;
28137   void *argp1 = 0 ;
28138   int res1 = 0 ;
28139   void *argp2 = 0 ;
28140   int res2 = 0 ;
28141   void *argp3 = 0 ;
28142   int res3 = 0 ;
28143   PyObject * obj0 = 0 ;
28144   PyObject * obj1 = 0 ;
28145   PyObject * obj2 = 0 ;
28146
28147   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cut",&obj0,&obj1,&obj2)) SWIG_fail;
28148   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28149   if (!SWIG_IsOK(res1)) {
28150     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cut" "', argument " "1"" of type '" "Hex::Document *""'");
28151   }
28152   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28153   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
28154   if (!SWIG_IsOK(res2)) {
28155     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cut" "', argument " "2"" of type '" "Hex::Edge *""'");
28156   }
28157   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28158   res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorTdouble_std__allocatorTdouble_t_t,  0 );
28159   if (!SWIG_IsOK(res3)) {
28160     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
28161   }
28162   if (!argp3) {
28163     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
28164   }
28165   arg3 = reinterpret_cast< Hex::RealVector * >(argp3);
28166   result = (Hex::Elements *)(arg1)->cut(arg2,*arg3);
28167   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28168   return resultobj;
28169 fail:
28170   return NULL;
28171 }
28172
28173
28174 SWIGINTERN PyObject *_wrap_Document_addGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28175   PyObject *resultobj = 0;
28176   Hex::Document *arg1 = (Hex::Document *) 0 ;
28177   cpchar arg2 = (cpchar) 0 ;
28178   Hex::EnumGroup arg3 ;
28179   Hex::Group *result = 0 ;
28180   void *argp1 = 0 ;
28181   int res1 = 0 ;
28182   int res2 ;
28183   char *buf2 = 0 ;
28184   int alloc2 = 0 ;
28185   int val3 ;
28186   int ecode3 = 0 ;
28187   PyObject * obj0 = 0 ;
28188   PyObject * obj1 = 0 ;
28189   PyObject * obj2 = 0 ;
28190
28191   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addGroup",&obj0,&obj1,&obj2)) SWIG_fail;
28192   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28193   if (!SWIG_IsOK(res1)) {
28194     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addGroup" "', argument " "1"" of type '" "Hex::Document *""'");
28195   }
28196   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28197   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28198   if (!SWIG_IsOK(res2)) {
28199     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addGroup" "', argument " "2"" of type '" "cpchar""'");
28200   }
28201   arg2 = reinterpret_cast< cpchar >(buf2);
28202   ecode3 = SWIG_AsVal_int(obj2, &val3);
28203   if (!SWIG_IsOK(ecode3)) {
28204     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addGroup" "', argument " "3"" of type '" "Hex::EnumGroup""'");
28205   }
28206   arg3 = static_cast< Hex::EnumGroup >(val3);
28207   result = (Hex::Group *)(arg1)->addGroup(arg2,arg3);
28208   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
28209   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28210   return resultobj;
28211 fail:
28212   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28213   return NULL;
28214 }
28215
28216
28217 SWIGINTERN PyObject *_wrap_Document_isSaved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28218   PyObject *resultobj = 0;
28219   Hex::Document *arg1 = (Hex::Document *) 0 ;
28220   bool result;
28221   void *argp1 = 0 ;
28222   int res1 = 0 ;
28223   PyObject * obj0 = 0 ;
28224
28225   if (!PyArg_ParseTuple(args,(char *)"O:Document_isSaved",&obj0)) SWIG_fail;
28226   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28227   if (!SWIG_IsOK(res1)) {
28228     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_isSaved" "', argument " "1"" of type '" "Hex::Document *""'");
28229   }
28230   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28231   result = (bool)(arg1)->isSaved();
28232   resultobj = SWIG_From_bool(static_cast< bool >(result));
28233   return resultobj;
28234 fail:
28235   return NULL;
28236 }
28237
28238
28239 SWIGINTERN PyObject *_wrap_Document_appendXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28240   PyObject *resultobj = 0;
28241   Hex::Document *arg1 = (Hex::Document *) 0 ;
28242   pfile arg2 = (pfile) 0 ;
28243   int result;
28244   void *argp1 = 0 ;
28245   int res1 = 0 ;
28246   void *argp2 = 0 ;
28247   int res2 = 0 ;
28248   PyObject * obj0 = 0 ;
28249   PyObject * obj1 = 0 ;
28250
28251   if (!PyArg_ParseTuple(args,(char *)"OO:Document_appendXml",&obj0,&obj1)) SWIG_fail;
28252   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28253   if (!SWIG_IsOK(res1)) {
28254     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_appendXml" "', argument " "1"" of type '" "Hex::Document *""'");
28255   }
28256   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28257   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
28258   if (!SWIG_IsOK(res2)) {
28259     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_appendXml" "', argument " "2"" of type '" "pfile""'");
28260   }
28261   arg2 = reinterpret_cast< pfile >(argp2);
28262   result = (int)(arg1)->appendXml(arg2);
28263   resultobj = SWIG_From_int(static_cast< int >(result));
28264   return resultobj;
28265 fail:
28266   return NULL;
28267 }
28268
28269
28270 SWIGINTERN PyObject *_wrap_Document_getXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28271   PyObject *resultobj = 0;
28272   Hex::Document *arg1 = (Hex::Document *) 0 ;
28273   cpchar result;
28274   void *argp1 = 0 ;
28275   int res1 = 0 ;
28276   PyObject * obj0 = 0 ;
28277
28278   if (!PyArg_ParseTuple(args,(char *)"O:Document_getXml",&obj0)) SWIG_fail;
28279   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28280   if (!SWIG_IsOK(res1)) {
28281     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getXml" "', argument " "1"" of type '" "Hex::Document *""'");
28282   }
28283   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28284   result = (cpchar)(arg1)->getXml();
28285   resultobj = SWIG_FromCharPtr((const char *)result);
28286   return resultobj;
28287 fail:
28288   return NULL;
28289 }
28290
28291
28292 SWIGINTERN PyObject *_wrap_Document_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28293   PyObject *resultobj = 0;
28294   Hex::Document *arg1 = (Hex::Document *) 0 ;
28295   int result;
28296   void *argp1 = 0 ;
28297   int res1 = 0 ;
28298   PyObject * obj0 = 0 ;
28299
28300   if (!PyArg_ParseTuple(args,(char *)"O:Document_getLevel",&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_getLevel" "', argument " "1"" of type '" "Hex::Document *""'");
28304   }
28305   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28306   result = (int)(arg1)->getLevel();
28307   resultobj = SWIG_From_int(static_cast< int >(result));
28308   return resultobj;
28309 fail:
28310   return NULL;
28311 }
28312
28313
28314 SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28315   PyObject *resultobj = 0;
28316   Hex::Document *arg1 = (Hex::Document *) 0 ;
28317   int arg2 ;
28318   Hex::Vertex *result = 0 ;
28319   void *argp1 = 0 ;
28320   int res1 = 0 ;
28321   int val2 ;
28322   int ecode2 = 0 ;
28323   PyObject * obj0 = 0 ;
28324   PyObject * obj1 = 0 ;
28325
28326   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findVertex",&obj0,&obj1)) SWIG_fail;
28327   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28328   if (!SWIG_IsOK(res1)) {
28329     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
28330   }
28331   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28332   ecode2 = SWIG_AsVal_int(obj1, &val2);
28333   if (!SWIG_IsOK(ecode2)) {
28334     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "int""'");
28335   }
28336   arg2 = static_cast< int >(val2);
28337   result = (Hex::Vertex *)(arg1)->findVertex(arg2);
28338   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28339   return resultobj;
28340 fail:
28341   return NULL;
28342 }
28343
28344
28345 SWIGINTERN PyObject *_wrap_Document_findVertex(PyObject *self, PyObject *args) {
28346   int argc;
28347   PyObject *argv[5];
28348   int ii;
28349
28350   if (!PyTuple_Check(args)) SWIG_fail;
28351   argc = PyObject_Length(args);
28352   for (ii = 0; (ii < argc) && (ii < 4); ii++) {
28353     argv[ii] = PyTuple_GET_ITEM(args,ii);
28354   }
28355   if (argc == 2) {
28356     int _v;
28357     void *vptr = 0;
28358     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28359     _v = SWIG_CheckState(res);
28360     if (_v) {
28361       {
28362         int res = SWIG_AsVal_int(argv[1], NULL);
28363         _v = SWIG_CheckState(res);
28364       }
28365       if (_v) {
28366         return _wrap_Document_findVertex__SWIG_1(self, args);
28367       }
28368     }
28369   }
28370   if (argc == 4) {
28371     int _v;
28372     void *vptr = 0;
28373     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28374     _v = SWIG_CheckState(res);
28375     if (_v) {
28376       {
28377         int res = SWIG_AsVal_double(argv[1], NULL);
28378         _v = SWIG_CheckState(res);
28379       }
28380       if (_v) {
28381         {
28382           int res = SWIG_AsVal_double(argv[2], NULL);
28383           _v = SWIG_CheckState(res);
28384         }
28385         if (_v) {
28386           {
28387             int res = SWIG_AsVal_double(argv[3], NULL);
28388             _v = SWIG_CheckState(res);
28389           }
28390           if (_v) {
28391             return _wrap_Document_findVertex__SWIG_0(self, args);
28392           }
28393         }
28394       }
28395     }
28396   }
28397
28398 fail:
28399   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");
28400   return NULL;
28401 }
28402
28403
28404 SWIGINTERN PyObject *_wrap_Document_closeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28405   PyObject *resultobj = 0;
28406   Hex::Document *arg1 = (Hex::Document *) 0 ;
28407   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
28408   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
28409   int result;
28410   void *argp1 = 0 ;
28411   int res1 = 0 ;
28412   void *argp2 = 0 ;
28413   int res2 = 0 ;
28414   void *argp3 = 0 ;
28415   int res3 = 0 ;
28416   PyObject * obj0 = 0 ;
28417   PyObject * obj1 = 0 ;
28418   PyObject * obj2 = 0 ;
28419
28420   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_closeQuads",&obj0,&obj1,&obj2)) SWIG_fail;
28421   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28422   if (!SWIG_IsOK(res1)) {
28423     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_closeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
28424   }
28425   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28426   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28427   if (!SWIG_IsOK(res2)) {
28428     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_closeQuads" "', argument " "2"" of type '" "Hex::Quad *""'");
28429   }
28430   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
28431   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28432   if (!SWIG_IsOK(res3)) {
28433     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_closeQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
28434   }
28435   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
28436   result = (int)(arg1)->closeQuads(arg2,arg3);
28437   resultobj = SWIG_From_int(static_cast< int >(result));
28438   return resultobj;
28439 fail:
28440   return NULL;
28441 }
28442
28443
28444 SWIGINTERN PyObject *_wrap_Document_addLaw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28445   PyObject *resultobj = 0;
28446   Hex::Document *arg1 = (Hex::Document *) 0 ;
28447   Hex::Law *arg2 = (Hex::Law *) 0 ;
28448   Hex::Law *result = 0 ;
28449   void *argp1 = 0 ;
28450   int res1 = 0 ;
28451   void *argp2 = 0 ;
28452   int res2 = 0 ;
28453   PyObject * obj0 = 0 ;
28454   PyObject * obj1 = 0 ;
28455
28456   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaw",&obj0,&obj1)) SWIG_fail;
28457   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28458   if (!SWIG_IsOK(res1)) {
28459     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaw" "', argument " "1"" of type '" "Hex::Document *""'");
28460   }
28461   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28462   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
28463   if (!SWIG_IsOK(res2)) {
28464     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addLaw" "', argument " "2"" of type '" "Hex::Law *""'");
28465   }
28466   arg2 = reinterpret_cast< Hex::Law * >(argp2);
28467   result = (Hex::Law *)(arg1)->addLaw(arg2);
28468   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
28469   return resultobj;
28470 fail:
28471   return NULL;
28472 }
28473
28474
28475 SWIGINTERN PyObject *_wrap_Document_addLaw(PyObject *self, PyObject *args) {
28476   int argc;
28477   PyObject *argv[4];
28478   int ii;
28479
28480   if (!PyTuple_Check(args)) SWIG_fail;
28481   argc = PyObject_Length(args);
28482   for (ii = 0; (ii < argc) && (ii < 3); ii++) {
28483     argv[ii] = PyTuple_GET_ITEM(args,ii);
28484   }
28485   if (argc == 2) {
28486     int _v;
28487     void *vptr = 0;
28488     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28489     _v = SWIG_CheckState(res);
28490     if (_v) {
28491       void *vptr = 0;
28492       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Law, 0);
28493       _v = SWIG_CheckState(res);
28494       if (_v) {
28495         return _wrap_Document_addLaw__SWIG_1(self, args);
28496       }
28497     }
28498   }
28499   if (argc == 3) {
28500     int _v;
28501     void *vptr = 0;
28502     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28503     _v = SWIG_CheckState(res);
28504     if (_v) {
28505       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
28506       _v = SWIG_CheckState(res);
28507       if (_v) {
28508         {
28509           int res = SWIG_AsVal_int(argv[2], NULL);
28510           _v = SWIG_CheckState(res);
28511         }
28512         if (_v) {
28513           return _wrap_Document_addLaw__SWIG_0(self, args);
28514         }
28515       }
28516     }
28517   }
28518
28519 fail:
28520   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");
28521   return NULL;
28522 }
28523
28524
28525 SWIGINTERN PyObject *_wrap_Document_checkAssociations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28526   PyObject *resultobj = 0;
28527   Hex::Document *arg1 = (Hex::Document *) 0 ;
28528   int result;
28529   void *argp1 = 0 ;
28530   int res1 = 0 ;
28531   PyObject * obj0 = 0 ;
28532
28533   if (!PyArg_ParseTuple(args,(char *)"O:Document_checkAssociations",&obj0)) SWIG_fail;
28534   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28535   if (!SWIG_IsOK(res1)) {
28536     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_checkAssociations" "', argument " "1"" of type '" "Hex::Document *""'");
28537   }
28538   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28539   result = (int)(arg1)->checkAssociations();
28540   resultobj = SWIG_From_int(static_cast< int >(result));
28541   return resultobj;
28542 fail:
28543   return NULL;
28544 }
28545
28546
28547 SWIGINTERN PyObject *_wrap_Document_addShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28548   PyObject *resultobj = 0;
28549   Hex::Document *arg1 = (Hex::Document *) 0 ;
28550   long arg2 ;
28551   char *arg3 = (char *) 0 ;
28552   Hex::NewShape *result = 0 ;
28553   void *argp1 = 0 ;
28554   int res1 = 0 ;
28555   long val2 ;
28556   int ecode2 = 0 ;
28557   int res3 ;
28558   char *buf3 = 0 ;
28559   int alloc3 = 0 ;
28560   PyObject * obj0 = 0 ;
28561   PyObject * obj1 = 0 ;
28562   PyObject * obj2 = 0 ;
28563
28564   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addShape",&obj0,&obj1,&obj2)) SWIG_fail;
28565   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28566   if (!SWIG_IsOK(res1)) {
28567     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addShape" "', argument " "1"" of type '" "Hex::Document *""'");
28568   }
28569   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28570   ecode2 = SWIG_AsVal_long(obj1, &val2);
28571   if (!SWIG_IsOK(ecode2)) {
28572     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addShape" "', argument " "2"" of type '" "long""'");
28573   }
28574   arg2 = static_cast< long >(val2);
28575   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
28576   if (!SWIG_IsOK(res3)) {
28577     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addShape" "', argument " "3"" of type '" "char const *""'");
28578   }
28579   arg3 = reinterpret_cast< char * >(buf3);
28580   result = (Hex::NewShape *)(arg1)->addShape(arg2,(char const *)arg3);
28581   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 |  0 );
28582   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
28583   return resultobj;
28584 fail:
28585   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
28586   return NULL;
28587 }
28588
28589
28590 SWIGINTERN PyObject *_wrap_delete_Document(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28591   PyObject *resultobj = 0;
28592   Hex::Document *arg1 = (Hex::Document *) 0 ;
28593   void *argp1 = 0 ;
28594   int res1 = 0 ;
28595   PyObject * obj0 = 0 ;
28596
28597   if (!PyArg_ParseTuple(args,(char *)"O:delete_Document",&obj0)) SWIG_fail;
28598   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, SWIG_POINTER_DISOWN |  0 );
28599   if (!SWIG_IsOK(res1)) {
28600     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Document" "', argument " "1"" of type '" "Hex::Document *""'");
28601   }
28602   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28603   delete arg1;
28604
28605   resultobj = SWIG_Py_Void();
28606   return resultobj;
28607 fail:
28608   return NULL;
28609 }
28610
28611
28612 SWIGINTERN PyObject *Document_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28613   PyObject *obj;
28614   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
28615   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Document, SWIG_NewClientData(obj));
28616   return SWIG_Py_Void();
28617 }
28618
28619 SWIGINTERN PyObject *_wrap_Propagation_getEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28620   PyObject *resultobj = 0;
28621   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28622   Hex::Edges *result = 0 ;
28623   void *argp1 = 0 ;
28624   int res1 = 0 ;
28625   PyObject * obj0 = 0 ;
28626
28627   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getEdges",&obj0)) SWIG_fail;
28628   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28629   if (!SWIG_IsOK(res1)) {
28630     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getEdges" "', argument " "1"" of type '" "Hex::Propagation *""'");
28631   }
28632   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28633   {
28634     Hex::Edges const &_result_ref = (arg1)->getEdges();
28635     result = (Hex::Edges *) &_result_ref;
28636   }
28637   resultobj = swig::from(static_cast< std::vector<Hex::Edge*,std::allocator<Hex::Edge * > > >(*result));
28638   return resultobj;
28639 fail:
28640   return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_Propagation_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645   PyObject *resultobj = 0;
28646   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28647   Hex::Law *result = 0 ;
28648   void *argp1 = 0 ;
28649   int res1 = 0 ;
28650   PyObject * obj0 = 0 ;
28651
28652   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getLaw",&obj0)) SWIG_fail;
28653   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28654   if (!SWIG_IsOK(res1)) {
28655     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
28656   }
28657   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28658   result = (Hex::Law *)(arg1)->getLaw();
28659   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
28660   return resultobj;
28661 fail:
28662   return NULL;
28663 }
28664
28665
28666 SWIGINTERN PyObject *_wrap_Propagation_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28667   PyObject *resultobj = 0;
28668   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28669   bool result;
28670   void *argp1 = 0 ;
28671   int res1 = 0 ;
28672   PyObject * obj0 = 0 ;
28673
28674   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getWay",&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_getWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
28678   }
28679   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28680   result = (bool)(arg1)->getWay();
28681   resultobj = SWIG_From_bool(static_cast< bool >(result));
28682   return resultobj;
28683 fail:
28684   return NULL;
28685 }
28686
28687
28688 SWIGINTERN PyObject *_wrap_Propagation_setWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28689   PyObject *resultobj = 0;
28690   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28691   bool arg2 ;
28692   void *argp1 = 0 ;
28693   int res1 = 0 ;
28694   bool val2 ;
28695   int ecode2 = 0 ;
28696   PyObject * obj0 = 0 ;
28697   PyObject * obj1 = 0 ;
28698
28699   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setWay",&obj0,&obj1)) SWIG_fail;
28700   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28701   if (!SWIG_IsOK(res1)) {
28702     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
28703   }
28704   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28705   ecode2 = SWIG_AsVal_bool(obj1, &val2);
28706   if (!SWIG_IsOK(ecode2)) {
28707     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Propagation_setWay" "', argument " "2"" of type '" "bool""'");
28708   }
28709   arg2 = static_cast< bool >(val2);
28710   (arg1)->setWay(arg2);
28711   resultobj = SWIG_Py_Void();
28712   return resultobj;
28713 fail:
28714   return NULL;
28715 }
28716
28717
28718 SWIGINTERN PyObject *_wrap_Propagation_setLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28719   PyObject *resultobj = 0;
28720   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28721   Hex::Law *arg2 = (Hex::Law *) 0 ;
28722   int result;
28723   void *argp1 = 0 ;
28724   int res1 = 0 ;
28725   void *argp2 = 0 ;
28726   int res2 = 0 ;
28727   PyObject * obj0 = 0 ;
28728   PyObject * obj1 = 0 ;
28729
28730   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setLaw",&obj0,&obj1)) SWIG_fail;
28731   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28732   if (!SWIG_IsOK(res1)) {
28733     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
28734   }
28735   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28736   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
28737   if (!SWIG_IsOK(res2)) {
28738     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_setLaw" "', argument " "2"" of type '" "Hex::Law *""'");
28739   }
28740   arg2 = reinterpret_cast< Hex::Law * >(argp2);
28741   result = (int)(arg1)->setLaw(arg2);
28742   resultobj = SWIG_From_int(static_cast< int >(result));
28743   return resultobj;
28744 fail:
28745   return NULL;
28746 }
28747
28748
28749 SWIGINTERN PyObject *_wrap_new_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28750   PyObject *resultobj = 0;
28751   Hex::Document *arg1 = (Hex::Document *) 0 ;
28752   Hex::Propagation *result = 0 ;
28753   void *argp1 = 0 ;
28754   int res1 = 0 ;
28755   PyObject * obj0 = 0 ;
28756
28757   if (!PyArg_ParseTuple(args,(char *)"O:new_Propagation",&obj0)) SWIG_fail;
28758   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28759   if (!SWIG_IsOK(res1)) {
28760     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Propagation" "', argument " "1"" of type '" "Hex::Document *""'");
28761   }
28762   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28763   result = (Hex::Propagation *)new Hex::Propagation(arg1);
28764   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_NEW |  0 );
28765   return resultobj;
28766 fail:
28767   return NULL;
28768 }
28769
28770
28771 SWIGINTERN PyObject *_wrap_Propagation_saveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28772   PyObject *resultobj = 0;
28773   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28774   Hex::XmlWriter *arg2 = (Hex::XmlWriter *) 0 ;
28775   void *argp1 = 0 ;
28776   int res1 = 0 ;
28777   void *argp2 = 0 ;
28778   int res2 = 0 ;
28779   PyObject * obj0 = 0 ;
28780   PyObject * obj1 = 0 ;
28781
28782   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_saveXml",&obj0,&obj1)) SWIG_fail;
28783   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28784   if (!SWIG_IsOK(res1)) {
28785     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_saveXml" "', argument " "1"" of type '" "Hex::Propagation *""'");
28786   }
28787   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28788   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__XmlWriter, 0 |  0 );
28789   if (!SWIG_IsOK(res2)) {
28790     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_saveXml" "', argument " "2"" of type '" "Hex::XmlWriter *""'");
28791   }
28792   arg2 = reinterpret_cast< Hex::XmlWriter * >(argp2);
28793   (arg1)->saveXml(arg2);
28794   resultobj = SWIG_Py_Void();
28795   return resultobj;
28796 fail:
28797   return NULL;
28798 }
28799
28800
28801 SWIGINTERN PyObject *_wrap_Propagation_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28802   PyObject *resultobj = 0;
28803   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28804   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28805   void *argp1 = 0 ;
28806   int res1 = 0 ;
28807   void *argp2 = 0 ;
28808   int res2 = 0 ;
28809   PyObject * obj0 = 0 ;
28810   PyObject * obj1 = 0 ;
28811
28812   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_addEdge",&obj0,&obj1)) SWIG_fail;
28813   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28814   if (!SWIG_IsOK(res1)) {
28815     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_addEdge" "', argument " "1"" of type '" "Hex::Propagation *""'");
28816   }
28817   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28818   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
28819   if (!SWIG_IsOK(res2)) {
28820     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_addEdge" "', argument " "2"" of type '" "Hex::Edge *""'");
28821   }
28822   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28823   (arg1)->addEdge(arg2);
28824   resultobj = SWIG_Py_Void();
28825   return resultobj;
28826 fail:
28827   return NULL;
28828 }
28829
28830
28831 SWIGINTERN PyObject *_wrap_Propagation_majLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28832   PyObject *resultobj = 0;
28833   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28834   void *argp1 = 0 ;
28835   int res1 = 0 ;
28836   PyObject * obj0 = 0 ;
28837
28838   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_majLaw",&obj0)) SWIG_fail;
28839   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28840   if (!SWIG_IsOK(res1)) {
28841     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_majLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
28842   }
28843   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28844   (arg1)->majLaw();
28845   resultobj = SWIG_Py_Void();
28846   return resultobj;
28847 fail:
28848   return NULL;
28849 }
28850
28851
28852 SWIGINTERN PyObject *_wrap_delete_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28853   PyObject *resultobj = 0;
28854   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
28855   void *argp1 = 0 ;
28856   int res1 = 0 ;
28857   PyObject * obj0 = 0 ;
28858
28859   if (!PyArg_ParseTuple(args,(char *)"O:delete_Propagation",&obj0)) SWIG_fail;
28860   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_DISOWN |  0 );
28861   if (!SWIG_IsOK(res1)) {
28862     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Propagation" "', argument " "1"" of type '" "Hex::Propagation *""'");
28863   }
28864   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
28865   delete arg1;
28866
28867   resultobj = SWIG_Py_Void();
28868   return resultobj;
28869 fail:
28870   return NULL;
28871 }
28872
28873
28874 SWIGINTERN PyObject *Propagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28875   PyObject *obj;
28876   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
28877   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Propagation, SWIG_NewClientData(obj));
28878   return SWIG_Py_Void();
28879 }
28880
28881 SWIGINTERN PyObject *_wrap_hex_instance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28882   PyObject *resultobj = 0;
28883   Hex::Hex *result = 0 ;
28884
28885   if (!PyArg_ParseTuple(args,(char *)":hex_instance")) SWIG_fail;
28886   result = (Hex::Hex *)Hex::hex_instance();
28887   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 |  0 );
28888   return resultobj;
28889 fail:
28890   return NULL;
28891 }
28892
28893
28894 SWIGINTERN PyObject *_wrap_Hex_getInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28895   PyObject *resultobj = 0;
28896   Hex::Hex *result = 0 ;
28897
28898   if (!PyArg_ParseTuple(args,(char *)":Hex_getInstance")) SWIG_fail;
28899   result = (Hex::Hex *)Hex::Hex::getInstance();
28900   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 |  0 );
28901   return resultobj;
28902 fail:
28903   return NULL;
28904 }
28905
28906
28907 SWIGINTERN PyObject *_wrap_Hex_countDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28908   PyObject *resultobj = 0;
28909   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
28910   int result;
28911   void *argp1 = 0 ;
28912   int res1 = 0 ;
28913   PyObject * obj0 = 0 ;
28914
28915   if (!PyArg_ParseTuple(args,(char *)"O:Hex_countDocument",&obj0)) SWIG_fail;
28916   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
28917   if (!SWIG_IsOK(res1)) {
28918     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_countDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
28919   }
28920   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
28921   result = (int)(arg1)->countDocument();
28922   resultobj = SWIG_From_int(static_cast< int >(result));
28923   return resultobj;
28924 fail:
28925   return NULL;
28926 }
28927
28928
28929 SWIGINTERN PyObject *_wrap_Hex_getDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28930   PyObject *resultobj = 0;
28931   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
28932   int arg2 ;
28933   Hex::Document *result = 0 ;
28934   void *argp1 = 0 ;
28935   int res1 = 0 ;
28936   int val2 ;
28937   int ecode2 = 0 ;
28938   PyObject * obj0 = 0 ;
28939   PyObject * obj1 = 0 ;
28940
28941   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getDocument",&obj0,&obj1)) SWIG_fail;
28942   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
28943   if (!SWIG_IsOK(res1)) {
28944     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
28945   }
28946   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
28947   ecode2 = SWIG_AsVal_int(obj1, &val2);
28948   if (!SWIG_IsOK(ecode2)) {
28949     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getDocument" "', argument " "2"" of type '" "int""'");
28950   }
28951   arg2 = static_cast< int >(val2);
28952   result = (Hex::Document *)(arg1)->getDocument(arg2);
28953   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
28954   return resultobj;
28955 fail:
28956   return NULL;
28957 }
28958
28959
28960 SWIGINTERN PyObject *_wrap_Hex_removeDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28961   PyObject *resultobj = 0;
28962   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
28963   Hex::Document *arg2 = (Hex::Document *) 0 ;
28964   void *argp1 = 0 ;
28965   int res1 = 0 ;
28966   void *argp2 = 0 ;
28967   int res2 = 0 ;
28968   PyObject * obj0 = 0 ;
28969   PyObject * obj1 = 0 ;
28970
28971   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_removeDocument",&obj0,&obj1)) SWIG_fail;
28972   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
28973   if (!SWIG_IsOK(res1)) {
28974     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_removeDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
28975   }
28976   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
28977   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Document, 0 |  0 );
28978   if (!SWIG_IsOK(res2)) {
28979     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_removeDocument" "', argument " "2"" of type '" "Hex::Document *""'");
28980   }
28981   arg2 = reinterpret_cast< Hex::Document * >(argp2);
28982   (arg1)->removeDocument(arg2);
28983   resultobj = SWIG_Py_Void();
28984   return resultobj;
28985 fail:
28986   return NULL;
28987 }
28988
28989
28990 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28991   PyObject *resultobj = 0;
28992   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
28993   cpchar arg2 = (cpchar) 0 ;
28994   Hex::Document *result = 0 ;
28995   void *argp1 = 0 ;
28996   int res1 = 0 ;
28997   int res2 ;
28998   char *buf2 = 0 ;
28999   int alloc2 = 0 ;
29000   PyObject * obj0 = 0 ;
29001   PyObject * obj1 = 0 ;
29002
29003   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_addDocument",&obj0,&obj1)) SWIG_fail;
29004   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29005   if (!SWIG_IsOK(res1)) {
29006     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29007   }
29008   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29009   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29010   if (!SWIG_IsOK(res2)) {
29011     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_addDocument" "', argument " "2"" of type '" "cpchar""'");
29012   }
29013   arg2 = reinterpret_cast< cpchar >(buf2);
29014   result = (Hex::Document *)(arg1)->addDocument(arg2);
29015   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
29016   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29017   return resultobj;
29018 fail:
29019   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29020   return NULL;
29021 }
29022
29023
29024 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29025   PyObject *resultobj = 0;
29026   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29027   Hex::Document *result = 0 ;
29028   void *argp1 = 0 ;
29029   int res1 = 0 ;
29030   PyObject * obj0 = 0 ;
29031
29032   if (!PyArg_ParseTuple(args,(char *)"O:Hex_addDocument",&obj0)) SWIG_fail;
29033   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29034   if (!SWIG_IsOK(res1)) {
29035     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29036   }
29037   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29038   result = (Hex::Document *)(arg1)->addDocument();
29039   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
29040   return resultobj;
29041 fail:
29042   return NULL;
29043 }
29044
29045
29046 SWIGINTERN PyObject *_wrap_Hex_addDocument(PyObject *self, PyObject *args) {
29047   int argc;
29048   PyObject *argv[3];
29049   int ii;
29050
29051   if (!PyTuple_Check(args)) SWIG_fail;
29052   argc = PyObject_Length(args);
29053   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29054     argv[ii] = PyTuple_GET_ITEM(args,ii);
29055   }
29056   if (argc == 1) {
29057     int _v;
29058     void *vptr = 0;
29059     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29060     _v = SWIG_CheckState(res);
29061     if (_v) {
29062       return _wrap_Hex_addDocument__SWIG_1(self, args);
29063     }
29064   }
29065   if (argc == 2) {
29066     int _v;
29067     void *vptr = 0;
29068     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29069     _v = SWIG_CheckState(res);
29070     if (_v) {
29071       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
29072       _v = SWIG_CheckState(res);
29073       if (_v) {
29074         return _wrap_Hex_addDocument__SWIG_0(self, args);
29075       }
29076     }
29077   }
29078
29079 fail:
29080   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");
29081   return NULL;
29082 }
29083
29084
29085 SWIGINTERN PyObject *_wrap_Hex_loadDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29086   PyObject *resultobj = 0;
29087   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29088   cpchar arg2 = (cpchar) 0 ;
29089   Hex::Document *result = 0 ;
29090   void *argp1 = 0 ;
29091   int res1 = 0 ;
29092   int res2 ;
29093   char *buf2 = 0 ;
29094   int alloc2 = 0 ;
29095   PyObject * obj0 = 0 ;
29096   PyObject * obj1 = 0 ;
29097
29098   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_loadDocument",&obj0,&obj1)) SWIG_fail;
29099   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29100   if (!SWIG_IsOK(res1)) {
29101     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_loadDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29102   }
29103   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29104   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29105   if (!SWIG_IsOK(res2)) {
29106     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_loadDocument" "', argument " "2"" of type '" "cpchar""'");
29107   }
29108   arg2 = reinterpret_cast< cpchar >(buf2);
29109   result = (Hex::Document *)(arg1)->loadDocument(arg2);
29110   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
29111   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29112   return resultobj;
29113 fail:
29114   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29115   return NULL;
29116 }
29117
29118
29119 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29120   PyObject *resultobj = 0;
29121   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29122   cpchar arg2 = (cpchar) 0 ;
29123   Hex::Document *result = 0 ;
29124   void *argp1 = 0 ;
29125   int res1 = 0 ;
29126   int res2 ;
29127   char *buf2 = 0 ;
29128   int alloc2 = 0 ;
29129   PyObject * obj0 = 0 ;
29130   PyObject * obj1 = 0 ;
29131
29132   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
29133   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29134   if (!SWIG_IsOK(res1)) {
29135     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29136   }
29137   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29138   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29139   if (!SWIG_IsOK(res2)) {
29140     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "cpchar""'");
29141   }
29142   arg2 = reinterpret_cast< cpchar >(buf2);
29143   result = (Hex::Document *)(arg1)->findDocument(arg2);
29144   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
29145   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29146   return resultobj;
29147 fail:
29148   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
29149   return NULL;
29150 }
29151
29152
29153 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29154   PyObject *resultobj = 0;
29155   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29156   string *arg2 = 0 ;
29157   Hex::Document *result = 0 ;
29158   void *argp1 = 0 ;
29159   int res1 = 0 ;
29160   void *argp2 = 0 ;
29161   int res2 = 0 ;
29162   PyObject * obj0 = 0 ;
29163   PyObject * obj1 = 0 ;
29164
29165   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
29166   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29167   if (!SWIG_IsOK(res1)) {
29168     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
29169   }
29170   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29171   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string,  0  | 0);
29172   if (!SWIG_IsOK(res2)) {
29173     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
29174   }
29175   if (!argp2) {
29176     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
29177   }
29178   arg2 = reinterpret_cast< string * >(argp2);
29179   result = (Hex::Document *)(arg1)->findDocument((string const &)*arg2);
29180   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
29181   return resultobj;
29182 fail:
29183   return NULL;
29184 }
29185
29186
29187 SWIGINTERN PyObject *_wrap_Hex_findDocument(PyObject *self, PyObject *args) {
29188   int argc;
29189   PyObject *argv[3];
29190   int ii;
29191
29192   if (!PyTuple_Check(args)) SWIG_fail;
29193   argc = PyObject_Length(args);
29194   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29195     argv[ii] = PyTuple_GET_ITEM(args,ii);
29196   }
29197   if (argc == 2) {
29198     int _v;
29199     void *vptr = 0;
29200     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29201     _v = SWIG_CheckState(res);
29202     if (_v) {
29203       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_string, 0);
29204       _v = SWIG_CheckState(res);
29205       if (_v) {
29206         return _wrap_Hex_findDocument__SWIG_1(self, args);
29207       }
29208     }
29209   }
29210   if (argc == 2) {
29211     int _v;
29212     void *vptr = 0;
29213     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
29214     _v = SWIG_CheckState(res);
29215     if (_v) {
29216       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
29217       _v = SWIG_CheckState(res);
29218       if (_v) {
29219         return _wrap_Hex_findDocument__SWIG_0(self, args);
29220       }
29221     }
29222   }
29223
29224 fail:
29225   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");
29226   return NULL;
29227 }
29228
29229
29230 SWIGINTERN PyObject *_wrap_Hex_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29231   PyObject *resultobj = 0;
29232   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29233   void *argp1 = 0 ;
29234   int res1 = 0 ;
29235   PyObject * obj0 = 0 ;
29236
29237   if (!PyArg_ParseTuple(args,(char *)"O:Hex_what",&obj0)) SWIG_fail;
29238   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29239   if (!SWIG_IsOK(res1)) {
29240     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_what" "', argument " "1"" of type '" "Hex::Hex *""'");
29241   }
29242   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29243   (arg1)->what();
29244   resultobj = SWIG_Py_Void();
29245   return resultobj;
29246 fail:
29247   return NULL;
29248 }
29249
29250
29251 SWIGINTERN PyObject *_wrap_Hex_sizeofMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29252   PyObject *resultobj = 0;
29253   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29254   int result;
29255   void *argp1 = 0 ;
29256   int res1 = 0 ;
29257   PyObject * obj0 = 0 ;
29258
29259   if (!PyArg_ParseTuple(args,(char *)"O:Hex_sizeofMessage",&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_sizeofMessage" "', argument " "1"" of type '" "Hex::Hex *""'");
29263   }
29264   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29265   result = (int)(arg1)->sizeofMessage();
29266   resultobj = SWIG_From_int(static_cast< int >(result));
29267   return resultobj;
29268 fail:
29269   return NULL;
29270 }
29271
29272
29273 SWIGINTERN PyObject *_wrap_Hex_getMessageLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29274   PyObject *resultobj = 0;
29275   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29276   int arg2 ;
29277   cpchar result;
29278   void *argp1 = 0 ;
29279   int res1 = 0 ;
29280   int val2 ;
29281   int ecode2 = 0 ;
29282   PyObject * obj0 = 0 ;
29283   PyObject * obj1 = 0 ;
29284
29285   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getMessageLine",&obj0,&obj1)) SWIG_fail;
29286   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
29287   if (!SWIG_IsOK(res1)) {
29288     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getMessageLine" "', argument " "1"" of type '" "Hex::Hex *""'");
29289   }
29290   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29291   ecode2 = SWIG_AsVal_int(obj1, &val2);
29292   if (!SWIG_IsOK(ecode2)) {
29293     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getMessageLine" "', argument " "2"" of type '" "int""'");
29294   }
29295   arg2 = static_cast< int >(val2);
29296   result = (cpchar)(arg1)->getMessageLine(arg2);
29297   resultobj = SWIG_FromCharPtr((const char *)result);
29298   return resultobj;
29299 fail:
29300   return NULL;
29301 }
29302
29303
29304 SWIGINTERN PyObject *_wrap_new_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29305   PyObject *resultobj = 0;
29306   Hex::Hex *result = 0 ;
29307
29308   if (!PyArg_ParseTuple(args,(char *)":new_Hex")) SWIG_fail;
29309   result = (Hex::Hex *)new Hex::Hex();
29310   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, SWIG_POINTER_NEW |  0 );
29311   return resultobj;
29312 fail:
29313   return NULL;
29314 }
29315
29316
29317 SWIGINTERN PyObject *_wrap_delete_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29318   PyObject *resultobj = 0;
29319   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
29320   void *argp1 = 0 ;
29321   int res1 = 0 ;
29322   PyObject * obj0 = 0 ;
29323
29324   if (!PyArg_ParseTuple(args,(char *)"O:delete_Hex",&obj0)) SWIG_fail;
29325   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, SWIG_POINTER_DISOWN |  0 );
29326   if (!SWIG_IsOK(res1)) {
29327     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hex" "', argument " "1"" of type '" "Hex::Hex *""'");
29328   }
29329   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
29330   delete arg1;
29331
29332   resultobj = SWIG_Py_Void();
29333   return resultobj;
29334 fail:
29335   return NULL;
29336 }
29337
29338
29339 SWIGINTERN PyObject *Hex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29340   PyObject *obj;
29341   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
29342   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hex, SWIG_NewClientData(obj));
29343   return SWIG_Py_Void();
29344 }
29345
29346 SWIGINTERN PyObject *_wrap_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29347   PyObject *resultobj = 0;
29348
29349   if (!PyArg_ParseTuple(args,(char *)":what")) SWIG_fail;
29350   Hex::what();
29351   resultobj = SWIG_Py_Void();
29352   return resultobj;
29353 fail:
29354   return NULL;
29355 }
29356
29357
29358 SWIGINTERN PyObject *_wrap_Elements_getHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29359   PyObject *resultobj = 0;
29360   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29361   int arg2 ;
29362   Hex::Hexa *result = 0 ;
29363   void *argp1 = 0 ;
29364   int res1 = 0 ;
29365   int val2 ;
29366   int ecode2 = 0 ;
29367   PyObject * obj0 = 0 ;
29368   PyObject * obj1 = 0 ;
29369
29370   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getHexa",&obj0,&obj1)) SWIG_fail;
29371   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29372   if (!SWIG_IsOK(res1)) {
29373     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
29374   }
29375   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29376   ecode2 = SWIG_AsVal_int(obj1, &val2);
29377   if (!SWIG_IsOK(ecode2)) {
29378     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexa" "', argument " "2"" of type '" "int""'");
29379   }
29380   arg2 = static_cast< int >(val2);
29381   result = (Hex::Hexa *)(arg1)->getHexa(arg2);
29382   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
29383   return resultobj;
29384 fail:
29385   return NULL;
29386 }
29387
29388
29389 SWIGINTERN PyObject *_wrap_Elements_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29390   PyObject *resultobj = 0;
29391   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29392   int arg2 ;
29393   Hex::Quad *result = 0 ;
29394   void *argp1 = 0 ;
29395   int res1 = 0 ;
29396   int val2 ;
29397   int ecode2 = 0 ;
29398   PyObject * obj0 = 0 ;
29399   PyObject * obj1 = 0 ;
29400
29401   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getQuad",&obj0,&obj1)) SWIG_fail;
29402   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29403   if (!SWIG_IsOK(res1)) {
29404     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
29405   }
29406   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29407   ecode2 = SWIG_AsVal_int(obj1, &val2);
29408   if (!SWIG_IsOK(ecode2)) {
29409     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuad" "', argument " "2"" of type '" "int""'");
29410   }
29411   arg2 = static_cast< int >(val2);
29412   result = (Hex::Quad *)(arg1)->getQuad(arg2);
29413   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
29414   return resultobj;
29415 fail:
29416   return NULL;
29417 }
29418
29419
29420 SWIGINTERN PyObject *_wrap_Elements_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29421   PyObject *resultobj = 0;
29422   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29423   int arg2 ;
29424   Hex::Edge *result = 0 ;
29425   void *argp1 = 0 ;
29426   int res1 = 0 ;
29427   int val2 ;
29428   int ecode2 = 0 ;
29429   PyObject * obj0 = 0 ;
29430   PyObject * obj1 = 0 ;
29431
29432   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getEdge",&obj0,&obj1)) SWIG_fail;
29433   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29434   if (!SWIG_IsOK(res1)) {
29435     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
29436   }
29437   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29438   ecode2 = SWIG_AsVal_int(obj1, &val2);
29439   if (!SWIG_IsOK(ecode2)) {
29440     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdge" "', argument " "2"" of type '" "int""'");
29441   }
29442   arg2 = static_cast< int >(val2);
29443   result = (Hex::Edge *)(arg1)->getEdge(arg2);
29444   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
29445   return resultobj;
29446 fail:
29447   return NULL;
29448 }
29449
29450
29451 SWIGINTERN PyObject *_wrap_Elements_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29452   PyObject *resultobj = 0;
29453   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29454   int arg2 ;
29455   Hex::Vertex *result = 0 ;
29456   void *argp1 = 0 ;
29457   int res1 = 0 ;
29458   int val2 ;
29459   int ecode2 = 0 ;
29460   PyObject * obj0 = 0 ;
29461   PyObject * obj1 = 0 ;
29462
29463   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getVertex",&obj0,&obj1)) SWIG_fail;
29464   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29465   if (!SWIG_IsOK(res1)) {
29466     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
29467   }
29468   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29469   ecode2 = SWIG_AsVal_int(obj1, &val2);
29470   if (!SWIG_IsOK(ecode2)) {
29471     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertex" "', argument " "2"" of type '" "int""'");
29472   }
29473   arg2 = static_cast< int >(val2);
29474   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
29475   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29476   return resultobj;
29477 fail:
29478   return NULL;
29479 }
29480
29481
29482 SWIGINTERN PyObject *_wrap_Elements_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29483   PyObject *resultobj = 0;
29484   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29485   int arg2 ;
29486   int arg3 ;
29487   int arg4 ;
29488   Hex::Hexa *result = 0 ;
29489   void *argp1 = 0 ;
29490   int res1 = 0 ;
29491   int val2 ;
29492   int ecode2 = 0 ;
29493   int val3 ;
29494   int ecode3 = 0 ;
29495   int val4 ;
29496   int ecode4 = 0 ;
29497   PyObject * obj0 = 0 ;
29498   PyObject * obj1 = 0 ;
29499   PyObject * obj2 = 0 ;
29500   PyObject * obj3 = 0 ;
29501
29502   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getHexaIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29503   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29504   if (!SWIG_IsOK(res1)) {
29505     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexaIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
29506   }
29507   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29508   ecode2 = SWIG_AsVal_int(obj1, &val2);
29509   if (!SWIG_IsOK(ecode2)) {
29510     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexaIJK" "', argument " "2"" of type '" "int""'");
29511   }
29512   arg2 = static_cast< int >(val2);
29513   ecode3 = SWIG_AsVal_int(obj2, &val3);
29514   if (!SWIG_IsOK(ecode3)) {
29515     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getHexaIJK" "', argument " "3"" of type '" "int""'");
29516   }
29517   arg3 = static_cast< int >(val3);
29518   ecode4 = SWIG_AsVal_int(obj3, &val4);
29519   if (!SWIG_IsOK(ecode4)) {
29520     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getHexaIJK" "', argument " "4"" of type '" "int""'");
29521   }
29522   arg4 = static_cast< int >(val4);
29523   result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4);
29524   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
29525   return resultobj;
29526 fail:
29527   return NULL;
29528 }
29529
29530
29531 SWIGINTERN PyObject *_wrap_Elements_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29532   PyObject *resultobj = 0;
29533   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29534   int arg2 ;
29535   int arg3 ;
29536   int arg4 ;
29537   Hex::Quad *result = 0 ;
29538   void *argp1 = 0 ;
29539   int res1 = 0 ;
29540   int val2 ;
29541   int ecode2 = 0 ;
29542   int val3 ;
29543   int ecode3 = 0 ;
29544   int val4 ;
29545   int ecode4 = 0 ;
29546   PyObject * obj0 = 0 ;
29547   PyObject * obj1 = 0 ;
29548   PyObject * obj2 = 0 ;
29549   PyObject * obj3 = 0 ;
29550
29551   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29552   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29553   if (!SWIG_IsOK(res1)) {
29554     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIJ" "', argument " "1"" of type '" "Hex::Elements *""'");
29555   }
29556   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29557   ecode2 = SWIG_AsVal_int(obj1, &val2);
29558   if (!SWIG_IsOK(ecode2)) {
29559     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIJ" "', argument " "2"" of type '" "int""'");
29560   }
29561   arg2 = static_cast< int >(val2);
29562   ecode3 = SWIG_AsVal_int(obj2, &val3);
29563   if (!SWIG_IsOK(ecode3)) {
29564     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIJ" "', argument " "3"" of type '" "int""'");
29565   }
29566   arg3 = static_cast< int >(val3);
29567   ecode4 = SWIG_AsVal_int(obj3, &val4);
29568   if (!SWIG_IsOK(ecode4)) {
29569     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIJ" "', argument " "4"" of type '" "int""'");
29570   }
29571   arg4 = static_cast< int >(val4);
29572   result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4);
29573   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
29574   return resultobj;
29575 fail:
29576   return NULL;
29577 }
29578
29579
29580 SWIGINTERN PyObject *_wrap_Elements_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29581   PyObject *resultobj = 0;
29582   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29583   int arg2 ;
29584   int arg3 ;
29585   int arg4 ;
29586   Hex::Quad *result = 0 ;
29587   void *argp1 = 0 ;
29588   int res1 = 0 ;
29589   int val2 ;
29590   int ecode2 = 0 ;
29591   int val3 ;
29592   int ecode3 = 0 ;
29593   int val4 ;
29594   int ecode4 = 0 ;
29595   PyObject * obj0 = 0 ;
29596   PyObject * obj1 = 0 ;
29597   PyObject * obj2 = 0 ;
29598   PyObject * obj3 = 0 ;
29599
29600   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29601   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29602   if (!SWIG_IsOK(res1)) {
29603     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadJK" "', argument " "1"" of type '" "Hex::Elements *""'");
29604   }
29605   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29606   ecode2 = SWIG_AsVal_int(obj1, &val2);
29607   if (!SWIG_IsOK(ecode2)) {
29608     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadJK" "', argument " "2"" of type '" "int""'");
29609   }
29610   arg2 = static_cast< int >(val2);
29611   ecode3 = SWIG_AsVal_int(obj2, &val3);
29612   if (!SWIG_IsOK(ecode3)) {
29613     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadJK" "', argument " "3"" of type '" "int""'");
29614   }
29615   arg3 = static_cast< int >(val3);
29616   ecode4 = SWIG_AsVal_int(obj3, &val4);
29617   if (!SWIG_IsOK(ecode4)) {
29618     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadJK" "', argument " "4"" of type '" "int""'");
29619   }
29620   arg4 = static_cast< int >(val4);
29621   result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4);
29622   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
29623   return resultobj;
29624 fail:
29625   return NULL;
29626 }
29627
29628
29629 SWIGINTERN PyObject *_wrap_Elements_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29630   PyObject *resultobj = 0;
29631   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29632   int arg2 ;
29633   int arg3 ;
29634   int arg4 ;
29635   Hex::Quad *result = 0 ;
29636   void *argp1 = 0 ;
29637   int res1 = 0 ;
29638   int val2 ;
29639   int ecode2 = 0 ;
29640   int val3 ;
29641   int ecode3 = 0 ;
29642   int val4 ;
29643   int ecode4 = 0 ;
29644   PyObject * obj0 = 0 ;
29645   PyObject * obj1 = 0 ;
29646   PyObject * obj2 = 0 ;
29647   PyObject * obj3 = 0 ;
29648
29649   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29650   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29651   if (!SWIG_IsOK(res1)) {
29652     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIK" "', argument " "1"" of type '" "Hex::Elements *""'");
29653   }
29654   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29655   ecode2 = SWIG_AsVal_int(obj1, &val2);
29656   if (!SWIG_IsOK(ecode2)) {
29657     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIK" "', argument " "2"" of type '" "int""'");
29658   }
29659   arg2 = static_cast< int >(val2);
29660   ecode3 = SWIG_AsVal_int(obj2, &val3);
29661   if (!SWIG_IsOK(ecode3)) {
29662     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIK" "', argument " "3"" of type '" "int""'");
29663   }
29664   arg3 = static_cast< int >(val3);
29665   ecode4 = SWIG_AsVal_int(obj3, &val4);
29666   if (!SWIG_IsOK(ecode4)) {
29667     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIK" "', argument " "4"" of type '" "int""'");
29668   }
29669   arg4 = static_cast< int >(val4);
29670   result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4);
29671   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
29672   return resultobj;
29673 fail:
29674   return NULL;
29675 }
29676
29677
29678 SWIGINTERN PyObject *_wrap_Elements_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29679   PyObject *resultobj = 0;
29680   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29681   int arg2 ;
29682   int arg3 ;
29683   int arg4 ;
29684   Hex::Edge *result = 0 ;
29685   void *argp1 = 0 ;
29686   int res1 = 0 ;
29687   int val2 ;
29688   int ecode2 = 0 ;
29689   int val3 ;
29690   int ecode3 = 0 ;
29691   int val4 ;
29692   int ecode4 = 0 ;
29693   PyObject * obj0 = 0 ;
29694   PyObject * obj1 = 0 ;
29695   PyObject * obj2 = 0 ;
29696   PyObject * obj3 = 0 ;
29697
29698   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeI",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29699   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29700   if (!SWIG_IsOK(res1)) {
29701     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeI" "', argument " "1"" of type '" "Hex::Elements *""'");
29702   }
29703   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29704   ecode2 = SWIG_AsVal_int(obj1, &val2);
29705   if (!SWIG_IsOK(ecode2)) {
29706     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeI" "', argument " "2"" of type '" "int""'");
29707   }
29708   arg2 = static_cast< int >(val2);
29709   ecode3 = SWIG_AsVal_int(obj2, &val3);
29710   if (!SWIG_IsOK(ecode3)) {
29711     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeI" "', argument " "3"" of type '" "int""'");
29712   }
29713   arg3 = static_cast< int >(val3);
29714   ecode4 = SWIG_AsVal_int(obj3, &val4);
29715   if (!SWIG_IsOK(ecode4)) {
29716     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeI" "', argument " "4"" of type '" "int""'");
29717   }
29718   arg4 = static_cast< int >(val4);
29719   result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4);
29720   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
29721   return resultobj;
29722 fail:
29723   return NULL;
29724 }
29725
29726
29727 SWIGINTERN PyObject *_wrap_Elements_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29728   PyObject *resultobj = 0;
29729   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29730   int arg2 ;
29731   int arg3 ;
29732   int arg4 ;
29733   Hex::Edge *result = 0 ;
29734   void *argp1 = 0 ;
29735   int res1 = 0 ;
29736   int val2 ;
29737   int ecode2 = 0 ;
29738   int val3 ;
29739   int ecode3 = 0 ;
29740   int val4 ;
29741   int ecode4 = 0 ;
29742   PyObject * obj0 = 0 ;
29743   PyObject * obj1 = 0 ;
29744   PyObject * obj2 = 0 ;
29745   PyObject * obj3 = 0 ;
29746
29747   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29748   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29749   if (!SWIG_IsOK(res1)) {
29750     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeJ" "', argument " "1"" of type '" "Hex::Elements *""'");
29751   }
29752   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29753   ecode2 = SWIG_AsVal_int(obj1, &val2);
29754   if (!SWIG_IsOK(ecode2)) {
29755     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeJ" "', argument " "2"" of type '" "int""'");
29756   }
29757   arg2 = static_cast< int >(val2);
29758   ecode3 = SWIG_AsVal_int(obj2, &val3);
29759   if (!SWIG_IsOK(ecode3)) {
29760     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeJ" "', argument " "3"" of type '" "int""'");
29761   }
29762   arg3 = static_cast< int >(val3);
29763   ecode4 = SWIG_AsVal_int(obj3, &val4);
29764   if (!SWIG_IsOK(ecode4)) {
29765     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeJ" "', argument " "4"" of type '" "int""'");
29766   }
29767   arg4 = static_cast< int >(val4);
29768   result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4);
29769   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
29770   return resultobj;
29771 fail:
29772   return NULL;
29773 }
29774
29775
29776 SWIGINTERN PyObject *_wrap_Elements_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29777   PyObject *resultobj = 0;
29778   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29779   int arg2 ;
29780   int arg3 ;
29781   int arg4 ;
29782   Hex::Edge *result = 0 ;
29783   void *argp1 = 0 ;
29784   int res1 = 0 ;
29785   int val2 ;
29786   int ecode2 = 0 ;
29787   int val3 ;
29788   int ecode3 = 0 ;
29789   int val4 ;
29790   int ecode4 = 0 ;
29791   PyObject * obj0 = 0 ;
29792   PyObject * obj1 = 0 ;
29793   PyObject * obj2 = 0 ;
29794   PyObject * obj3 = 0 ;
29795
29796   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29797   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29798   if (!SWIG_IsOK(res1)) {
29799     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeK" "', argument " "1"" of type '" "Hex::Elements *""'");
29800   }
29801   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29802   ecode2 = SWIG_AsVal_int(obj1, &val2);
29803   if (!SWIG_IsOK(ecode2)) {
29804     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeK" "', argument " "2"" of type '" "int""'");
29805   }
29806   arg2 = static_cast< int >(val2);
29807   ecode3 = SWIG_AsVal_int(obj2, &val3);
29808   if (!SWIG_IsOK(ecode3)) {
29809     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeK" "', argument " "3"" of type '" "int""'");
29810   }
29811   arg3 = static_cast< int >(val3);
29812   ecode4 = SWIG_AsVal_int(obj3, &val4);
29813   if (!SWIG_IsOK(ecode4)) {
29814     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeK" "', argument " "4"" of type '" "int""'");
29815   }
29816   arg4 = static_cast< int >(val4);
29817   result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4);
29818   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
29819   return resultobj;
29820 fail:
29821   return NULL;
29822 }
29823
29824
29825 SWIGINTERN PyObject *_wrap_Elements_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29826   PyObject *resultobj = 0;
29827   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29828   int arg2 ;
29829   int arg3 ;
29830   int arg4 ;
29831   Hex::Vertex *result = 0 ;
29832   void *argp1 = 0 ;
29833   int res1 = 0 ;
29834   int val2 ;
29835   int ecode2 = 0 ;
29836   int val3 ;
29837   int ecode3 = 0 ;
29838   int val4 ;
29839   int ecode4 = 0 ;
29840   PyObject * obj0 = 0 ;
29841   PyObject * obj1 = 0 ;
29842   PyObject * obj2 = 0 ;
29843   PyObject * obj3 = 0 ;
29844
29845   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getVertexIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29846   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29847   if (!SWIG_IsOK(res1)) {
29848     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertexIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
29849   }
29850   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29851   ecode2 = SWIG_AsVal_int(obj1, &val2);
29852   if (!SWIG_IsOK(ecode2)) {
29853     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertexIJK" "', argument " "2"" of type '" "int""'");
29854   }
29855   arg2 = static_cast< int >(val2);
29856   ecode3 = SWIG_AsVal_int(obj2, &val3);
29857   if (!SWIG_IsOK(ecode3)) {
29858     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getVertexIJK" "', argument " "3"" of type '" "int""'");
29859   }
29860   arg3 = static_cast< int >(val3);
29861   ecode4 = SWIG_AsVal_int(obj3, &val4);
29862   if (!SWIG_IsOK(ecode4)) {
29863     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getVertexIJK" "', argument " "4"" of type '" "int""'");
29864   }
29865   arg4 = static_cast< int >(val4);
29866   result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4);
29867   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29868   return resultobj;
29869 fail:
29870   return NULL;
29871 }
29872
29873
29874 SWIGINTERN PyObject *_wrap_Elements_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29875   PyObject *resultobj = 0;
29876   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29877   int result;
29878   void *argp1 = 0 ;
29879   int res1 = 0 ;
29880   PyObject * obj0 = 0 ;
29881
29882   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countHexa",&obj0)) SWIG_fail;
29883   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29884   if (!SWIG_IsOK(res1)) {
29885     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
29886   }
29887   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29888   result = (int)(arg1)->countHexa();
29889   resultobj = SWIG_From_int(static_cast< int >(result));
29890   return resultobj;
29891 fail:
29892   return NULL;
29893 }
29894
29895
29896 SWIGINTERN PyObject *_wrap_Elements_countQuad(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_countQuad",&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_countQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
29908   }
29909   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29910   result = (int)(arg1)->countQuad();
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_countEdge(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_countEdge",&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_countEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
29930   }
29931   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29932   result = (int)(arg1)->countEdge();
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_countVertex(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_countVertex",&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_countVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
29952   }
29953   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29954   result = (int)(arg1)->countVertex();
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_nearestVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29963   PyObject *resultobj = 0;
29964   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29965   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29966   Hex::Vertex *result = 0 ;
29967   void *argp1 = 0 ;
29968   int res1 = 0 ;
29969   void *argp2 = 0 ;
29970   int res2 = 0 ;
29971   PyObject * obj0 = 0 ;
29972   PyObject * obj1 = 0 ;
29973
29974   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_nearestVertex",&obj0,&obj1)) SWIG_fail;
29975   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
29976   if (!SWIG_IsOK(res1)) {
29977     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_nearestVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
29978   }
29979   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
29980   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29981   if (!SWIG_IsOK(res2)) {
29982     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_nearestVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
29983   }
29984   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29985   result = (Hex::Vertex *)(arg1)->nearestVertex(arg2);
29986   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29987   return resultobj;
29988 fail:
29989   return NULL;
29990 }
29991
29992
29993 SWIGINTERN PyObject *_wrap_Elements_findVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29994   PyObject *resultobj = 0;
29995   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
29996   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29997   int result;
29998   void *argp1 = 0 ;
29999   int res1 = 0 ;
30000   void *argp2 = 0 ;
30001   int res2 = 0 ;
30002   PyObject * obj0 = 0 ;
30003   PyObject * obj1 = 0 ;
30004
30005   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_findVertex",&obj0,&obj1)) SWIG_fail;
30006   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30007   if (!SWIG_IsOK(res1)) {
30008     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_findVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
30009   }
30010   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30011   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30012   if (!SWIG_IsOK(res2)) {
30013     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_findVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
30014   }
30015   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30016   result = (int)(arg1)->findVertex(arg2);
30017   resultobj = SWIG_From_int(static_cast< int >(result));
30018   return resultobj;
30019 fail:
30020   return NULL;
30021 }
30022
30023
30024 SWIGINTERN PyObject *_wrap_Elements_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30025   PyObject *resultobj = 0;
30026   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30027   void *argp1 = 0 ;
30028   int res1 = 0 ;
30029   PyObject * obj0 = 0 ;
30030
30031   if (!PyArg_ParseTuple(args,(char *)"O:Elements_clearAssociation",&obj0)) SWIG_fail;
30032   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30033   if (!SWIG_IsOK(res1)) {
30034     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_clearAssociation" "', argument " "1"" of type '" "Hex::Elements *""'");
30035   }
30036   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30037   (arg1)->clearAssociation();
30038   resultobj = SWIG_Py_Void();
30039   return resultobj;
30040 fail:
30041   return NULL;
30042 }
30043
30044
30045 SWIGINTERN PyObject *_wrap_Elements_saveVtk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30046   PyObject *resultobj = 0;
30047   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30048   cpchar arg2 = (cpchar) 0 ;
30049   int result;
30050   void *argp1 = 0 ;
30051   int res1 = 0 ;
30052   int res2 ;
30053   char *buf2 = 0 ;
30054   int alloc2 = 0 ;
30055   PyObject * obj0 = 0 ;
30056   PyObject * obj1 = 0 ;
30057
30058   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_saveVtk",&obj0,&obj1)) SWIG_fail;
30059   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
30060   if (!SWIG_IsOK(res1)) {
30061     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_saveVtk" "', argument " "1"" of type '" "Hex::Elements *""'");
30062   }
30063   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30064   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30065   if (!SWIG_IsOK(res2)) {
30066     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_saveVtk" "', argument " "2"" of type '" "cpchar""'");
30067   }
30068   arg2 = reinterpret_cast< cpchar >(buf2);
30069   result = (int)(arg1)->saveVtk(arg2);
30070   resultobj = SWIG_From_int(static_cast< int >(result));
30071   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30072   return resultobj;
30073 fail:
30074   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
30075   return NULL;
30076 }
30077
30078
30079 SWIGINTERN PyObject *_wrap_new_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30080   PyObject *resultobj = 0;
30081   Hex::Document *arg1 = (Hex::Document *) 0 ;
30082   Hex::Elements *result = 0 ;
30083   void *argp1 = 0 ;
30084   int res1 = 0 ;
30085   PyObject * obj0 = 0 ;
30086
30087   if (!PyArg_ParseTuple(args,(char *)"O:new_Elements",&obj0)) SWIG_fail;
30088   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30089   if (!SWIG_IsOK(res1)) {
30090     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Elements" "', argument " "1"" of type '" "Hex::Document *""'");
30091   }
30092   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30093   result = (Hex::Elements *)new Hex::Elements(arg1);
30094   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, SWIG_POINTER_NEW |  0 );
30095   return resultobj;
30096 fail:
30097   return NULL;
30098 }
30099
30100
30101 SWIGINTERN PyObject *_wrap_delete_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30102   PyObject *resultobj = 0;
30103   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
30104   void *argp1 = 0 ;
30105   int res1 = 0 ;
30106   PyObject * obj0 = 0 ;
30107
30108   if (!PyArg_ParseTuple(args,(char *)"O:delete_Elements",&obj0)) SWIG_fail;
30109   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, SWIG_POINTER_DISOWN |  0 );
30110   if (!SWIG_IsOK(res1)) {
30111     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Elements" "', argument " "1"" of type '" "Hex::Elements *""'");
30112   }
30113   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
30114   delete arg1;
30115
30116   resultobj = SWIG_Py_Void();
30117   return resultobj;
30118 fail:
30119   return NULL;
30120 }
30121
30122
30123 SWIGINTERN PyObject *Elements_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30124   PyObject *obj;
30125   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
30126   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Elements, SWIG_NewClientData(obj));
30127   return SWIG_Py_Void();
30128 }
30129
30130 SWIGINTERN PyObject *_wrap_new_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30131   PyObject *resultobj = 0;
30132   Hex::Document *arg1 = (Hex::Document *) 0 ;
30133   Hex::BiCylinder *result = 0 ;
30134   void *argp1 = 0 ;
30135   int res1 = 0 ;
30136   PyObject * obj0 = 0 ;
30137
30138   if (!PyArg_ParseTuple(args,(char *)"O:new_BiCylinder",&obj0)) SWIG_fail;
30139   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30140   if (!SWIG_IsOK(res1)) {
30141     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BiCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
30142   }
30143   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30144   result = (Hex::BiCylinder *)new Hex::BiCylinder(arg1);
30145   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_NEW |  0 );
30146   return resultobj;
30147 fail:
30148   return NULL;
30149 }
30150
30151
30152 SWIGINTERN PyObject *_wrap_BiCylinder_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30153   PyObject *resultobj = 0;
30154   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30155   int arg2 ;
30156   int arg3 ;
30157   int arg4 ;
30158   int arg5 ;
30159   Hex::Hexa *result = 0 ;
30160   void *argp1 = 0 ;
30161   int res1 = 0 ;
30162   int val2 ;
30163   int ecode2 = 0 ;
30164   int val3 ;
30165   int ecode3 = 0 ;
30166   int val4 ;
30167   int ecode4 = 0 ;
30168   int val5 ;
30169   int ecode5 = 0 ;
30170   PyObject * obj0 = 0 ;
30171   PyObject * obj1 = 0 ;
30172   PyObject * obj2 = 0 ;
30173   PyObject * obj3 = 0 ;
30174   PyObject * obj4 = 0 ;
30175
30176   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getHexaIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30177   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30178   if (!SWIG_IsOK(res1)) {
30179     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getHexaIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30180   }
30181   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30182   ecode2 = SWIG_AsVal_int(obj1, &val2);
30183   if (!SWIG_IsOK(ecode2)) {
30184     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getHexaIJK" "', argument " "2"" of type '" "int""'");
30185   }
30186   arg2 = static_cast< int >(val2);
30187   ecode3 = SWIG_AsVal_int(obj2, &val3);
30188   if (!SWIG_IsOK(ecode3)) {
30189     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getHexaIJK" "', argument " "3"" of type '" "int""'");
30190   }
30191   arg3 = static_cast< int >(val3);
30192   ecode4 = SWIG_AsVal_int(obj3, &val4);
30193   if (!SWIG_IsOK(ecode4)) {
30194     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getHexaIJK" "', argument " "4"" of type '" "int""'");
30195   }
30196   arg4 = static_cast< int >(val4);
30197   ecode5 = SWIG_AsVal_int(obj4, &val5);
30198   if (!SWIG_IsOK(ecode5)) {
30199     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getHexaIJK" "', argument " "5"" of type '" "int""'");
30200   }
30201   arg5 = static_cast< int >(val5);
30202   result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4,arg5);
30203   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
30204   return resultobj;
30205 fail:
30206   return NULL;
30207 }
30208
30209
30210 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30211   PyObject *resultobj = 0;
30212   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30213   int arg2 ;
30214   int arg3 ;
30215   int arg4 ;
30216   int arg5 ;
30217   Hex::Quad *result = 0 ;
30218   void *argp1 = 0 ;
30219   int res1 = 0 ;
30220   int val2 ;
30221   int ecode2 = 0 ;
30222   int val3 ;
30223   int ecode3 = 0 ;
30224   int val4 ;
30225   int ecode4 = 0 ;
30226   int val5 ;
30227   int ecode5 = 0 ;
30228   PyObject * obj0 = 0 ;
30229   PyObject * obj1 = 0 ;
30230   PyObject * obj2 = 0 ;
30231   PyObject * obj3 = 0 ;
30232   PyObject * obj4 = 0 ;
30233
30234   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30235   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30236   if (!SWIG_IsOK(res1)) {
30237     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30238   }
30239   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30240   ecode2 = SWIG_AsVal_int(obj1, &val2);
30241   if (!SWIG_IsOK(ecode2)) {
30242     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIJ" "', argument " "2"" of type '" "int""'");
30243   }
30244   arg2 = static_cast< int >(val2);
30245   ecode3 = SWIG_AsVal_int(obj2, &val3);
30246   if (!SWIG_IsOK(ecode3)) {
30247     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIJ" "', argument " "3"" of type '" "int""'");
30248   }
30249   arg3 = static_cast< int >(val3);
30250   ecode4 = SWIG_AsVal_int(obj3, &val4);
30251   if (!SWIG_IsOK(ecode4)) {
30252     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIJ" "', argument " "4"" of type '" "int""'");
30253   }
30254   arg4 = static_cast< int >(val4);
30255   ecode5 = SWIG_AsVal_int(obj4, &val5);
30256   if (!SWIG_IsOK(ecode5)) {
30257     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIJ" "', argument " "5"" of type '" "int""'");
30258   }
30259   arg5 = static_cast< int >(val5);
30260   result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4,arg5);
30261   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
30262   return resultobj;
30263 fail:
30264   return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30269   PyObject *resultobj = 0;
30270   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30271   int arg2 ;
30272   int arg3 ;
30273   int arg4 ;
30274   int arg5 ;
30275   Hex::Quad *result = 0 ;
30276   void *argp1 = 0 ;
30277   int res1 = 0 ;
30278   int val2 ;
30279   int ecode2 = 0 ;
30280   int val3 ;
30281   int ecode3 = 0 ;
30282   int val4 ;
30283   int ecode4 = 0 ;
30284   int val5 ;
30285   int ecode5 = 0 ;
30286   PyObject * obj0 = 0 ;
30287   PyObject * obj1 = 0 ;
30288   PyObject * obj2 = 0 ;
30289   PyObject * obj3 = 0 ;
30290   PyObject * obj4 = 0 ;
30291
30292   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30293   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30294   if (!SWIG_IsOK(res1)) {
30295     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30296   }
30297   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30298   ecode2 = SWIG_AsVal_int(obj1, &val2);
30299   if (!SWIG_IsOK(ecode2)) {
30300     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadJK" "', argument " "2"" of type '" "int""'");
30301   }
30302   arg2 = static_cast< int >(val2);
30303   ecode3 = SWIG_AsVal_int(obj2, &val3);
30304   if (!SWIG_IsOK(ecode3)) {
30305     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadJK" "', argument " "3"" of type '" "int""'");
30306   }
30307   arg3 = static_cast< int >(val3);
30308   ecode4 = SWIG_AsVal_int(obj3, &val4);
30309   if (!SWIG_IsOK(ecode4)) {
30310     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadJK" "', argument " "4"" of type '" "int""'");
30311   }
30312   arg4 = static_cast< int >(val4);
30313   ecode5 = SWIG_AsVal_int(obj4, &val5);
30314   if (!SWIG_IsOK(ecode5)) {
30315     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadJK" "', argument " "5"" of type '" "int""'");
30316   }
30317   arg5 = static_cast< int >(val5);
30318   result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4,arg5);
30319   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
30320   return resultobj;
30321 fail:
30322   return NULL;
30323 }
30324
30325
30326 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30327   PyObject *resultobj = 0;
30328   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30329   int arg2 ;
30330   int arg3 ;
30331   int arg4 ;
30332   int arg5 ;
30333   Hex::Quad *result = 0 ;
30334   void *argp1 = 0 ;
30335   int res1 = 0 ;
30336   int val2 ;
30337   int ecode2 = 0 ;
30338   int val3 ;
30339   int ecode3 = 0 ;
30340   int val4 ;
30341   int ecode4 = 0 ;
30342   int val5 ;
30343   int ecode5 = 0 ;
30344   PyObject * obj0 = 0 ;
30345   PyObject * obj1 = 0 ;
30346   PyObject * obj2 = 0 ;
30347   PyObject * obj3 = 0 ;
30348   PyObject * obj4 = 0 ;
30349
30350   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30351   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30352   if (!SWIG_IsOK(res1)) {
30353     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30354   }
30355   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30356   ecode2 = SWIG_AsVal_int(obj1, &val2);
30357   if (!SWIG_IsOK(ecode2)) {
30358     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIK" "', argument " "2"" of type '" "int""'");
30359   }
30360   arg2 = static_cast< int >(val2);
30361   ecode3 = SWIG_AsVal_int(obj2, &val3);
30362   if (!SWIG_IsOK(ecode3)) {
30363     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIK" "', argument " "3"" of type '" "int""'");
30364   }
30365   arg3 = static_cast< int >(val3);
30366   ecode4 = SWIG_AsVal_int(obj3, &val4);
30367   if (!SWIG_IsOK(ecode4)) {
30368     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIK" "', argument " "4"" of type '" "int""'");
30369   }
30370   arg4 = static_cast< int >(val4);
30371   ecode5 = SWIG_AsVal_int(obj4, &val5);
30372   if (!SWIG_IsOK(ecode5)) {
30373     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIK" "', argument " "5"" of type '" "int""'");
30374   }
30375   arg5 = static_cast< int >(val5);
30376   result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4,arg5);
30377   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
30378   return resultobj;
30379 fail:
30380   return NULL;
30381 }
30382
30383
30384 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30385   PyObject *resultobj = 0;
30386   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30387   int arg2 ;
30388   int arg3 ;
30389   int arg4 ;
30390   int arg5 ;
30391   Hex::Edge *result = 0 ;
30392   void *argp1 = 0 ;
30393   int res1 = 0 ;
30394   int val2 ;
30395   int ecode2 = 0 ;
30396   int val3 ;
30397   int ecode3 = 0 ;
30398   int val4 ;
30399   int ecode4 = 0 ;
30400   int val5 ;
30401   int ecode5 = 0 ;
30402   PyObject * obj0 = 0 ;
30403   PyObject * obj1 = 0 ;
30404   PyObject * obj2 = 0 ;
30405   PyObject * obj3 = 0 ;
30406   PyObject * obj4 = 0 ;
30407
30408   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeI",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30409   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30410   if (!SWIG_IsOK(res1)) {
30411     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeI" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30412   }
30413   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30414   ecode2 = SWIG_AsVal_int(obj1, &val2);
30415   if (!SWIG_IsOK(ecode2)) {
30416     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeI" "', argument " "2"" of type '" "int""'");
30417   }
30418   arg2 = static_cast< int >(val2);
30419   ecode3 = SWIG_AsVal_int(obj2, &val3);
30420   if (!SWIG_IsOK(ecode3)) {
30421     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeI" "', argument " "3"" of type '" "int""'");
30422   }
30423   arg3 = static_cast< int >(val3);
30424   ecode4 = SWIG_AsVal_int(obj3, &val4);
30425   if (!SWIG_IsOK(ecode4)) {
30426     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeI" "', argument " "4"" of type '" "int""'");
30427   }
30428   arg4 = static_cast< int >(val4);
30429   ecode5 = SWIG_AsVal_int(obj4, &val5);
30430   if (!SWIG_IsOK(ecode5)) {
30431     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeI" "', argument " "5"" of type '" "int""'");
30432   }
30433   arg5 = static_cast< int >(val5);
30434   result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4,arg5);
30435   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
30436   return resultobj;
30437 fail:
30438   return NULL;
30439 }
30440
30441
30442 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30443   PyObject *resultobj = 0;
30444   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30445   int arg2 ;
30446   int arg3 ;
30447   int arg4 ;
30448   int arg5 ;
30449   Hex::Edge *result = 0 ;
30450   void *argp1 = 0 ;
30451   int res1 = 0 ;
30452   int val2 ;
30453   int ecode2 = 0 ;
30454   int val3 ;
30455   int ecode3 = 0 ;
30456   int val4 ;
30457   int ecode4 = 0 ;
30458   int val5 ;
30459   int ecode5 = 0 ;
30460   PyObject * obj0 = 0 ;
30461   PyObject * obj1 = 0 ;
30462   PyObject * obj2 = 0 ;
30463   PyObject * obj3 = 0 ;
30464   PyObject * obj4 = 0 ;
30465
30466   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30467   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30468   if (!SWIG_IsOK(res1)) {
30469     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30470   }
30471   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30472   ecode2 = SWIG_AsVal_int(obj1, &val2);
30473   if (!SWIG_IsOK(ecode2)) {
30474     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeJ" "', argument " "2"" of type '" "int""'");
30475   }
30476   arg2 = static_cast< int >(val2);
30477   ecode3 = SWIG_AsVal_int(obj2, &val3);
30478   if (!SWIG_IsOK(ecode3)) {
30479     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeJ" "', argument " "3"" of type '" "int""'");
30480   }
30481   arg3 = static_cast< int >(val3);
30482   ecode4 = SWIG_AsVal_int(obj3, &val4);
30483   if (!SWIG_IsOK(ecode4)) {
30484     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeJ" "', argument " "4"" of type '" "int""'");
30485   }
30486   arg4 = static_cast< int >(val4);
30487   ecode5 = SWIG_AsVal_int(obj4, &val5);
30488   if (!SWIG_IsOK(ecode5)) {
30489     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeJ" "', argument " "5"" of type '" "int""'");
30490   }
30491   arg5 = static_cast< int >(val5);
30492   result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4,arg5);
30493   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
30494   return resultobj;
30495 fail:
30496   return NULL;
30497 }
30498
30499
30500 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30501   PyObject *resultobj = 0;
30502   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30503   int arg2 ;
30504   int arg3 ;
30505   int arg4 ;
30506   int arg5 ;
30507   Hex::Edge *result = 0 ;
30508   void *argp1 = 0 ;
30509   int res1 = 0 ;
30510   int val2 ;
30511   int ecode2 = 0 ;
30512   int val3 ;
30513   int ecode3 = 0 ;
30514   int val4 ;
30515   int ecode4 = 0 ;
30516   int val5 ;
30517   int ecode5 = 0 ;
30518   PyObject * obj0 = 0 ;
30519   PyObject * obj1 = 0 ;
30520   PyObject * obj2 = 0 ;
30521   PyObject * obj3 = 0 ;
30522   PyObject * obj4 = 0 ;
30523
30524   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30525   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30526   if (!SWIG_IsOK(res1)) {
30527     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30528   }
30529   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30530   ecode2 = SWIG_AsVal_int(obj1, &val2);
30531   if (!SWIG_IsOK(ecode2)) {
30532     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeK" "', argument " "2"" of type '" "int""'");
30533   }
30534   arg2 = static_cast< int >(val2);
30535   ecode3 = SWIG_AsVal_int(obj2, &val3);
30536   if (!SWIG_IsOK(ecode3)) {
30537     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeK" "', argument " "3"" of type '" "int""'");
30538   }
30539   arg3 = static_cast< int >(val3);
30540   ecode4 = SWIG_AsVal_int(obj3, &val4);
30541   if (!SWIG_IsOK(ecode4)) {
30542     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeK" "', argument " "4"" of type '" "int""'");
30543   }
30544   arg4 = static_cast< int >(val4);
30545   ecode5 = SWIG_AsVal_int(obj4, &val5);
30546   if (!SWIG_IsOK(ecode5)) {
30547     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeK" "', argument " "5"" of type '" "int""'");
30548   }
30549   arg5 = static_cast< int >(val5);
30550   result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4,arg5);
30551   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
30552   return resultobj;
30553 fail:
30554   return NULL;
30555 }
30556
30557
30558 SWIGINTERN PyObject *_wrap_BiCylinder_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30559   PyObject *resultobj = 0;
30560   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30561   int arg2 ;
30562   int arg3 ;
30563   int arg4 ;
30564   int arg5 ;
30565   Hex::Vertex *result = 0 ;
30566   void *argp1 = 0 ;
30567   int res1 = 0 ;
30568   int val2 ;
30569   int ecode2 = 0 ;
30570   int val3 ;
30571   int ecode3 = 0 ;
30572   int val4 ;
30573   int ecode4 = 0 ;
30574   int val5 ;
30575   int ecode5 = 0 ;
30576   PyObject * obj0 = 0 ;
30577   PyObject * obj1 = 0 ;
30578   PyObject * obj2 = 0 ;
30579   PyObject * obj3 = 0 ;
30580   PyObject * obj4 = 0 ;
30581
30582   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getVertexIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30583   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30584   if (!SWIG_IsOK(res1)) {
30585     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getVertexIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30586   }
30587   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30588   ecode2 = SWIG_AsVal_int(obj1, &val2);
30589   if (!SWIG_IsOK(ecode2)) {
30590     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getVertexIJK" "', argument " "2"" of type '" "int""'");
30591   }
30592   arg2 = static_cast< int >(val2);
30593   ecode3 = SWIG_AsVal_int(obj2, &val3);
30594   if (!SWIG_IsOK(ecode3)) {
30595     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getVertexIJK" "', argument " "3"" of type '" "int""'");
30596   }
30597   arg3 = static_cast< int >(val3);
30598   ecode4 = SWIG_AsVal_int(obj3, &val4);
30599   if (!SWIG_IsOK(ecode4)) {
30600     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getVertexIJK" "', argument " "4"" of type '" "int""'");
30601   }
30602   arg4 = static_cast< int >(val4);
30603   ecode5 = SWIG_AsVal_int(obj4, &val5);
30604   if (!SWIG_IsOK(ecode5)) {
30605     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getVertexIJK" "', argument " "5"" of type '" "int""'");
30606   }
30607   arg5 = static_cast< int >(val5);
30608   result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4,arg5);
30609   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30610   return resultobj;
30611 fail:
30612   return NULL;
30613 }
30614
30615
30616 SWIGINTERN PyObject *_wrap_delete_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30617   PyObject *resultobj = 0;
30618   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
30619   void *argp1 = 0 ;
30620   int res1 = 0 ;
30621   PyObject * obj0 = 0 ;
30622
30623   if (!PyArg_ParseTuple(args,(char *)"O:delete_BiCylinder",&obj0)) SWIG_fail;
30624   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_DISOWN |  0 );
30625   if (!SWIG_IsOK(res1)) {
30626     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCylinder" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
30627   }
30628   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
30629   delete arg1;
30630
30631   resultobj = SWIG_Py_Void();
30632   return resultobj;
30633 fail:
30634   return NULL;
30635 }
30636
30637
30638 SWIGINTERN PyObject *BiCylinder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30639   PyObject *obj;
30640   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
30641   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__BiCylinder, SWIG_NewClientData(obj));
30642   return SWIG_Py_Void();
30643 }
30644
30645 SWIGINTERN PyObject *_wrap_NewShape_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30646   PyObject *resultobj = 0;
30647   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30648   int result;
30649   void *argp1 = 0 ;
30650   int res1 = 0 ;
30651   PyObject * obj0 = 0 ;
30652
30653   if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countVertex",&obj0)) SWIG_fail;
30654   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30655   if (!SWIG_IsOK(res1)) {
30656     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
30657   }
30658   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30659   result = (int)(arg1)->countVertex();
30660   resultobj = SWIG_From_int(static_cast< int >(result));
30661   return resultobj;
30662 fail:
30663   return NULL;
30664 }
30665
30666
30667 SWIGINTERN PyObject *_wrap_NewShape_countEdge(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_countEdge",&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_countEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
30679   }
30680   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30681   result = (int)(arg1)->countEdge();
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_countFace(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_countFace",&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_countFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
30701   }
30702   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30703   result = (int)(arg1)->countFace();
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_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30712   PyObject *resultobj = 0;
30713   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30714   int arg2 ;
30715   int result;
30716   void *argp1 = 0 ;
30717   int res1 = 0 ;
30718   int val2 ;
30719   int ecode2 = 0 ;
30720   PyObject * obj0 = 0 ;
30721   PyObject * obj1 = 0 ;
30722
30723   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getVertex",&obj0,&obj1)) SWIG_fail;
30724   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30725   if (!SWIG_IsOK(res1)) {
30726     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
30727   }
30728   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30729   ecode2 = SWIG_AsVal_int(obj1, &val2);
30730   if (!SWIG_IsOK(ecode2)) {
30731     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getVertex" "', argument " "2"" of type '" "int""'");
30732   }
30733   arg2 = static_cast< int >(val2);
30734   result = (int)(arg1)->getVertex(arg2);
30735   resultobj = SWIG_From_int(static_cast< int >(result));
30736   return resultobj;
30737 fail:
30738   return NULL;
30739 }
30740
30741
30742 SWIGINTERN PyObject *_wrap_NewShape_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30743   PyObject *resultobj = 0;
30744   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30745   int arg2 ;
30746   int result;
30747   void *argp1 = 0 ;
30748   int res1 = 0 ;
30749   int val2 ;
30750   int ecode2 = 0 ;
30751   PyObject * obj0 = 0 ;
30752   PyObject * obj1 = 0 ;
30753
30754   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getEdge",&obj0,&obj1)) SWIG_fail;
30755   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30756   if (!SWIG_IsOK(res1)) {
30757     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
30758   }
30759   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30760   ecode2 = SWIG_AsVal_int(obj1, &val2);
30761   if (!SWIG_IsOK(ecode2)) {
30762     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getEdge" "', argument " "2"" of type '" "int""'");
30763   }
30764   arg2 = static_cast< int >(val2);
30765   result = (int)(arg1)->getEdge(arg2);
30766   resultobj = SWIG_From_int(static_cast< int >(result));
30767   return resultobj;
30768 fail:
30769   return NULL;
30770 }
30771
30772
30773 SWIGINTERN PyObject *_wrap_NewShape_getFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30774   PyObject *resultobj = 0;
30775   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30776   int arg2 ;
30777   int result;
30778   void *argp1 = 0 ;
30779   int res1 = 0 ;
30780   int val2 ;
30781   int ecode2 = 0 ;
30782   PyObject * obj0 = 0 ;
30783   PyObject * obj1 = 0 ;
30784
30785   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getFace",&obj0,&obj1)) SWIG_fail;
30786   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30787   if (!SWIG_IsOK(res1)) {
30788     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
30789   }
30790   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30791   ecode2 = SWIG_AsVal_int(obj1, &val2);
30792   if (!SWIG_IsOK(ecode2)) {
30793     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getFace" "', argument " "2"" of type '" "int""'");
30794   }
30795   arg2 = static_cast< int >(val2);
30796   result = (int)(arg1)->getFace(arg2);
30797   resultobj = SWIG_From_int(static_cast< int >(result));
30798   return resultobj;
30799 fail:
30800   return NULL;
30801 }
30802
30803
30804 SWIGINTERN PyObject *_wrap_NewShape_getNameVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30805   PyObject *resultobj = 0;
30806   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30807   int arg2 ;
30808   cpchar result;
30809   void *argp1 = 0 ;
30810   int res1 = 0 ;
30811   int val2 ;
30812   int ecode2 = 0 ;
30813   PyObject * obj0 = 0 ;
30814   PyObject * obj1 = 0 ;
30815
30816   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameVertex",&obj0,&obj1)) SWIG_fail;
30817   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30818   if (!SWIG_IsOK(res1)) {
30819     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
30820   }
30821   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30822   ecode2 = SWIG_AsVal_int(obj1, &val2);
30823   if (!SWIG_IsOK(ecode2)) {
30824     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameVertex" "', argument " "2"" of type '" "int""'");
30825   }
30826   arg2 = static_cast< int >(val2);
30827   result = (cpchar)(arg1)->getNameVertex(arg2);
30828   resultobj = SWIG_FromCharPtr((const char *)result);
30829   return resultobj;
30830 fail:
30831   return NULL;
30832 }
30833
30834
30835 SWIGINTERN PyObject *_wrap_NewShape_getNameEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30836   PyObject *resultobj = 0;
30837   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30838   int arg2 ;
30839   cpchar result;
30840   void *argp1 = 0 ;
30841   int res1 = 0 ;
30842   int val2 ;
30843   int ecode2 = 0 ;
30844   PyObject * obj0 = 0 ;
30845   PyObject * obj1 = 0 ;
30846
30847   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameEdge",&obj0,&obj1)) SWIG_fail;
30848   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30849   if (!SWIG_IsOK(res1)) {
30850     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
30851   }
30852   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30853   ecode2 = SWIG_AsVal_int(obj1, &val2);
30854   if (!SWIG_IsOK(ecode2)) {
30855     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameEdge" "', argument " "2"" of type '" "int""'");
30856   }
30857   arg2 = static_cast< int >(val2);
30858   result = (cpchar)(arg1)->getNameEdge(arg2);
30859   resultobj = SWIG_FromCharPtr((const char *)result);
30860   return resultobj;
30861 fail:
30862   return NULL;
30863 }
30864
30865
30866 SWIGINTERN PyObject *_wrap_NewShape_getNameFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30867   PyObject *resultobj = 0;
30868   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30869   int arg2 ;
30870   cpchar result;
30871   void *argp1 = 0 ;
30872   int res1 = 0 ;
30873   int val2 ;
30874   int ecode2 = 0 ;
30875   PyObject * obj0 = 0 ;
30876   PyObject * obj1 = 0 ;
30877
30878   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameFace",&obj0,&obj1)) SWIG_fail;
30879   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
30880   if (!SWIG_IsOK(res1)) {
30881     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
30882   }
30883   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
30884   ecode2 = SWIG_AsVal_int(obj1, &val2);
30885   if (!SWIG_IsOK(ecode2)) {
30886     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameFace" "', argument " "2"" of type '" "int""'");
30887   }
30888   arg2 = static_cast< int >(val2);
30889   result = (cpchar)(arg1)->getNameFace(arg2);
30890   resultobj = SWIG_FromCharPtr((const char *)result);
30891   return resultobj;
30892 fail:
30893   return NULL;
30894 }
30895
30896
30897 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30898   PyObject *resultobj = 0;
30899   Hex::Document *arg1 = (Hex::Document *) 0 ;
30900   Hex::EnumShape arg2 ;
30901   Hex::NewShape *result = 0 ;
30902   void *argp1 = 0 ;
30903   int res1 = 0 ;
30904   int val2 ;
30905   int ecode2 = 0 ;
30906   PyObject * obj0 = 0 ;
30907   PyObject * obj1 = 0 ;
30908
30909   if (!PyArg_ParseTuple(args,(char *)"OO:new_NewShape",&obj0,&obj1)) SWIG_fail;
30910   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30911   if (!SWIG_IsOK(res1)) {
30912     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
30913   }
30914   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30915   ecode2 = SWIG_AsVal_int(obj1, &val2);
30916   if (!SWIG_IsOK(ecode2)) {
30917     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewShape" "', argument " "2"" of type '" "Hex::EnumShape""'");
30918   }
30919   arg2 = static_cast< Hex::EnumShape >(val2);
30920   result = (Hex::NewShape *)new Hex::NewShape(arg1,arg2);
30921   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_NEW |  0 );
30922   return resultobj;
30923 fail:
30924   return NULL;
30925 }
30926
30927
30928 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30929   PyObject *resultobj = 0;
30930   Hex::Document *arg1 = (Hex::Document *) 0 ;
30931   Hex::NewShape *result = 0 ;
30932   void *argp1 = 0 ;
30933   int res1 = 0 ;
30934   PyObject * obj0 = 0 ;
30935
30936   if (!PyArg_ParseTuple(args,(char *)"O:new_NewShape",&obj0)) SWIG_fail;
30937   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30938   if (!SWIG_IsOK(res1)) {
30939     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
30940   }
30941   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30942   result = (Hex::NewShape *)new Hex::NewShape(arg1);
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(PyObject *self, PyObject *args) {
30951   int argc;
30952   PyObject *argv[3];
30953   int ii;
30954
30955   if (!PyTuple_Check(args)) SWIG_fail;
30956   argc = PyObject_Length(args);
30957   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30958     argv[ii] = PyTuple_GET_ITEM(args,ii);
30959   }
30960   if (argc == 1) {
30961     int _v;
30962     void *vptr = 0;
30963     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
30964     _v = SWIG_CheckState(res);
30965     if (_v) {
30966       return _wrap_new_NewShape__SWIG_1(self, args);
30967     }
30968   }
30969   if (argc == 2) {
30970     int _v;
30971     void *vptr = 0;
30972     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
30973     _v = SWIG_CheckState(res);
30974     if (_v) {
30975       {
30976         int res = SWIG_AsVal_int(argv[1], NULL);
30977         _v = SWIG_CheckState(res);
30978       }
30979       if (_v) {
30980         return _wrap_new_NewShape__SWIG_0(self, args);
30981       }
30982     }
30983   }
30984
30985 fail:
30986   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");
30987   return NULL;
30988 }
30989
30990
30991 SWIGINTERN PyObject *_wrap_delete_NewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30992   PyObject *resultobj = 0;
30993   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
30994   void *argp1 = 0 ;
30995   int res1 = 0 ;
30996   PyObject * obj0 = 0 ;
30997
30998   if (!PyArg_ParseTuple(args,(char *)"O:delete_NewShape",&obj0)) SWIG_fail;
30999   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_DISOWN |  0 );
31000   if (!SWIG_IsOK(res1)) {
31001     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewShape" "', argument " "1"" of type '" "Hex::NewShape *""'");
31002   }
31003   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
31004   delete arg1;
31005
31006   resultobj = SWIG_Py_Void();
31007   return resultobj;
31008 fail:
31009   return NULL;
31010 }
31011
31012
31013 SWIGINTERN PyObject *NewShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31014   PyObject *obj;
31015   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
31016   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__NewShape, SWIG_NewClientData(obj));
31017   return SWIG_Py_Void();
31018 }
31019
31020 SWIGINTERN PyObject *_wrap_Group_addElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31021   PyObject *resultobj = 0;
31022   Hex::Group *arg1 = (Hex::Group *) 0 ;
31023   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
31024   int result;
31025   void *argp1 = 0 ;
31026   int res1 = 0 ;
31027   void *argp2 = 0 ;
31028   int res2 = 0 ;
31029   PyObject * obj0 = 0 ;
31030   PyObject * obj1 = 0 ;
31031
31032   if (!PyArg_ParseTuple(args,(char *)"OO:Group_addElement",&obj0,&obj1)) SWIG_fail;
31033   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31034   if (!SWIG_IsOK(res1)) {
31035     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_addElement" "', argument " "1"" of type '" "Hex::Group *""'");
31036   }
31037   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31038   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
31039   if (!SWIG_IsOK(res2)) {
31040     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_addElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
31041   }
31042   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
31043   result = (int)(arg1)->addElement(arg2);
31044   resultobj = SWIG_From_int(static_cast< int >(result));
31045   return resultobj;
31046 fail:
31047   return NULL;
31048 }
31049
31050
31051 SWIGINTERN PyObject *_wrap_Group_countElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31052   PyObject *resultobj = 0;
31053   Hex::Group *arg1 = (Hex::Group *) 0 ;
31054   int result;
31055   void *argp1 = 0 ;
31056   int res1 = 0 ;
31057   PyObject * obj0 = 0 ;
31058
31059   if (!PyArg_ParseTuple(args,(char *)"O:Group_countElement",&obj0)) SWIG_fail;
31060   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31061   if (!SWIG_IsOK(res1)) {
31062     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_countElement" "', argument " "1"" of type '" "Hex::Group *""'");
31063   }
31064   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31065   result = (int)(arg1)->countElement();
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_getKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31074   PyObject *resultobj = 0;
31075   Hex::Group *arg1 = (Hex::Group *) 0 ;
31076   Hex::EnumGroup result;
31077   void *argp1 = 0 ;
31078   int res1 = 0 ;
31079   PyObject * obj0 = 0 ;
31080
31081   if (!PyArg_ParseTuple(args,(char *)"O:Group_getKind",&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_getKind" "', argument " "1"" of type '" "Hex::Group *""'");
31085   }
31086   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31087   result = (Hex::EnumGroup)(arg1)->getKind();
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_removeElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31096   PyObject *resultobj = 0;
31097   Hex::Group *arg1 = (Hex::Group *) 0 ;
31098   int arg2 ;
31099   int result;
31100   void *argp1 = 0 ;
31101   int res1 = 0 ;
31102   int val2 ;
31103   int ecode2 = 0 ;
31104   PyObject * obj0 = 0 ;
31105   PyObject * obj1 = 0 ;
31106
31107   if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
31108   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31109   if (!SWIG_IsOK(res1)) {
31110     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
31111   }
31112   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31113   ecode2 = SWIG_AsVal_int(obj1, &val2);
31114   if (!SWIG_IsOK(ecode2)) {
31115     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "int""'");
31116   }
31117   arg2 = static_cast< int >(val2);
31118   result = (int)(arg1)->removeElement(arg2);
31119   resultobj = SWIG_From_int(static_cast< int >(result));
31120   return resultobj;
31121 fail:
31122   return NULL;
31123 }
31124
31125
31126 SWIGINTERN PyObject *_wrap_Group_clearElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31127   PyObject *resultobj = 0;
31128   Hex::Group *arg1 = (Hex::Group *) 0 ;
31129   void *argp1 = 0 ;
31130   int res1 = 0 ;
31131   PyObject * obj0 = 0 ;
31132
31133   if (!PyArg_ParseTuple(args,(char *)"O:Group_clearElement",&obj0)) SWIG_fail;
31134   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31135   if (!SWIG_IsOK(res1)) {
31136     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_clearElement" "', argument " "1"" of type '" "Hex::Group *""'");
31137   }
31138   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31139   (arg1)->clearElement();
31140   resultobj = SWIG_Py_Void();
31141   return resultobj;
31142 fail:
31143   return NULL;
31144 }
31145
31146
31147 SWIGINTERN PyObject *_wrap_Group_removeElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31148   PyObject *resultobj = 0;
31149   Hex::Group *arg1 = (Hex::Group *) 0 ;
31150   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
31151   int result;
31152   void *argp1 = 0 ;
31153   int res1 = 0 ;
31154   void *argp2 = 0 ;
31155   int res2 = 0 ;
31156   PyObject * obj0 = 0 ;
31157   PyObject * obj1 = 0 ;
31158
31159   if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
31160   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31161   if (!SWIG_IsOK(res1)) {
31162     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
31163   }
31164   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31165   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
31166   if (!SWIG_IsOK(res2)) {
31167     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
31168   }
31169   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
31170   result = (int)(arg1)->removeElement(arg2);
31171   resultobj = SWIG_From_int(static_cast< int >(result));
31172   return resultobj;
31173 fail:
31174   return NULL;
31175 }
31176
31177
31178 SWIGINTERN PyObject *_wrap_Group_removeElement(PyObject *self, PyObject *args) {
31179   int argc;
31180   PyObject *argv[3];
31181   int ii;
31182
31183   if (!PyTuple_Check(args)) SWIG_fail;
31184   argc = PyObject_Length(args);
31185   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31186     argv[ii] = PyTuple_GET_ITEM(args,ii);
31187   }
31188   if (argc == 2) {
31189     int _v;
31190     void *vptr = 0;
31191     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
31192     _v = SWIG_CheckState(res);
31193     if (_v) {
31194       void *vptr = 0;
31195       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
31196       _v = SWIG_CheckState(res);
31197       if (_v) {
31198         return _wrap_Group_removeElement__SWIG_1(self, args);
31199       }
31200     }
31201   }
31202   if (argc == 2) {
31203     int _v;
31204     void *vptr = 0;
31205     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
31206     _v = SWIG_CheckState(res);
31207     if (_v) {
31208       {
31209         int res = SWIG_AsVal_int(argv[1], NULL);
31210         _v = SWIG_CheckState(res);
31211       }
31212       if (_v) {
31213         return _wrap_Group_removeElement__SWIG_0(self, args);
31214       }
31215     }
31216   }
31217
31218 fail:
31219   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");
31220   return NULL;
31221 }
31222
31223
31224 SWIGINTERN PyObject *_wrap_Group_getElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31225   PyObject *resultobj = 0;
31226   Hex::Group *arg1 = (Hex::Group *) 0 ;
31227   int arg2 ;
31228   Hex::EltBase *result = 0 ;
31229   void *argp1 = 0 ;
31230   int res1 = 0 ;
31231   int val2 ;
31232   int ecode2 = 0 ;
31233   PyObject * obj0 = 0 ;
31234   PyObject * obj1 = 0 ;
31235
31236   if (!PyArg_ParseTuple(args,(char *)"OO:Group_getElement",&obj0,&obj1)) SWIG_fail;
31237   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
31238   if (!SWIG_IsOK(res1)) {
31239     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getElement" "', argument " "1"" of type '" "Hex::Group *""'");
31240   }
31241   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31242   ecode2 = SWIG_AsVal_int(obj1, &val2);
31243   if (!SWIG_IsOK(ecode2)) {
31244     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_getElement" "', argument " "2"" of type '" "int""'");
31245   }
31246   arg2 = static_cast< int >(val2);
31247   result = (Hex::EltBase *)(arg1)->getElement(arg2);
31248   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 |  0 );
31249   return resultobj;
31250 fail:
31251   return NULL;
31252 }
31253
31254
31255 SWIGINTERN PyObject *_wrap_new_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31256   PyObject *resultobj = 0;
31257   Hex::Document *arg1 = (Hex::Document *) 0 ;
31258   cpchar arg2 = (cpchar) 0 ;
31259   Hex::EnumGroup arg3 ;
31260   Hex::Group *result = 0 ;
31261   void *argp1 = 0 ;
31262   int res1 = 0 ;
31263   int res2 ;
31264   char *buf2 = 0 ;
31265   int alloc2 = 0 ;
31266   int val3 ;
31267   int ecode3 = 0 ;
31268   PyObject * obj0 = 0 ;
31269   PyObject * obj1 = 0 ;
31270   PyObject * obj2 = 0 ;
31271
31272   if (!PyArg_ParseTuple(args,(char *)"OOO:new_Group",&obj0,&obj1,&obj2)) SWIG_fail;
31273   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31274   if (!SWIG_IsOK(res1)) {
31275     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Group" "', argument " "1"" of type '" "Hex::Document *""'");
31276   }
31277   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31278   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
31279   if (!SWIG_IsOK(res2)) {
31280     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Group" "', argument " "2"" of type '" "cpchar""'");
31281   }
31282   arg2 = reinterpret_cast< cpchar >(buf2);
31283   ecode3 = SWIG_AsVal_int(obj2, &val3);
31284   if (!SWIG_IsOK(ecode3)) {
31285     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Group" "', argument " "3"" of type '" "Hex::EnumGroup""'");
31286   }
31287   arg3 = static_cast< Hex::EnumGroup >(val3);
31288   result = (Hex::Group *)new Hex::Group(arg1,arg2,arg3);
31289   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, SWIG_POINTER_NEW |  0 );
31290   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31291   return resultobj;
31292 fail:
31293   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31294   return NULL;
31295 }
31296
31297
31298 SWIGINTERN PyObject *_wrap_delete_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31299   PyObject *resultobj = 0;
31300   Hex::Group *arg1 = (Hex::Group *) 0 ;
31301   void *argp1 = 0 ;
31302   int res1 = 0 ;
31303   PyObject * obj0 = 0 ;
31304
31305   if (!PyArg_ParseTuple(args,(char *)"O:delete_Group",&obj0)) SWIG_fail;
31306   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, SWIG_POINTER_DISOWN |  0 );
31307   if (!SWIG_IsOK(res1)) {
31308     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Group" "', argument " "1"" of type '" "Hex::Group *""'");
31309   }
31310   arg1 = reinterpret_cast< Hex::Group * >(argp1);
31311   delete arg1;
31312
31313   resultobj = SWIG_Py_Void();
31314   return resultobj;
31315 fail:
31316   return NULL;
31317 }
31318
31319
31320 SWIGINTERN PyObject *Group_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31321   PyObject *obj;
31322   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
31323   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Group, SWIG_NewClientData(obj));
31324   return SWIG_Py_Void();
31325 }
31326
31327 static PyMethodDef SwigMethods[] = {
31328          { (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, NULL},
31329          { (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, NULL},
31330          { (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, NULL},
31331          { (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, NULL},
31332          { (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, NULL},
31333          { (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, NULL},
31334          { (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, NULL},
31335          { (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, NULL},
31336          { (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, NULL},
31337          { (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, NULL},
31338          { (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, NULL},
31339          { (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, NULL},
31340          { (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, NULL},
31341          { (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, NULL},
31342          { (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, NULL},
31343          { (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, NULL},
31344          { (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
31345          { (char *)"VectorHexas_iterator", _wrap_VectorHexas_iterator, METH_VARARGS, NULL},
31346          { (char *)"VectorHexas___nonzero__", _wrap_VectorHexas___nonzero__, METH_VARARGS, NULL},
31347          { (char *)"VectorHexas___len__", _wrap_VectorHexas___len__, METH_VARARGS, NULL},
31348          { (char *)"VectorHexas_pop", _wrap_VectorHexas_pop, METH_VARARGS, NULL},
31349          { (char *)"VectorHexas___getslice__", _wrap_VectorHexas___getslice__, METH_VARARGS, NULL},
31350          { (char *)"VectorHexas___setslice__", _wrap_VectorHexas___setslice__, METH_VARARGS, NULL},
31351          { (char *)"VectorHexas___delslice__", _wrap_VectorHexas___delslice__, METH_VARARGS, NULL},
31352          { (char *)"VectorHexas___delitem__", _wrap_VectorHexas___delitem__, METH_VARARGS, NULL},
31353          { (char *)"VectorHexas___getitem__", _wrap_VectorHexas___getitem__, METH_VARARGS, NULL},
31354          { (char *)"VectorHexas___setitem__", _wrap_VectorHexas___setitem__, METH_VARARGS, NULL},
31355          { (char *)"VectorHexas_append", _wrap_VectorHexas_append, METH_VARARGS, NULL},
31356          { (char *)"VectorHexas_empty", _wrap_VectorHexas_empty, METH_VARARGS, NULL},
31357          { (char *)"VectorHexas_size", _wrap_VectorHexas_size, METH_VARARGS, NULL},
31358          { (char *)"VectorHexas_clear", _wrap_VectorHexas_clear, METH_VARARGS, NULL},
31359          { (char *)"VectorHexas_swap", _wrap_VectorHexas_swap, METH_VARARGS, NULL},
31360          { (char *)"VectorHexas_get_allocator", _wrap_VectorHexas_get_allocator, METH_VARARGS, NULL},
31361          { (char *)"VectorHexas_begin", _wrap_VectorHexas_begin, METH_VARARGS, NULL},
31362          { (char *)"VectorHexas_end", _wrap_VectorHexas_end, METH_VARARGS, NULL},
31363          { (char *)"VectorHexas_rbegin", _wrap_VectorHexas_rbegin, METH_VARARGS, NULL},
31364          { (char *)"VectorHexas_rend", _wrap_VectorHexas_rend, METH_VARARGS, NULL},
31365          { (char *)"VectorHexas_pop_back", _wrap_VectorHexas_pop_back, METH_VARARGS, NULL},
31366          { (char *)"VectorHexas_erase", _wrap_VectorHexas_erase, METH_VARARGS, NULL},
31367          { (char *)"new_VectorHexas", _wrap_new_VectorHexas, METH_VARARGS, NULL},
31368          { (char *)"VectorHexas_push_back", _wrap_VectorHexas_push_back, METH_VARARGS, NULL},
31369          { (char *)"VectorHexas_front", _wrap_VectorHexas_front, METH_VARARGS, NULL},
31370          { (char *)"VectorHexas_back", _wrap_VectorHexas_back, METH_VARARGS, NULL},
31371          { (char *)"VectorHexas_assign", _wrap_VectorHexas_assign, METH_VARARGS, NULL},
31372          { (char *)"VectorHexas_resize", _wrap_VectorHexas_resize, METH_VARARGS, NULL},
31373          { (char *)"VectorHexas_insert", _wrap_VectorHexas_insert, METH_VARARGS, NULL},
31374          { (char *)"VectorHexas_reserve", _wrap_VectorHexas_reserve, METH_VARARGS, NULL},
31375          { (char *)"VectorHexas_capacity", _wrap_VectorHexas_capacity, METH_VARARGS, NULL},
31376          { (char *)"delete_VectorHexas", _wrap_delete_VectorHexas, METH_VARARGS, NULL},
31377          { (char *)"VectorHexas_swigregister", VectorHexas_swigregister, METH_VARARGS, NULL},
31378          { (char *)"VectorQuads_iterator", _wrap_VectorQuads_iterator, METH_VARARGS, NULL},
31379          { (char *)"VectorQuads___nonzero__", _wrap_VectorQuads___nonzero__, METH_VARARGS, NULL},
31380          { (char *)"VectorQuads___len__", _wrap_VectorQuads___len__, METH_VARARGS, NULL},
31381          { (char *)"VectorQuads_pop", _wrap_VectorQuads_pop, METH_VARARGS, NULL},
31382          { (char *)"VectorQuads___getslice__", _wrap_VectorQuads___getslice__, METH_VARARGS, NULL},
31383          { (char *)"VectorQuads___setslice__", _wrap_VectorQuads___setslice__, METH_VARARGS, NULL},
31384          { (char *)"VectorQuads___delslice__", _wrap_VectorQuads___delslice__, METH_VARARGS, NULL},
31385          { (char *)"VectorQuads___delitem__", _wrap_VectorQuads___delitem__, METH_VARARGS, NULL},
31386          { (char *)"VectorQuads___getitem__", _wrap_VectorQuads___getitem__, METH_VARARGS, NULL},
31387          { (char *)"VectorQuads___setitem__", _wrap_VectorQuads___setitem__, METH_VARARGS, NULL},
31388          { (char *)"VectorQuads_append", _wrap_VectorQuads_append, METH_VARARGS, NULL},
31389          { (char *)"VectorQuads_empty", _wrap_VectorQuads_empty, METH_VARARGS, NULL},
31390          { (char *)"VectorQuads_size", _wrap_VectorQuads_size, METH_VARARGS, NULL},
31391          { (char *)"VectorQuads_clear", _wrap_VectorQuads_clear, METH_VARARGS, NULL},
31392          { (char *)"VectorQuads_swap", _wrap_VectorQuads_swap, METH_VARARGS, NULL},
31393          { (char *)"VectorQuads_get_allocator", _wrap_VectorQuads_get_allocator, METH_VARARGS, NULL},
31394          { (char *)"VectorQuads_begin", _wrap_VectorQuads_begin, METH_VARARGS, NULL},
31395          { (char *)"VectorQuads_end", _wrap_VectorQuads_end, METH_VARARGS, NULL},
31396          { (char *)"VectorQuads_rbegin", _wrap_VectorQuads_rbegin, METH_VARARGS, NULL},
31397          { (char *)"VectorQuads_rend", _wrap_VectorQuads_rend, METH_VARARGS, NULL},
31398          { (char *)"VectorQuads_pop_back", _wrap_VectorQuads_pop_back, METH_VARARGS, NULL},
31399          { (char *)"VectorQuads_erase", _wrap_VectorQuads_erase, METH_VARARGS, NULL},
31400          { (char *)"new_VectorQuads", _wrap_new_VectorQuads, METH_VARARGS, NULL},
31401          { (char *)"VectorQuads_push_back", _wrap_VectorQuads_push_back, METH_VARARGS, NULL},
31402          { (char *)"VectorQuads_front", _wrap_VectorQuads_front, METH_VARARGS, NULL},
31403          { (char *)"VectorQuads_back", _wrap_VectorQuads_back, METH_VARARGS, NULL},
31404          { (char *)"VectorQuads_assign", _wrap_VectorQuads_assign, METH_VARARGS, NULL},
31405          { (char *)"VectorQuads_resize", _wrap_VectorQuads_resize, METH_VARARGS, NULL},
31406          { (char *)"VectorQuads_insert", _wrap_VectorQuads_insert, METH_VARARGS, NULL},
31407          { (char *)"VectorQuads_reserve", _wrap_VectorQuads_reserve, METH_VARARGS, NULL},
31408          { (char *)"VectorQuads_capacity", _wrap_VectorQuads_capacity, METH_VARARGS, NULL},
31409          { (char *)"delete_VectorQuads", _wrap_delete_VectorQuads, METH_VARARGS, NULL},
31410          { (char *)"VectorQuads_swigregister", VectorQuads_swigregister, METH_VARARGS, NULL},
31411          { (char *)"VectorEdges_iterator", _wrap_VectorEdges_iterator, METH_VARARGS, NULL},
31412          { (char *)"VectorEdges___nonzero__", _wrap_VectorEdges___nonzero__, METH_VARARGS, NULL},
31413          { (char *)"VectorEdges___len__", _wrap_VectorEdges___len__, METH_VARARGS, NULL},
31414          { (char *)"VectorEdges_pop", _wrap_VectorEdges_pop, METH_VARARGS, NULL},
31415          { (char *)"VectorEdges___getslice__", _wrap_VectorEdges___getslice__, METH_VARARGS, NULL},
31416          { (char *)"VectorEdges___setslice__", _wrap_VectorEdges___setslice__, METH_VARARGS, NULL},
31417          { (char *)"VectorEdges___delslice__", _wrap_VectorEdges___delslice__, METH_VARARGS, NULL},
31418          { (char *)"VectorEdges___delitem__", _wrap_VectorEdges___delitem__, METH_VARARGS, NULL},
31419          { (char *)"VectorEdges___getitem__", _wrap_VectorEdges___getitem__, METH_VARARGS, NULL},
31420          { (char *)"VectorEdges___setitem__", _wrap_VectorEdges___setitem__, METH_VARARGS, NULL},
31421          { (char *)"VectorEdges_append", _wrap_VectorEdges_append, METH_VARARGS, NULL},
31422          { (char *)"VectorEdges_empty", _wrap_VectorEdges_empty, METH_VARARGS, NULL},
31423          { (char *)"VectorEdges_size", _wrap_VectorEdges_size, METH_VARARGS, NULL},
31424          { (char *)"VectorEdges_clear", _wrap_VectorEdges_clear, METH_VARARGS, NULL},
31425          { (char *)"VectorEdges_swap", _wrap_VectorEdges_swap, METH_VARARGS, NULL},
31426          { (char *)"VectorEdges_get_allocator", _wrap_VectorEdges_get_allocator, METH_VARARGS, NULL},
31427          { (char *)"VectorEdges_begin", _wrap_VectorEdges_begin, METH_VARARGS, NULL},
31428          { (char *)"VectorEdges_end", _wrap_VectorEdges_end, METH_VARARGS, NULL},
31429          { (char *)"VectorEdges_rbegin", _wrap_VectorEdges_rbegin, METH_VARARGS, NULL},
31430          { (char *)"VectorEdges_rend", _wrap_VectorEdges_rend, METH_VARARGS, NULL},
31431          { (char *)"VectorEdges_pop_back", _wrap_VectorEdges_pop_back, METH_VARARGS, NULL},
31432          { (char *)"VectorEdges_erase", _wrap_VectorEdges_erase, METH_VARARGS, NULL},
31433          { (char *)"new_VectorEdges", _wrap_new_VectorEdges, METH_VARARGS, NULL},
31434          { (char *)"VectorEdges_push_back", _wrap_VectorEdges_push_back, METH_VARARGS, NULL},
31435          { (char *)"VectorEdges_front", _wrap_VectorEdges_front, METH_VARARGS, NULL},
31436          { (char *)"VectorEdges_back", _wrap_VectorEdges_back, METH_VARARGS, NULL},
31437          { (char *)"VectorEdges_assign", _wrap_VectorEdges_assign, METH_VARARGS, NULL},
31438          { (char *)"VectorEdges_resize", _wrap_VectorEdges_resize, METH_VARARGS, NULL},
31439          { (char *)"VectorEdges_insert", _wrap_VectorEdges_insert, METH_VARARGS, NULL},
31440          { (char *)"VectorEdges_reserve", _wrap_VectorEdges_reserve, METH_VARARGS, NULL},
31441          { (char *)"VectorEdges_capacity", _wrap_VectorEdges_capacity, METH_VARARGS, NULL},
31442          { (char *)"delete_VectorEdges", _wrap_delete_VectorEdges, METH_VARARGS, NULL},
31443          { (char *)"VectorEdges_swigregister", VectorEdges_swigregister, METH_VARARGS, NULL},
31444          { (char *)"VectorVertices_iterator", _wrap_VectorVertices_iterator, METH_VARARGS, NULL},
31445          { (char *)"VectorVertices___nonzero__", _wrap_VectorVertices___nonzero__, METH_VARARGS, NULL},
31446          { (char *)"VectorVertices___len__", _wrap_VectorVertices___len__, METH_VARARGS, NULL},
31447          { (char *)"VectorVertices_pop", _wrap_VectorVertices_pop, METH_VARARGS, NULL},
31448          { (char *)"VectorVertices___getslice__", _wrap_VectorVertices___getslice__, METH_VARARGS, NULL},
31449          { (char *)"VectorVertices___setslice__", _wrap_VectorVertices___setslice__, METH_VARARGS, NULL},
31450          { (char *)"VectorVertices___delslice__", _wrap_VectorVertices___delslice__, METH_VARARGS, NULL},
31451          { (char *)"VectorVertices___delitem__", _wrap_VectorVertices___delitem__, METH_VARARGS, NULL},
31452          { (char *)"VectorVertices___getitem__", _wrap_VectorVertices___getitem__, METH_VARARGS, NULL},
31453          { (char *)"VectorVertices___setitem__", _wrap_VectorVertices___setitem__, METH_VARARGS, NULL},
31454          { (char *)"VectorVertices_append", _wrap_VectorVertices_append, METH_VARARGS, NULL},
31455          { (char *)"VectorVertices_empty", _wrap_VectorVertices_empty, METH_VARARGS, NULL},
31456          { (char *)"VectorVertices_size", _wrap_VectorVertices_size, METH_VARARGS, NULL},
31457          { (char *)"VectorVertices_clear", _wrap_VectorVertices_clear, METH_VARARGS, NULL},
31458          { (char *)"VectorVertices_swap", _wrap_VectorVertices_swap, METH_VARARGS, NULL},
31459          { (char *)"VectorVertices_get_allocator", _wrap_VectorVertices_get_allocator, METH_VARARGS, NULL},
31460          { (char *)"VectorVertices_begin", _wrap_VectorVertices_begin, METH_VARARGS, NULL},
31461          { (char *)"VectorVertices_end", _wrap_VectorVertices_end, METH_VARARGS, NULL},
31462          { (char *)"VectorVertices_rbegin", _wrap_VectorVertices_rbegin, METH_VARARGS, NULL},
31463          { (char *)"VectorVertices_rend", _wrap_VectorVertices_rend, METH_VARARGS, NULL},
31464          { (char *)"VectorVertices_pop_back", _wrap_VectorVertices_pop_back, METH_VARARGS, NULL},
31465          { (char *)"VectorVertices_erase", _wrap_VectorVertices_erase, METH_VARARGS, NULL},
31466          { (char *)"new_VectorVertices", _wrap_new_VectorVertices, METH_VARARGS, NULL},
31467          { (char *)"VectorVertices_push_back", _wrap_VectorVertices_push_back, METH_VARARGS, NULL},
31468          { (char *)"VectorVertices_front", _wrap_VectorVertices_front, METH_VARARGS, NULL},
31469          { (char *)"VectorVertices_back", _wrap_VectorVertices_back, METH_VARARGS, NULL},
31470          { (char *)"VectorVertices_assign", _wrap_VectorVertices_assign, METH_VARARGS, NULL},
31471          { (char *)"VectorVertices_resize", _wrap_VectorVertices_resize, METH_VARARGS, NULL},
31472          { (char *)"VectorVertices_insert", _wrap_VectorVertices_insert, METH_VARARGS, NULL},
31473          { (char *)"VectorVertices_reserve", _wrap_VectorVertices_reserve, METH_VARARGS, NULL},
31474          { (char *)"VectorVertices_capacity", _wrap_VectorVertices_capacity, METH_VARARGS, NULL},
31475          { (char *)"delete_VectorVertices", _wrap_delete_VectorVertices, METH_VARARGS, NULL},
31476          { (char *)"VectorVertices_swigregister", VectorVertices_swigregister, METH_VARARGS, NULL},
31477          { (char *)"VectorShapes_iterator", _wrap_VectorShapes_iterator, METH_VARARGS, NULL},
31478          { (char *)"VectorShapes___nonzero__", _wrap_VectorShapes___nonzero__, METH_VARARGS, NULL},
31479          { (char *)"VectorShapes___len__", _wrap_VectorShapes___len__, METH_VARARGS, NULL},
31480          { (char *)"VectorShapes_pop", _wrap_VectorShapes_pop, METH_VARARGS, NULL},
31481          { (char *)"VectorShapes___getslice__", _wrap_VectorShapes___getslice__, METH_VARARGS, NULL},
31482          { (char *)"VectorShapes___setslice__", _wrap_VectorShapes___setslice__, METH_VARARGS, NULL},
31483          { (char *)"VectorShapes___delslice__", _wrap_VectorShapes___delslice__, METH_VARARGS, NULL},
31484          { (char *)"VectorShapes___delitem__", _wrap_VectorShapes___delitem__, METH_VARARGS, NULL},
31485          { (char *)"VectorShapes___getitem__", _wrap_VectorShapes___getitem__, METH_VARARGS, NULL},
31486          { (char *)"VectorShapes___setitem__", _wrap_VectorShapes___setitem__, METH_VARARGS, NULL},
31487          { (char *)"VectorShapes_append", _wrap_VectorShapes_append, METH_VARARGS, NULL},
31488          { (char *)"VectorShapes_empty", _wrap_VectorShapes_empty, METH_VARARGS, NULL},
31489          { (char *)"VectorShapes_size", _wrap_VectorShapes_size, METH_VARARGS, NULL},
31490          { (char *)"VectorShapes_clear", _wrap_VectorShapes_clear, METH_VARARGS, NULL},
31491          { (char *)"VectorShapes_swap", _wrap_VectorShapes_swap, METH_VARARGS, NULL},
31492          { (char *)"VectorShapes_get_allocator", _wrap_VectorShapes_get_allocator, METH_VARARGS, NULL},
31493          { (char *)"VectorShapes_begin", _wrap_VectorShapes_begin, METH_VARARGS, NULL},
31494          { (char *)"VectorShapes_end", _wrap_VectorShapes_end, METH_VARARGS, NULL},
31495          { (char *)"VectorShapes_rbegin", _wrap_VectorShapes_rbegin, METH_VARARGS, NULL},
31496          { (char *)"VectorShapes_rend", _wrap_VectorShapes_rend, METH_VARARGS, NULL},
31497          { (char *)"VectorShapes_pop_back", _wrap_VectorShapes_pop_back, METH_VARARGS, NULL},
31498          { (char *)"VectorShapes_erase", _wrap_VectorShapes_erase, METH_VARARGS, NULL},
31499          { (char *)"new_VectorShapes", _wrap_new_VectorShapes, METH_VARARGS, NULL},
31500          { (char *)"VectorShapes_push_back", _wrap_VectorShapes_push_back, METH_VARARGS, NULL},
31501          { (char *)"VectorShapes_front", _wrap_VectorShapes_front, METH_VARARGS, NULL},
31502          { (char *)"VectorShapes_back", _wrap_VectorShapes_back, METH_VARARGS, NULL},
31503          { (char *)"VectorShapes_assign", _wrap_VectorShapes_assign, METH_VARARGS, NULL},
31504          { (char *)"VectorShapes_resize", _wrap_VectorShapes_resize, METH_VARARGS, NULL},
31505          { (char *)"VectorShapes_insert", _wrap_VectorShapes_insert, METH_VARARGS, NULL},
31506          { (char *)"VectorShapes_reserve", _wrap_VectorShapes_reserve, METH_VARARGS, NULL},
31507          { (char *)"VectorShapes_capacity", _wrap_VectorShapes_capacity, METH_VARARGS, NULL},
31508          { (char *)"delete_VectorShapes", _wrap_delete_VectorShapes, METH_VARARGS, NULL},
31509          { (char *)"VectorShapes_swigregister", VectorShapes_swigregister, METH_VARARGS, NULL},
31510          { (char *)"VectorReal_iterator", _wrap_VectorReal_iterator, METH_VARARGS, NULL},
31511          { (char *)"VectorReal___nonzero__", _wrap_VectorReal___nonzero__, METH_VARARGS, NULL},
31512          { (char *)"VectorReal___len__", _wrap_VectorReal___len__, METH_VARARGS, NULL},
31513          { (char *)"VectorReal_pop", _wrap_VectorReal_pop, METH_VARARGS, NULL},
31514          { (char *)"VectorReal___getslice__", _wrap_VectorReal___getslice__, METH_VARARGS, NULL},
31515          { (char *)"VectorReal___setslice__", _wrap_VectorReal___setslice__, METH_VARARGS, NULL},
31516          { (char *)"VectorReal___delslice__", _wrap_VectorReal___delslice__, METH_VARARGS, NULL},
31517          { (char *)"VectorReal___delitem__", _wrap_VectorReal___delitem__, METH_VARARGS, NULL},
31518          { (char *)"VectorReal___getitem__", _wrap_VectorReal___getitem__, METH_VARARGS, NULL},
31519          { (char *)"VectorReal___setitem__", _wrap_VectorReal___setitem__, METH_VARARGS, NULL},
31520          { (char *)"VectorReal_append", _wrap_VectorReal_append, METH_VARARGS, NULL},
31521          { (char *)"VectorReal_empty", _wrap_VectorReal_empty, METH_VARARGS, NULL},
31522          { (char *)"VectorReal_size", _wrap_VectorReal_size, METH_VARARGS, NULL},
31523          { (char *)"VectorReal_clear", _wrap_VectorReal_clear, METH_VARARGS, NULL},
31524          { (char *)"VectorReal_swap", _wrap_VectorReal_swap, METH_VARARGS, NULL},
31525          { (char *)"VectorReal_get_allocator", _wrap_VectorReal_get_allocator, METH_VARARGS, NULL},
31526          { (char *)"VectorReal_begin", _wrap_VectorReal_begin, METH_VARARGS, NULL},
31527          { (char *)"VectorReal_end", _wrap_VectorReal_end, METH_VARARGS, NULL},
31528          { (char *)"VectorReal_rbegin", _wrap_VectorReal_rbegin, METH_VARARGS, NULL},
31529          { (char *)"VectorReal_rend", _wrap_VectorReal_rend, METH_VARARGS, NULL},
31530          { (char *)"VectorReal_pop_back", _wrap_VectorReal_pop_back, METH_VARARGS, NULL},
31531          { (char *)"VectorReal_erase", _wrap_VectorReal_erase, METH_VARARGS, NULL},
31532          { (char *)"new_VectorReal", _wrap_new_VectorReal, METH_VARARGS, NULL},
31533          { (char *)"VectorReal_push_back", _wrap_VectorReal_push_back, METH_VARARGS, NULL},
31534          { (char *)"VectorReal_front", _wrap_VectorReal_front, METH_VARARGS, NULL},
31535          { (char *)"VectorReal_back", _wrap_VectorReal_back, METH_VARARGS, NULL},
31536          { (char *)"VectorReal_assign", _wrap_VectorReal_assign, METH_VARARGS, NULL},
31537          { (char *)"VectorReal_resize", _wrap_VectorReal_resize, METH_VARARGS, NULL},
31538          { (char *)"VectorReal_insert", _wrap_VectorReal_insert, METH_VARARGS, NULL},
31539          { (char *)"VectorReal_reserve", _wrap_VectorReal_reserve, METH_VARARGS, NULL},
31540          { (char *)"VectorReal_capacity", _wrap_VectorReal_capacity, METH_VARARGS, NULL},
31541          { (char *)"delete_VectorReal", _wrap_delete_VectorReal, METH_VARARGS, NULL},
31542          { (char *)"VectorReal_swigregister", VectorReal_swigregister, METH_VARARGS, NULL},
31543          { (char *)"VectorInt_iterator", _wrap_VectorInt_iterator, METH_VARARGS, NULL},
31544          { (char *)"VectorInt___nonzero__", _wrap_VectorInt___nonzero__, METH_VARARGS, NULL},
31545          { (char *)"VectorInt___len__", _wrap_VectorInt___len__, METH_VARARGS, NULL},
31546          { (char *)"VectorInt_pop", _wrap_VectorInt_pop, METH_VARARGS, NULL},
31547          { (char *)"VectorInt___getslice__", _wrap_VectorInt___getslice__, METH_VARARGS, NULL},
31548          { (char *)"VectorInt___setslice__", _wrap_VectorInt___setslice__, METH_VARARGS, NULL},
31549          { (char *)"VectorInt___delslice__", _wrap_VectorInt___delslice__, METH_VARARGS, NULL},
31550          { (char *)"VectorInt___delitem__", _wrap_VectorInt___delitem__, METH_VARARGS, NULL},
31551          { (char *)"VectorInt___getitem__", _wrap_VectorInt___getitem__, METH_VARARGS, NULL},
31552          { (char *)"VectorInt___setitem__", _wrap_VectorInt___setitem__, METH_VARARGS, NULL},
31553          { (char *)"VectorInt_append", _wrap_VectorInt_append, METH_VARARGS, NULL},
31554          { (char *)"VectorInt_empty", _wrap_VectorInt_empty, METH_VARARGS, NULL},
31555          { (char *)"VectorInt_size", _wrap_VectorInt_size, METH_VARARGS, NULL},
31556          { (char *)"VectorInt_clear", _wrap_VectorInt_clear, METH_VARARGS, NULL},
31557          { (char *)"VectorInt_swap", _wrap_VectorInt_swap, METH_VARARGS, NULL},
31558          { (char *)"VectorInt_get_allocator", _wrap_VectorInt_get_allocator, METH_VARARGS, NULL},
31559          { (char *)"VectorInt_begin", _wrap_VectorInt_begin, METH_VARARGS, NULL},
31560          { (char *)"VectorInt_end", _wrap_VectorInt_end, METH_VARARGS, NULL},
31561          { (char *)"VectorInt_rbegin", _wrap_VectorInt_rbegin, METH_VARARGS, NULL},
31562          { (char *)"VectorInt_rend", _wrap_VectorInt_rend, METH_VARARGS, NULL},
31563          { (char *)"VectorInt_pop_back", _wrap_VectorInt_pop_back, METH_VARARGS, NULL},
31564          { (char *)"VectorInt_erase", _wrap_VectorInt_erase, METH_VARARGS, NULL},
31565          { (char *)"new_VectorInt", _wrap_new_VectorInt, METH_VARARGS, NULL},
31566          { (char *)"VectorInt_push_back", _wrap_VectorInt_push_back, METH_VARARGS, NULL},
31567          { (char *)"VectorInt_front", _wrap_VectorInt_front, METH_VARARGS, NULL},
31568          { (char *)"VectorInt_back", _wrap_VectorInt_back, METH_VARARGS, NULL},
31569          { (char *)"VectorInt_assign", _wrap_VectorInt_assign, METH_VARARGS, NULL},
31570          { (char *)"VectorInt_resize", _wrap_VectorInt_resize, METH_VARARGS, NULL},
31571          { (char *)"VectorInt_insert", _wrap_VectorInt_insert, METH_VARARGS, NULL},
31572          { (char *)"VectorInt_reserve", _wrap_VectorInt_reserve, METH_VARARGS, NULL},
31573          { (char *)"VectorInt_capacity", _wrap_VectorInt_capacity, METH_VARARGS, NULL},
31574          { (char *)"delete_VectorInt", _wrap_delete_VectorInt, METH_VARARGS, NULL},
31575          { (char *)"VectorInt_swigregister", VectorInt_swigregister, METH_VARARGS, NULL},
31576          { (char *)"get_temp_name", _wrap_get_temp_name, METH_VARARGS, NULL},
31577          { (char *)"fatal_error", _wrap_fatal_error, METH_VARARGS, NULL},
31578          { (char *)"prod_scalaire", _wrap_prod_scalaire, METH_VARARGS, NULL},
31579          { (char *)"prod_vectoriel", _wrap_prod_vectoriel, METH_VARARGS, NULL},
31580          { (char *)"prod_mixte", _wrap_prod_mixte, METH_VARARGS, NULL},
31581          { (char *)"deg2radians", _wrap_deg2radians, METH_VARARGS, NULL},
31582          { (char *)"rad2degres", _wrap_rad2degres, METH_VARARGS, NULL},
31583          { (char *)"calc_norme", _wrap_calc_norme, METH_VARARGS, NULL},
31584          { (char *)"calc_distance", _wrap_calc_distance, METH_VARARGS, NULL},
31585          { (char *)"calc_d2", _wrap_calc_d2, METH_VARARGS, NULL},
31586          { (char *)"calc_vecteur", _wrap_calc_vecteur, METH_VARARGS, NULL},
31587          { (char *)"copy_vecteur", _wrap_copy_vecteur, METH_VARARGS, NULL},
31588          { (char *)"calc_milieu", _wrap_calc_milieu, METH_VARARGS, NULL},
31589          { (char *)"normer_vecteur", _wrap_normer_vecteur, METH_VARARGS, NULL},
31590          { (char *)"carre", _wrap_carre, METH_VARARGS, NULL},
31591          { (char *)"same_coords", _wrap_same_coords, METH_VARARGS, NULL},
31592          { (char *)"requals", _wrap_requals, METH_VARARGS, NULL},
31593          { (char *)"on_debug", _wrap_on_debug, METH_VARARGS, NULL},
31594          { (char *)"in_test", _wrap_in_test, METH_VARARGS, NULL},
31595          { (char *)"niv_debug", _wrap_niv_debug, METH_VARARGS, NULL},
31596          { (char *)"set_minus", _wrap_set_minus, METH_VARARGS, NULL},
31597          { (char *)"special_option", _wrap_special_option, METH_VARARGS, NULL},
31598          { (char *)"set_special_option", _wrap_set_special_option, METH_VARARGS, NULL},
31599          { (char *)"sizeof_file", _wrap_sizeof_file, METH_VARARGS, NULL},
31600          { (char *)"read_file", _wrap_read_file, METH_VARARGS, NULL},
31601          { (char *)"get_time", _wrap_get_time, METH_VARARGS, NULL},
31602          { (char *)"make_basename", _wrap_make_basename, METH_VARARGS, NULL},
31603          { (char *)"EltBase_countHexa", _wrap_EltBase_countHexa, METH_VARARGS, NULL},
31604          { (char *)"EltBase_countQuad", _wrap_EltBase_countQuad, METH_VARARGS, NULL},
31605          { (char *)"EltBase_countEdge", _wrap_EltBase_countEdge, METH_VARARGS, NULL},
31606          { (char *)"EltBase_countVertex", _wrap_EltBase_countVertex, METH_VARARGS, NULL},
31607          { (char *)"EltBase_setError", _wrap_EltBase_setError, METH_VARARGS, NULL},
31608          { (char *)"EltBase_getError", _wrap_EltBase_getError, METH_VARARGS, NULL},
31609          { (char *)"EltBase_isValid", _wrap_EltBase_isValid, METH_VARARGS, NULL},
31610          { (char *)"EltBase_isBad", _wrap_EltBase_isBad, METH_VARARGS, NULL},
31611          { (char *)"EltBase_duplicate", _wrap_EltBase_duplicate, METH_VARARGS, NULL},
31612          { (char *)"EltBase_clearAssociation", _wrap_EltBase_clearAssociation, METH_VARARGS, NULL},
31613          { (char *)"EltBase_replaceEdge", _wrap_EltBase_replaceEdge, METH_VARARGS, NULL},
31614          { (char *)"EltBase_replaceVertex", _wrap_EltBase_replaceVertex, METH_VARARGS, NULL},
31615          { (char *)"new_EltBase", _wrap_new_EltBase, METH_VARARGS, NULL},
31616          { (char *)"delete_EltBase", _wrap_delete_EltBase, METH_VARARGS, NULL},
31617          { (char *)"EltBase_remove", _wrap_EltBase_remove, METH_VARARGS, NULL},
31618          { (char *)"EltBase_suppress", _wrap_EltBase_suppress, METH_VARARGS, NULL},
31619          { (char *)"EltBase_dump", _wrap_EltBase_dump, METH_VARARGS, NULL},
31620          { (char *)"EltBase_saveXml", _wrap_EltBase_saveXml, METH_VARARGS, NULL},
31621          { (char *)"EltBase_majReferences", _wrap_EltBase_majReferences, METH_VARARGS, NULL},
31622          { (char *)"EltBase_makeVarName", _wrap_EltBase_makeVarName, METH_VARARGS, NULL},
31623          { (char *)"EltBase_makeName", _wrap_EltBase_makeName, METH_VARARGS, NULL},
31624          { (char *)"EltBase_next", _wrap_EltBase_next, METH_VARARGS, NULL},
31625          { (char *)"EltBase_setNext", _wrap_EltBase_setNext, METH_VARARGS, NULL},
31626          { (char *)"EltBase_getId", _wrap_EltBase_getId, METH_VARARGS, NULL},
31627          { (char *)"EltBase_setId", _wrap_EltBase_setId, METH_VARARGS, NULL},
31628          { (char *)"EltBase_dad", _wrap_EltBase_dad, METH_VARARGS, NULL},
31629          { (char *)"EltBase_getType", _wrap_EltBase_getType, METH_VARARGS, NULL},
31630          { (char *)"EltBase_isHere", _wrap_EltBase_isHere, METH_VARARGS, NULL},
31631          { (char *)"EltBase_isDeleted", _wrap_EltBase_isDeleted, METH_VARARGS, NULL},
31632          { (char *)"EltBase_razReferences", _wrap_EltBase_razReferences, METH_VARARGS, NULL},
31633          { (char *)"EltBase_addParent", _wrap_EltBase_addParent, METH_VARARGS, NULL},
31634          { (char *)"EltBase_getNbrParents", _wrap_EltBase_getNbrParents, METH_VARARGS, NULL},
31635          { (char *)"EltBase_hasParents", _wrap_EltBase_hasParents, METH_VARARGS, NULL},
31636          { (char *)"EltBase_getFather", _wrap_EltBase_getFather, METH_VARARGS, NULL},
31637          { (char *)"EltBase_getMark", _wrap_EltBase_getMark, METH_VARARGS, NULL},
31638          { (char *)"EltBase_setMark", _wrap_EltBase_setMark, METH_VARARGS, NULL},
31639          { (char *)"EltBase_printName", _wrap_EltBase_printName, METH_VARARGS, NULL},
31640          { (char *)"EltBase_dumpRef", _wrap_EltBase_dumpRef, METH_VARARGS, NULL},
31641          { (char *)"EltBase_getName", _wrap_EltBase_getName, METH_VARARGS, NULL},
31642          { (char *)"EltBase_setName", _wrap_EltBase_setName, METH_VARARGS, NULL},
31643          { (char *)"EltBase_debug", _wrap_EltBase_debug, METH_VARARGS, NULL},
31644          { (char *)"EltBase_isAssociated", _wrap_EltBase_isAssociated, METH_VARARGS, NULL},
31645          { (char *)"EltBase_getNextName", _wrap_EltBase_getNextName, METH_VARARGS, NULL},
31646          { (char *)"EltBase_swigregister", EltBase_swigregister, METH_VARARGS, NULL},
31647          { (char *)"Vertex_getX", _wrap_Vertex_getX, METH_VARARGS, NULL},
31648          { (char *)"Vertex_getY", _wrap_Vertex_getY, METH_VARARGS, NULL},
31649          { (char *)"Vertex_getZ", _wrap_Vertex_getZ, METH_VARARGS, NULL},
31650          { (char *)"Vertex_setX", _wrap_Vertex_setX, METH_VARARGS, NULL},
31651          { (char *)"Vertex_setY", _wrap_Vertex_setY, METH_VARARGS, NULL},
31652          { (char *)"Vertex_setZ", _wrap_Vertex_setZ, METH_VARARGS, NULL},
31653          { (char *)"Vertex_getAssoX", _wrap_Vertex_getAssoX, METH_VARARGS, NULL},
31654          { (char *)"Vertex_getAssoY", _wrap_Vertex_getAssoY, METH_VARARGS, NULL},
31655          { (char *)"Vertex_getAssoZ", _wrap_Vertex_getAssoZ, METH_VARARGS, NULL},
31656          { (char *)"Vertex_setAssociation", _wrap_Vertex_setAssociation, METH_VARARGS, NULL},
31657          { (char *)"Vertex_clearAssociation", _wrap_Vertex_clearAssociation, METH_VARARGS, NULL},
31658          { (char *)"Vertex_setColor", _wrap_Vertex_setColor, METH_VARARGS, NULL},
31659          { (char *)"new_Vertex", _wrap_new_Vertex, METH_VARARGS, NULL},
31660          { (char *)"delete_Vertex", _wrap_delete_Vertex, METH_VARARGS, NULL},
31661          { (char *)"Vertex_swigregister", Vertex_swigregister, METH_VARARGS, NULL},
31662          { (char *)"Edge_getVertex", _wrap_Edge_getVertex, METH_VARARGS, NULL},
31663          { (char *)"Edge_addAssociation", _wrap_Edge_addAssociation, METH_VARARGS, NULL},
31664          { (char *)"Edge_setAssociation", _wrap_Edge_setAssociation, METH_VARARGS, NULL},
31665          { (char *)"Edge_findAssociation", _wrap_Edge_findAssociation, METH_VARARGS, NULL},
31666          { (char *)"Edge_clearAssociation", _wrap_Edge_clearAssociation, METH_VARARGS, NULL},
31667          { (char *)"Edge_setColor", _wrap_Edge_setColor, METH_VARARGS, NULL},
31668          { (char *)"Edge_getWay", _wrap_Edge_getWay, METH_VARARGS, NULL},
31669          { (char *)"Edge_getLength", _wrap_Edge_getLength, METH_VARARGS, NULL},
31670          { (char *)"new_Edge", _wrap_new_Edge, METH_VARARGS, NULL},
31671          { (char *)"delete_Edge", _wrap_delete_Edge, METH_VARARGS, NULL},
31672          { (char *)"Edge_swigregister", Edge_swigregister, METH_VARARGS, NULL},
31673          { (char *)"Quad_getEdge", _wrap_Quad_getEdge, METH_VARARGS, NULL},
31674          { (char *)"Quad_getVertex", _wrap_Quad_getVertex, METH_VARARGS, NULL},
31675          { (char *)"Quad_addAssociation", _wrap_Quad_addAssociation, METH_VARARGS, NULL},
31676          { (char *)"Quad_clearAssociation", _wrap_Quad_clearAssociation, METH_VARARGS, NULL},
31677          { (char *)"Quad_setColor", _wrap_Quad_setColor, METH_VARARGS, NULL},
31678          { (char *)"Quad_nearestVertex", _wrap_Quad_nearestVertex, METH_VARARGS, NULL},
31679          { (char *)"Quad_getCenter", _wrap_Quad_getCenter, METH_VARARGS, NULL},
31680          { (char *)"new_Quad", _wrap_new_Quad, METH_VARARGS, NULL},
31681          { (char *)"delete_Quad", _wrap_delete_Quad, METH_VARARGS, NULL},
31682          { (char *)"Quad_swigregister", Quad_swigregister, METH_VARARGS, NULL},
31683          { (char *)"Hexa_getQuad", _wrap_Hexa_getQuad, METH_VARARGS, NULL},
31684          { (char *)"Hexa_getEdge", _wrap_Hexa_getEdge, METH_VARARGS, NULL},
31685          { (char *)"Hexa_getVertex", _wrap_Hexa_getVertex, METH_VARARGS, NULL},
31686          { (char *)"Hexa_setColor", _wrap_Hexa_setColor, METH_VARARGS, NULL},
31687          { (char *)"new_Hexa", _wrap_new_Hexa, METH_VARARGS, NULL},
31688          { (char *)"delete_Hexa", _wrap_delete_Hexa, METH_VARARGS, NULL},
31689          { (char *)"Hexa_swigregister", Hexa_swigregister, METH_VARARGS, NULL},
31690          { (char *)"Vector_getDx", _wrap_Vector_getDx, METH_VARARGS, NULL},
31691          { (char *)"Vector_getDy", _wrap_Vector_getDy, METH_VARARGS, NULL},
31692          { (char *)"Vector_getDz", _wrap_Vector_getDz, METH_VARARGS, NULL},
31693          { (char *)"Vector_getNorm", _wrap_Vector_getNorm, METH_VARARGS, NULL},
31694          { (char *)"Vector_getAngleX", _wrap_Vector_getAngleX, METH_VARARGS, NULL},
31695          { (char *)"new_Vector", _wrap_new_Vector, METH_VARARGS, NULL},
31696          { (char *)"delete_Vector", _wrap_delete_Vector, METH_VARARGS, NULL},
31697          { (char *)"Vector_swigregister", Vector_swigregister, METH_VARARGS, NULL},
31698          { (char *)"new_Document", _wrap_new_Document, METH_VARARGS, NULL},
31699          { (char *)"Document_dump", _wrap_Document_dump, METH_VARARGS, NULL},
31700          { (char *)"Document_setName", _wrap_Document_setName, METH_VARARGS, NULL},
31701          { (char *)"Document_setLevel", _wrap_Document_setLevel, METH_VARARGS, NULL},
31702          { (char *)"Document_save", _wrap_Document_save, METH_VARARGS, NULL},
31703          { (char *)"Document_saveVtk", _wrap_Document_saveVtk, METH_VARARGS, NULL},
31704          { (char *)"Document_purge", _wrap_Document_purge, METH_VARARGS, NULL},
31705          { (char *)"Document_setTolerance", _wrap_Document_setTolerance, METH_VARARGS, NULL},
31706          { (char *)"Document_getTolerance", _wrap_Document_getTolerance, METH_VARARGS, NULL},
31707          { (char *)"Document_addVertex", _wrap_Document_addVertex, METH_VARARGS, NULL},
31708          { (char *)"Document_addEdge", _wrap_Document_addEdge, METH_VARARGS, NULL},
31709          { (char *)"Document_addEdgeVector", _wrap_Document_addEdgeVector, METH_VARARGS, NULL},
31710          { (char *)"Document_addQuad", _wrap_Document_addQuad, METH_VARARGS, NULL},
31711          { (char *)"Document_addQuadVertices", _wrap_Document_addQuadVertices, METH_VARARGS, NULL},
31712          { (char *)"Document_addHexa", _wrap_Document_addHexa, METH_VARARGS, NULL},
31713          { (char *)"Document_addHexaVertices", _wrap_Document_addHexaVertices, METH_VARARGS, NULL},
31714          { (char *)"Document_addHexa2Quads", _wrap_Document_addHexa2Quads, METH_VARARGS, NULL},
31715          { (char *)"Document_addHexa3Quads", _wrap_Document_addHexa3Quads, METH_VARARGS, NULL},
31716          { (char *)"Document_addHexa4Quads", _wrap_Document_addHexa4Quads, METH_VARARGS, NULL},
31717          { (char *)"Document_addHexa5Quads", _wrap_Document_addHexa5Quads, METH_VARARGS, NULL},
31718          { (char *)"Document_addVector", _wrap_Document_addVector, METH_VARARGS, NULL},
31719          { (char *)"Document_addVectorVertices", _wrap_Document_addVectorVertices, METH_VARARGS, NULL},
31720          { (char *)"Document_addLaws", _wrap_Document_addLaws, METH_VARARGS, NULL},
31721          { (char *)"Document_addHexaGroup", _wrap_Document_addHexaGroup, METH_VARARGS, NULL},
31722          { (char *)"Document_addQuadGroup", _wrap_Document_addQuadGroup, METH_VARARGS, NULL},
31723          { (char *)"Document_addQuadNodeGroup", _wrap_Document_addQuadNodeGroup, METH_VARARGS, NULL},
31724          { (char *)"Document_addHexaNodeGroup", _wrap_Document_addHexaNodeGroup, METH_VARARGS, NULL},
31725          { (char *)"Document_addEdgeGroup", _wrap_Document_addEdgeGroup, METH_VARARGS, NULL},
31726          { (char *)"Document_addEdgeNodeGroup", _wrap_Document_addEdgeNodeGroup, METH_VARARGS, NULL},
31727          { (char *)"Document_addVertexNodeGroup", _wrap_Document_addVertexNodeGroup, METH_VARARGS, NULL},
31728          { (char *)"Document_makeTranslation", _wrap_Document_makeTranslation, METH_VARARGS, NULL},
31729          { (char *)"Document_makeScale", _wrap_Document_makeScale, METH_VARARGS, NULL},
31730          { (char *)"Document_makeRotation", _wrap_Document_makeRotation, METH_VARARGS, NULL},
31731          { (char *)"Document_makeSymmetryPoint", _wrap_Document_makeSymmetryPoint, METH_VARARGS, NULL},
31732          { (char *)"Document_makeSymmetryLine", _wrap_Document_makeSymmetryLine, METH_VARARGS, NULL},
31733          { (char *)"Document_makeSymmetryPlane", _wrap_Document_makeSymmetryPlane, METH_VARARGS, NULL},
31734          { (char *)"Document_performTranslation", _wrap_Document_performTranslation, METH_VARARGS, NULL},
31735          { (char *)"Document_performScale", _wrap_Document_performScale, METH_VARARGS, NULL},
31736          { (char *)"Document_performRotation", _wrap_Document_performRotation, METH_VARARGS, NULL},
31737          { (char *)"Document_performSymmetryPoint", _wrap_Document_performSymmetryPoint, METH_VARARGS, NULL},
31738          { (char *)"Document_performSymmetryLine", _wrap_Document_performSymmetryLine, METH_VARARGS, NULL},
31739          { (char *)"Document_performSymmetryPlane", _wrap_Document_performSymmetryPlane, METH_VARARGS, NULL},
31740          { (char *)"Document_disconnectQuad", _wrap_Document_disconnectQuad, METH_VARARGS, NULL},
31741          { (char *)"Document_disconnectEdge", _wrap_Document_disconnectEdge, METH_VARARGS, NULL},
31742          { (char *)"Document_disconnectVertex", _wrap_Document_disconnectVertex, METH_VARARGS, NULL},
31743          { (char *)"Document_disconnectEdges", _wrap_Document_disconnectEdges, METH_VARARGS, NULL},
31744          { (char *)"Document_replace", _wrap_Document_replace, METH_VARARGS, NULL},
31745          { (char *)"Document_mergeVertices", _wrap_Document_mergeVertices, METH_VARARGS, NULL},
31746          { (char *)"Document_mergeEdges", _wrap_Document_mergeEdges, METH_VARARGS, NULL},
31747          { (char *)"Document_mergeQuads", _wrap_Document_mergeQuads, METH_VARARGS, NULL},
31748          { (char *)"Document_clearAssociation", _wrap_Document_clearAssociation, METH_VARARGS, NULL},
31749          { (char *)"Document_associateOpenedLine", _wrap_Document_associateOpenedLine, METH_VARARGS, NULL},
31750          { (char *)"Document_associateClosedLine", _wrap_Document_associateClosedLine, METH_VARARGS, NULL},
31751          { (char *)"Document_countHexa", _wrap_Document_countHexa, METH_VARARGS, NULL},
31752          { (char *)"Document_countQuad", _wrap_Document_countQuad, METH_VARARGS, NULL},
31753          { (char *)"Document_countEdge", _wrap_Document_countEdge, METH_VARARGS, NULL},
31754          { (char *)"Document_countVertex", _wrap_Document_countVertex, METH_VARARGS, NULL},
31755          { (char *)"Document_countVector", _wrap_Document_countVector, METH_VARARGS, NULL},
31756          { (char *)"Document_countGroup", _wrap_Document_countGroup, METH_VARARGS, NULL},
31757          { (char *)"Document_countLaw", _wrap_Document_countLaw, METH_VARARGS, NULL},
31758          { (char *)"Document_countPropagation", _wrap_Document_countPropagation, METH_VARARGS, NULL},
31759          { (char *)"Document_countShape", _wrap_Document_countShape, METH_VARARGS, NULL},
31760          { (char *)"Document_countUsedHexa", _wrap_Document_countUsedHexa, METH_VARARGS, NULL},
31761          { (char *)"Document_countUsedQuad", _wrap_Document_countUsedQuad, METH_VARARGS, NULL},
31762          { (char *)"Document_countUsedEdge", _wrap_Document_countUsedEdge, METH_VARARGS, NULL},
31763          { (char *)"Document_countUsedVertex", _wrap_Document_countUsedVertex, METH_VARARGS, NULL},
31764          { (char *)"Document_getHexa", _wrap_Document_getHexa, METH_VARARGS, NULL},
31765          { (char *)"Document_getQuad", _wrap_Document_getQuad, METH_VARARGS, NULL},
31766          { (char *)"Document_getEdge", _wrap_Document_getEdge, METH_VARARGS, NULL},
31767          { (char *)"Document_getVertex", _wrap_Document_getVertex, METH_VARARGS, NULL},
31768          { (char *)"Document_getUsedHexa", _wrap_Document_getUsedHexa, METH_VARARGS, NULL},
31769          { (char *)"Document_getUsedQuad", _wrap_Document_getUsedQuad, METH_VARARGS, NULL},
31770          { (char *)"Document_getUsedEdge", _wrap_Document_getUsedEdge, METH_VARARGS, NULL},
31771          { (char *)"Document_getUsedVertex", _wrap_Document_getUsedVertex, METH_VARARGS, NULL},
31772          { (char *)"Document_getVector", _wrap_Document_getVector, METH_VARARGS, NULL},
31773          { (char *)"Document_getShape", _wrap_Document_getShape, METH_VARARGS, NULL},
31774          { (char *)"Document_getGroup", _wrap_Document_getGroup, METH_VARARGS, NULL},
31775          { (char *)"Document_getLaw", _wrap_Document_getLaw, METH_VARARGS, NULL},
31776          { (char *)"Document_getPropagation", _wrap_Document_getPropagation, METH_VARARGS, NULL},
31777          { (char *)"Document_findEdge", _wrap_Document_findEdge, METH_VARARGS, NULL},
31778          { (char *)"Document_findQuad", _wrap_Document_findQuad, METH_VARARGS, NULL},
31779          { (char *)"Document_findHexa", _wrap_Document_findHexa, METH_VARARGS, NULL},
31780          { (char *)"Document_findGroup", _wrap_Document_findGroup, METH_VARARGS, NULL},
31781          { (char *)"Document_findLaw", _wrap_Document_findLaw, METH_VARARGS, NULL},
31782          { (char *)"Document_findPropagation", _wrap_Document_findPropagation, METH_VARARGS, NULL},
31783          { (char *)"Document_removeHexa", _wrap_Document_removeHexa, METH_VARARGS, NULL},
31784          { (char *)"Document_removeQuad", _wrap_Document_removeQuad, METH_VARARGS, NULL},
31785          { (char *)"Document_removeConnectedHexa", _wrap_Document_removeConnectedHexa, METH_VARARGS, NULL},
31786          { (char *)"Document_removeElements", _wrap_Document_removeElements, METH_VARARGS, NULL},
31787          { (char *)"Document_removeGroup", _wrap_Document_removeGroup, METH_VARARGS, NULL},
31788          { (char *)"Document_removeLaw", _wrap_Document_removeLaw, METH_VARARGS, NULL},
31789          { (char *)"Document_makeCartesianTop", _wrap_Document_makeCartesianTop, METH_VARARGS, NULL},
31790          { (char *)"Document_makeCartesianUni", _wrap_Document_makeCartesianUni, METH_VARARGS, NULL},
31791          { (char *)"Document_makeCartesian", _wrap_Document_makeCartesian, METH_VARARGS, NULL},
31792          { (char *)"Document_makeCylinderTop", _wrap_Document_makeCylinderTop, METH_VARARGS, NULL},
31793          { (char *)"Document_makeCylinderUni", _wrap_Document_makeCylinderUni, METH_VARARGS, NULL},
31794          { (char *)"Document_makeCylinder", _wrap_Document_makeCylinder, METH_VARARGS, NULL},
31795          { (char *)"Document_makePipeTop", _wrap_Document_makePipeTop, METH_VARARGS, NULL},
31796          { (char *)"Document_makePipeUni", _wrap_Document_makePipeUni, METH_VARARGS, NULL},
31797          { (char *)"Document_makePipe", _wrap_Document_makePipe, METH_VARARGS, NULL},
31798          { (char *)"Document_makeSphericalTop", _wrap_Document_makeSphericalTop, METH_VARARGS, NULL},
31799          { (char *)"Document_makeSphericalUni", _wrap_Document_makeSphericalUni, METH_VARARGS, NULL},
31800          { (char *)"Document_makeSpherical", _wrap_Document_makeSpherical, METH_VARARGS, NULL},
31801          { (char *)"Document_makeSphereTop", _wrap_Document_makeSphereTop, METH_VARARGS, NULL},
31802          { (char *)"Document_makeSphereUni", _wrap_Document_makeSphereUni, METH_VARARGS, NULL},
31803          { (char *)"Document_makeSphere", _wrap_Document_makeSphere, METH_VARARGS, NULL},
31804          { (char *)"Document_makeRindTop", _wrap_Document_makeRindTop, METH_VARARGS, NULL},
31805          { (char *)"Document_makeRindUni", _wrap_Document_makeRindUni, METH_VARARGS, NULL},
31806          { (char *)"Document_makeRind", _wrap_Document_makeRind, METH_VARARGS, NULL},
31807          { (char *)"Document_makeCylinders", _wrap_Document_makeCylinders, METH_VARARGS, NULL},
31808          { (char *)"Document_makePipes", _wrap_Document_makePipes, METH_VARARGS, NULL},
31809          { (char *)"Document_extrudeQuadTop", _wrap_Document_extrudeQuadTop, METH_VARARGS, NULL},
31810          { (char *)"Document_extrudeQuadUni", _wrap_Document_extrudeQuadUni, METH_VARARGS, NULL},
31811          { (char *)"Document_extrudeQuad", _wrap_Document_extrudeQuad, METH_VARARGS, NULL},
31812          { (char *)"Document_extrudeQuadsTop", _wrap_Document_extrudeQuadsTop, METH_VARARGS, NULL},
31813          { (char *)"Document_extrudeQuadsUni", _wrap_Document_extrudeQuadsUni, METH_VARARGS, NULL},
31814          { (char *)"Document_extrudeQuads", _wrap_Document_extrudeQuads, METH_VARARGS, NULL},
31815          { (char *)"Document_revolutionQuadUni", _wrap_Document_revolutionQuadUni, METH_VARARGS, NULL},
31816          { (char *)"Document_revolutionQuad", _wrap_Document_revolutionQuad, METH_VARARGS, NULL},
31817          { (char *)"Document_revolutionQuadsUni", _wrap_Document_revolutionQuadsUni, METH_VARARGS, NULL},
31818          { (char *)"Document_revolutionQuads", _wrap_Document_revolutionQuads, METH_VARARGS, NULL},
31819          { (char *)"Document_joinQuadUni", _wrap_Document_joinQuadUni, METH_VARARGS, NULL},
31820          { (char *)"Document_joinQuadsUni", _wrap_Document_joinQuadsUni, METH_VARARGS, NULL},
31821          { (char *)"Document_joinQuad", _wrap_Document_joinQuad, METH_VARARGS, NULL},
31822          { (char *)"Document_joinQuads", _wrap_Document_joinQuads, METH_VARARGS, NULL},
31823          { (char *)"Document_cutUni", _wrap_Document_cutUni, METH_VARARGS, NULL},
31824          { (char *)"Document_cut", _wrap_Document_cut, METH_VARARGS, NULL},
31825          { (char *)"Document_addGroup", _wrap_Document_addGroup, METH_VARARGS, NULL},
31826          { (char *)"Document_isSaved", _wrap_Document_isSaved, METH_VARARGS, NULL},
31827          { (char *)"Document_appendXml", _wrap_Document_appendXml, METH_VARARGS, NULL},
31828          { (char *)"Document_getXml", _wrap_Document_getXml, METH_VARARGS, NULL},
31829          { (char *)"Document_getLevel", _wrap_Document_getLevel, METH_VARARGS, NULL},
31830          { (char *)"Document_findVertex", _wrap_Document_findVertex, METH_VARARGS, NULL},
31831          { (char *)"Document_closeQuads", _wrap_Document_closeQuads, METH_VARARGS, NULL},
31832          { (char *)"Document_addLaw", _wrap_Document_addLaw, METH_VARARGS, NULL},
31833          { (char *)"Document_checkAssociations", _wrap_Document_checkAssociations, METH_VARARGS, NULL},
31834          { (char *)"Document_addShape", _wrap_Document_addShape, METH_VARARGS, NULL},
31835          { (char *)"delete_Document", _wrap_delete_Document, METH_VARARGS, NULL},
31836          { (char *)"Document_swigregister", Document_swigregister, METH_VARARGS, NULL},
31837          { (char *)"Propagation_getEdges", _wrap_Propagation_getEdges, METH_VARARGS, NULL},
31838          { (char *)"Propagation_getLaw", _wrap_Propagation_getLaw, METH_VARARGS, NULL},
31839          { (char *)"Propagation_getWay", _wrap_Propagation_getWay, METH_VARARGS, NULL},
31840          { (char *)"Propagation_setWay", _wrap_Propagation_setWay, METH_VARARGS, NULL},
31841          { (char *)"Propagation_setLaw", _wrap_Propagation_setLaw, METH_VARARGS, NULL},
31842          { (char *)"new_Propagation", _wrap_new_Propagation, METH_VARARGS, NULL},
31843          { (char *)"Propagation_saveXml", _wrap_Propagation_saveXml, METH_VARARGS, NULL},
31844          { (char *)"Propagation_addEdge", _wrap_Propagation_addEdge, METH_VARARGS, NULL},
31845          { (char *)"Propagation_majLaw", _wrap_Propagation_majLaw, METH_VARARGS, NULL},
31846          { (char *)"delete_Propagation", _wrap_delete_Propagation, METH_VARARGS, NULL},
31847          { (char *)"Propagation_swigregister", Propagation_swigregister, METH_VARARGS, NULL},
31848          { (char *)"hex_instance", _wrap_hex_instance, METH_VARARGS, NULL},
31849          { (char *)"Hex_getInstance", _wrap_Hex_getInstance, METH_VARARGS, NULL},
31850          { (char *)"Hex_countDocument", _wrap_Hex_countDocument, METH_VARARGS, NULL},
31851          { (char *)"Hex_getDocument", _wrap_Hex_getDocument, METH_VARARGS, NULL},
31852          { (char *)"Hex_removeDocument", _wrap_Hex_removeDocument, METH_VARARGS, NULL},
31853          { (char *)"Hex_addDocument", _wrap_Hex_addDocument, METH_VARARGS, NULL},
31854          { (char *)"Hex_loadDocument", _wrap_Hex_loadDocument, METH_VARARGS, NULL},
31855          { (char *)"Hex_findDocument", _wrap_Hex_findDocument, METH_VARARGS, NULL},
31856          { (char *)"Hex_what", _wrap_Hex_what, METH_VARARGS, NULL},
31857          { (char *)"Hex_sizeofMessage", _wrap_Hex_sizeofMessage, METH_VARARGS, NULL},
31858          { (char *)"Hex_getMessageLine", _wrap_Hex_getMessageLine, METH_VARARGS, NULL},
31859          { (char *)"new_Hex", _wrap_new_Hex, METH_VARARGS, NULL},
31860          { (char *)"delete_Hex", _wrap_delete_Hex, METH_VARARGS, NULL},
31861          { (char *)"Hex_swigregister", Hex_swigregister, METH_VARARGS, NULL},
31862          { (char *)"what", _wrap_what, METH_VARARGS, NULL},
31863          { (char *)"Elements_getHexa", _wrap_Elements_getHexa, METH_VARARGS, NULL},
31864          { (char *)"Elements_getQuad", _wrap_Elements_getQuad, METH_VARARGS, NULL},
31865          { (char *)"Elements_getEdge", _wrap_Elements_getEdge, METH_VARARGS, NULL},
31866          { (char *)"Elements_getVertex", _wrap_Elements_getVertex, METH_VARARGS, NULL},
31867          { (char *)"Elements_getHexaIJK", _wrap_Elements_getHexaIJK, METH_VARARGS, NULL},
31868          { (char *)"Elements_getQuadIJ", _wrap_Elements_getQuadIJ, METH_VARARGS, NULL},
31869          { (char *)"Elements_getQuadJK", _wrap_Elements_getQuadJK, METH_VARARGS, NULL},
31870          { (char *)"Elements_getQuadIK", _wrap_Elements_getQuadIK, METH_VARARGS, NULL},
31871          { (char *)"Elements_getEdgeI", _wrap_Elements_getEdgeI, METH_VARARGS, NULL},
31872          { (char *)"Elements_getEdgeJ", _wrap_Elements_getEdgeJ, METH_VARARGS, NULL},
31873          { (char *)"Elements_getEdgeK", _wrap_Elements_getEdgeK, METH_VARARGS, NULL},
31874          { (char *)"Elements_getVertexIJK", _wrap_Elements_getVertexIJK, METH_VARARGS, NULL},
31875          { (char *)"Elements_countHexa", _wrap_Elements_countHexa, METH_VARARGS, NULL},
31876          { (char *)"Elements_countQuad", _wrap_Elements_countQuad, METH_VARARGS, NULL},
31877          { (char *)"Elements_countEdge", _wrap_Elements_countEdge, METH_VARARGS, NULL},
31878          { (char *)"Elements_countVertex", _wrap_Elements_countVertex, METH_VARARGS, NULL},
31879          { (char *)"Elements_nearestVertex", _wrap_Elements_nearestVertex, METH_VARARGS, NULL},
31880          { (char *)"Elements_findVertex", _wrap_Elements_findVertex, METH_VARARGS, NULL},
31881          { (char *)"Elements_clearAssociation", _wrap_Elements_clearAssociation, METH_VARARGS, NULL},
31882          { (char *)"Elements_saveVtk", _wrap_Elements_saveVtk, METH_VARARGS, NULL},
31883          { (char *)"new_Elements", _wrap_new_Elements, METH_VARARGS, NULL},
31884          { (char *)"delete_Elements", _wrap_delete_Elements, METH_VARARGS, NULL},
31885          { (char *)"Elements_swigregister", Elements_swigregister, METH_VARARGS, NULL},
31886          { (char *)"new_BiCylinder", _wrap_new_BiCylinder, METH_VARARGS, NULL},
31887          { (char *)"BiCylinder_getHexaIJK", _wrap_BiCylinder_getHexaIJK, METH_VARARGS, NULL},
31888          { (char *)"BiCylinder_getQuadIJ", _wrap_BiCylinder_getQuadIJ, METH_VARARGS, NULL},
31889          { (char *)"BiCylinder_getQuadJK", _wrap_BiCylinder_getQuadJK, METH_VARARGS, NULL},
31890          { (char *)"BiCylinder_getQuadIK", _wrap_BiCylinder_getQuadIK, METH_VARARGS, NULL},
31891          { (char *)"BiCylinder_getEdgeI", _wrap_BiCylinder_getEdgeI, METH_VARARGS, NULL},
31892          { (char *)"BiCylinder_getEdgeJ", _wrap_BiCylinder_getEdgeJ, METH_VARARGS, NULL},
31893          { (char *)"BiCylinder_getEdgeK", _wrap_BiCylinder_getEdgeK, METH_VARARGS, NULL},
31894          { (char *)"BiCylinder_getVertexIJK", _wrap_BiCylinder_getVertexIJK, METH_VARARGS, NULL},
31895          { (char *)"delete_BiCylinder", _wrap_delete_BiCylinder, METH_VARARGS, NULL},
31896          { (char *)"BiCylinder_swigregister", BiCylinder_swigregister, METH_VARARGS, NULL},
31897          { (char *)"NewShape_countVertex", _wrap_NewShape_countVertex, METH_VARARGS, NULL},
31898          { (char *)"NewShape_countEdge", _wrap_NewShape_countEdge, METH_VARARGS, NULL},
31899          { (char *)"NewShape_countFace", _wrap_NewShape_countFace, METH_VARARGS, NULL},
31900          { (char *)"NewShape_getVertex", _wrap_NewShape_getVertex, METH_VARARGS, NULL},
31901          { (char *)"NewShape_getEdge", _wrap_NewShape_getEdge, METH_VARARGS, NULL},
31902          { (char *)"NewShape_getFace", _wrap_NewShape_getFace, METH_VARARGS, NULL},
31903          { (char *)"NewShape_getNameVertex", _wrap_NewShape_getNameVertex, METH_VARARGS, NULL},
31904          { (char *)"NewShape_getNameEdge", _wrap_NewShape_getNameEdge, METH_VARARGS, NULL},
31905          { (char *)"NewShape_getNameFace", _wrap_NewShape_getNameFace, METH_VARARGS, NULL},
31906          { (char *)"new_NewShape", _wrap_new_NewShape, METH_VARARGS, NULL},
31907          { (char *)"delete_NewShape", _wrap_delete_NewShape, METH_VARARGS, NULL},
31908          { (char *)"NewShape_swigregister", NewShape_swigregister, METH_VARARGS, NULL},
31909          { (char *)"Group_addElement", _wrap_Group_addElement, METH_VARARGS, NULL},
31910          { (char *)"Group_countElement", _wrap_Group_countElement, METH_VARARGS, NULL},
31911          { (char *)"Group_getKind", _wrap_Group_getKind, METH_VARARGS, NULL},
31912          { (char *)"Group_clearElement", _wrap_Group_clearElement, METH_VARARGS, NULL},
31913          { (char *)"Group_removeElement", _wrap_Group_removeElement, METH_VARARGS, NULL},
31914          { (char *)"Group_getElement", _wrap_Group_getElement, METH_VARARGS, NULL},
31915          { (char *)"new_Group", _wrap_new_Group, METH_VARARGS, NULL},
31916          { (char *)"delete_Group", _wrap_delete_Group, METH_VARARGS, NULL},
31917          { (char *)"Group_swigregister", Group_swigregister, METH_VARARGS, NULL},
31918          { NULL, NULL, 0, NULL }
31919 };
31920
31921
31922 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31923
31924 static void *_p_Hex__VectorTo_p_Hex__EltBase(void *x) {
31925     return (void *)((Hex::EltBase *)  ((Hex::Vector *) x));
31926 }
31927 static void *_p_Hex__NewShapeTo_p_Hex__EltBase(void *x) {
31928     return (void *)((Hex::EltBase *)  ((Hex::NewShape *) x));
31929 }
31930 static void *_p_Hex__GroupTo_p_Hex__EltBase(void *x) {
31931     return (void *)((Hex::EltBase *)  ((Hex::Group *) x));
31932 }
31933 static void *_p_Hex__PropagationTo_p_Hex__EltBase(void *x) {
31934     return (void *)((Hex::EltBase *)  ((Hex::Propagation *) x));
31935 }
31936 static void *_p_Hex__VertexTo_p_Hex__EltBase(void *x) {
31937     return (void *)((Hex::EltBase *)  ((Hex::Vertex *) x));
31938 }
31939 static void *_p_Hex__HexaTo_p_Hex__EltBase(void *x) {
31940     return (void *)((Hex::EltBase *)  ((Hex::Hexa *) x));
31941 }
31942 static void *_p_Hex__EdgeTo_p_Hex__EltBase(void *x) {
31943     return (void *)((Hex::EltBase *)  ((Hex::Edge *) x));
31944 }
31945 static void *_p_Hex__QuadTo_p_Hex__EltBase(void *x) {
31946     return (void *)((Hex::EltBase *)  ((Hex::Quad *) x));
31947 }
31948 static void *_p_Hex__ElementsTo_p_Hex__EltBase(void *x) {
31949     return (void *)((Hex::EltBase *)  ((Hex::Elements *) x));
31950 }
31951 static void *_p_Hex__DocumentTo_p_Hex__EltBase(void *x) {
31952     return (void *)((Hex::EltBase *)  ((Hex::Document *) x));
31953 }
31954 static void *_p_Hex__BiCylinderTo_p_Hex__EltBase(void *x) {
31955     return (void *)((Hex::EltBase *) (Hex::Elements *) ((Hex::BiCylinder *) x));
31956 }
31957 static void *_p_Hex__BiCylinderTo_p_Hex__Elements(void *x) {
31958     return (void *)((Hex::Elements *)  ((Hex::BiCylinder *) x));
31959 }
31960 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *|pfile", 0, 0, (void*)0, 0};
31961 static swig_type_info _swigt__p_Hex__BiCylinder = {"_p_Hex__BiCylinder", "Hex::BiCylinder *", 0, 0, (void*)0, 0};
31962 static swig_type_info _swigt__p_Hex__Document = {"_p_Hex__Document", "Hex::Document *", 0, 0, (void*)0, 0};
31963 static swig_type_info _swigt__p_Hex__Edge = {"_p_Hex__Edge", "Hex::Edge *", 0, 0, (void*)0, 0};
31964 static swig_type_info _swigt__p_Hex__Elements = {"_p_Hex__Elements", "Hex::Elements *", 0, 0, (void*)0, 0};
31965 static swig_type_info _swigt__p_Hex__EltBase = {"_p_Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
31966 static swig_type_info _swigt__p_Hex__Group = {"_p_Hex__Group", "Hex::Group *", 0, 0, (void*)0, 0};
31967 static swig_type_info _swigt__p_Hex__Hex = {"_p_Hex__Hex", "Hex::Hex *", 0, 0, (void*)0, 0};
31968 static swig_type_info _swigt__p_Hex__Hex__EltBase = {"_p_Hex__Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
31969 static swig_type_info _swigt__p_Hex__Hexa = {"_p_Hex__Hexa", "Hex::Hexa *", 0, 0, (void*)0, 0};
31970 static swig_type_info _swigt__p_Hex__Law = {"_p_Hex__Law", "Hex::Law *", 0, 0, (void*)0, 0};
31971 static swig_type_info _swigt__p_Hex__NewShape = {"_p_Hex__NewShape", "Hex::NewShape *", 0, 0, (void*)0, 0};
31972 static swig_type_info _swigt__p_Hex__Propagation = {"_p_Hex__Propagation", "Hex::Propagation *", 0, 0, (void*)0, 0};
31973 static swig_type_info _swigt__p_Hex__Quad = {"_p_Hex__Quad", "Hex::Quad *", 0, 0, (void*)0, 0};
31974 static swig_type_info _swigt__p_Hex__Shape = {"_p_Hex__Shape", "Hex::Shape *|Hex::OldShape *", 0, 0, (void*)0, 0};
31975 static swig_type_info _swigt__p_Hex__Vector = {"_p_Hex__Vector", "Hex::Vector *", 0, 0, (void*)0, 0};
31976 static swig_type_info _swigt__p_Hex__Vertex = {"_p_Hex__Vertex", "Hex::Vertex *", 0, 0, (void*)0, 0};
31977 static swig_type_info _swigt__p_Hex__XmlWriter = {"_p_Hex__XmlWriter", "Hex::XmlWriter *", 0, 0, (void*)0, 0};
31978 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};
31979 static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
31980 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
31981 static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
31982 static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
31983 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
31984 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
31985 static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
31986 static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
31987 static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
31988 static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
31989 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};
31990 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};
31991 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};
31992 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};
31993 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};
31994 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};
31995 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};
31996 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};
31997 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};
31998 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};
31999 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};
32000 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};
32001 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};
32002 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};
32003 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};
32004 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};
32005 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};
32006 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};
32007 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};
32008 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};
32009 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};
32010 static swig_type_info _swigt__p_string = {"_p_string", "string *", 0, 0, (void*)0, 0};
32011 static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
32012 static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
32013 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};
32014 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};
32015 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};
32016 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};
32017 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};
32018
32019 static swig_type_info *swig_type_initial[] = {
32020   &_swigt__p_FILE,
32021   &_swigt__p_Hex__BiCylinder,
32022   &_swigt__p_Hex__Document,
32023   &_swigt__p_Hex__Edge,
32024   &_swigt__p_Hex__Elements,
32025   &_swigt__p_Hex__EltBase,
32026   &_swigt__p_Hex__Group,
32027   &_swigt__p_Hex__Hex,
32028   &_swigt__p_Hex__Hex__EltBase,
32029   &_swigt__p_Hex__Hexa,
32030   &_swigt__p_Hex__Law,
32031   &_swigt__p_Hex__NewShape,
32032   &_swigt__p_Hex__Propagation,
32033   &_swigt__p_Hex__Quad,
32034   &_swigt__p_Hex__Shape,
32035   &_swigt__p_Hex__Vector,
32036   &_swigt__p_Hex__Vertex,
32037   &_swigt__p_Hex__XmlWriter,
32038   &_swigt__p_a_Hex__DIM3__double,
32039   &_swigt__p_allocator_type,
32040   &_swigt__p_char,
32041   &_swigt__p_const_reference,
32042   &_swigt__p_difference_type,
32043   &_swigt__p_double,
32044   &_swigt__p_int,
32045   &_swigt__p_p_PyObject,
32046   &_swigt__p_reference,
32047   &_swigt__p_size_type,
32048   &_swigt__p_std__invalid_argument,
32049   &_swigt__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t,
32050   &_swigt__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t,
32051   &_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t,
32052   &_swigt__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type,
32053   &_swigt__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t,
32054   &_swigt__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t,
32055   &_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t,
32056   &_swigt__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type,
32057   &_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t,
32058   &_swigt__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type,
32059   &_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t,
32060   &_swigt__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type,
32061   &_swigt__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t,
32062   &_swigt__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t,
32063   &_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t,
32064   &_swigt__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type,
32065   &_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t,
32066   &_swigt__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type,
32067   &_swigt__p_std__vectorTint_std__allocatorTint_t_t,
32068   &_swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type,
32069   &_swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t,
32070   &_swigt__p_string,
32071   &_swigt__p_swig__PySwigIterator,
32072   &_swigt__p_value_type,
32073   &_swigt__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type,
32074   &_swigt__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type,
32075   &_swigt__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type,
32076   &_swigt__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type,
32077   &_swigt__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type,
32078 };
32079
32080 static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
32081 static swig_cast_info _swigc__p_Hex__BiCylinder[] = {  {&_swigt__p_Hex__BiCylinder, 0, 0, 0},{0, 0, 0, 0}};
32082 static swig_cast_info _swigc__p_Hex__Document[] = {  {&_swigt__p_Hex__Document, 0, 0, 0},{0, 0, 0, 0}};
32083 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}};
32084 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}};
32085 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}};
32086 static swig_cast_info _swigc__p_Hex__Group[] = {  {&_swigt__p_Hex__Group, 0, 0, 0},{0, 0, 0, 0}};
32087 static swig_cast_info _swigc__p_Hex__Hex[] = {  {&_swigt__p_Hex__Hex, 0, 0, 0},{0, 0, 0, 0}};
32088 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}};
32089 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}};
32090 static swig_cast_info _swigc__p_Hex__Law[] = {  {&_swigt__p_Hex__Law, 0, 0, 0},{0, 0, 0, 0}};
32091 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}};
32092 static swig_cast_info _swigc__p_Hex__Propagation[] = {  {&_swigt__p_Hex__Propagation, 0, 0, 0},{0, 0, 0, 0}};
32093 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}};
32094 static swig_cast_info _swigc__p_Hex__Shape[] = {  {&_swigt__p_Hex__Shape, 0, 0, 0},{0, 0, 0, 0}};
32095 static swig_cast_info _swigc__p_Hex__Vector[] = {  {&_swigt__p_Hex__Vector, 0, 0, 0},{0, 0, 0, 0}};
32096 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}};
32097 static swig_cast_info _swigc__p_Hex__XmlWriter[] = {  {&_swigt__p_Hex__XmlWriter, 0, 0, 0},{0, 0, 0, 0}};
32098 static swig_cast_info _swigc__p_a_Hex__DIM3__double[] = {  {&_swigt__p_a_Hex__DIM3__double, 0, 0, 0},{0, 0, 0, 0}};
32099 static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
32100 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
32101 static swig_cast_info _swigc__p_const_reference[] = {  {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
32102 static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
32103 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
32104 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
32105 static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
32106 static swig_cast_info _swigc__p_reference[] = {  {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
32107 static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
32108 static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
32109 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}};
32110 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}};
32111 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}};
32112 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}};
32113 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}};
32114 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}};
32115 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}};
32116 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}};
32117 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}};
32118 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}};
32119 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}};
32120 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}};
32121 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}};
32122 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}};
32123 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}};
32124 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}};
32125 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}};
32126 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}};
32127 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}};
32128 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}};
32129 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}};
32130 static swig_cast_info _swigc__p_string[] = {  {&_swigt__p_string, 0, 0, 0},{0, 0, 0, 0}};
32131 static swig_cast_info _swigc__p_swig__PySwigIterator[] = {  {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
32132 static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
32133 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}};
32134 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}};
32135 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}};
32136 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}};
32137 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}};
32138
32139 static swig_cast_info *swig_cast_initial[] = {
32140   _swigc__p_FILE,
32141   _swigc__p_Hex__BiCylinder,
32142   _swigc__p_Hex__Document,
32143   _swigc__p_Hex__Edge,
32144   _swigc__p_Hex__Elements,
32145   _swigc__p_Hex__EltBase,
32146   _swigc__p_Hex__Group,
32147   _swigc__p_Hex__Hex,
32148   _swigc__p_Hex__Hex__EltBase,
32149   _swigc__p_Hex__Hexa,
32150   _swigc__p_Hex__Law,
32151   _swigc__p_Hex__NewShape,
32152   _swigc__p_Hex__Propagation,
32153   _swigc__p_Hex__Quad,
32154   _swigc__p_Hex__Shape,
32155   _swigc__p_Hex__Vector,
32156   _swigc__p_Hex__Vertex,
32157   _swigc__p_Hex__XmlWriter,
32158   _swigc__p_a_Hex__DIM3__double,
32159   _swigc__p_allocator_type,
32160   _swigc__p_char,
32161   _swigc__p_const_reference,
32162   _swigc__p_difference_type,
32163   _swigc__p_double,
32164   _swigc__p_int,
32165   _swigc__p_p_PyObject,
32166   _swigc__p_reference,
32167   _swigc__p_size_type,
32168   _swigc__p_std__invalid_argument,
32169   _swigc__p_std__vectorTHex__AssoEdge_p_std__allocatorTHex__AssoEdge_p_t_t,
32170   _swigc__p_std__vectorTHex__EdgeShape_p_std__allocatorTHex__EdgeShape_p_t_t,
32171   _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t,
32172   _swigc__p_std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__allocator_type,
32173   _swigc__p_std__vectorTHex__EltBase_p_std__allocatorTHex__EltBase_p_t_t,
32174   _swigc__p_std__vectorTHex__FaceShape_p_std__allocatorTHex__FaceShape_p_t_t,
32175   _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t,
32176   _swigc__p_std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__allocator_type,
32177   _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t,
32178   _swigc__p_std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__allocator_type,
32179   _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t,
32180   _swigc__p_std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__allocator_type,
32181   _swigc__p_std__vectorTHex__Shape_p_std__allocatorTHex__Shape_p_t_t,
32182   _swigc__p_std__vectorTHex__SubShape_p_std__allocatorTHex__SubShape_p_t_t,
32183   _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t,
32184   _swigc__p_std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__allocator_type,
32185   _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t,
32186   _swigc__p_std__vectorTdouble_std__allocatorTdouble_t_t__allocator_type,
32187   _swigc__p_std__vectorTint_std__allocatorTint_t_t,
32188   _swigc__p_std__vectorTint_std__allocatorTint_t_t__allocator_type,
32189   _swigc__p_std__vectorTstd__string_std__allocatorTstd__string_t_t,
32190   _swigc__p_string,
32191   _swigc__p_swig__PySwigIterator,
32192   _swigc__p_value_type,
32193   _swigc__std__vectorTHex__Edge_p_std__allocatorTHex__Edge_p_t_t__value_type,
32194   _swigc__std__vectorTHex__Hexa_p_std__allocatorTHex__Hexa_p_t_t__value_type,
32195   _swigc__std__vectorTHex__NewShape_p_std__allocatorTHex__NewShape_p_t_t__value_type,
32196   _swigc__std__vectorTHex__Quad_p_std__allocatorTHex__Quad_p_t_t__value_type,
32197   _swigc__std__vectorTHex__Vertex_p_std__allocatorTHex__Vertex_p_t_t__value_type,
32198 };
32199
32200
32201 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32202
32203 static swig_const_info swig_const_table[] = {
32204 {0, 0, 0, 0.0, 0, 0}};
32205
32206 #ifdef __cplusplus
32207 }
32208 #endif
32209 /* -----------------------------------------------------------------------------
32210  * Type initialization:
32211  * This problem is tough by the requirement that no dynamic
32212  * memory is used. Also, since swig_type_info structures store pointers to
32213  * swig_cast_info structures and swig_cast_info structures store pointers back
32214  * to swig_type_info structures, we need some lookup code at initialization.
32215  * The idea is that swig generates all the structures that are needed.
32216  * The runtime then collects these partially filled structures.
32217  * The SWIG_InitializeModule function takes these initial arrays out of
32218  * swig_module, and does all the lookup, filling in the swig_module.types
32219  * array with the correct data and linking the correct swig_cast_info
32220  * structures together.
32221  *
32222  * The generated swig_type_info structures are assigned staticly to an initial
32223  * array. We just loop through that array, and handle each type individually.
32224  * First we lookup if this type has been already loaded, and if so, use the
32225  * loaded structure instead of the generated one. Then we have to fill in the
32226  * cast linked list. The cast data is initially stored in something like a
32227  * two-dimensional array. Each row corresponds to a type (there are the same
32228  * number of rows as there are in the swig_type_initial array). Each entry in
32229  * a column is one of the swig_cast_info structures for that type.
32230  * The cast_initial array is actually an array of arrays, because each row has
32231  * a variable number of columns. So to actually build the cast linked list,
32232  * we find the array of casts associated with the type, and loop through it
32233  * adding the casts to the list. The one last trick we need to do is making
32234  * sure the type pointer in the swig_cast_info struct is correct.
32235  *
32236  * First off, we lookup the cast->type name to see if it is already loaded.
32237  * There are three cases to handle:
32238  *  1) If the cast->type has already been loaded AND the type we are adding
32239  *     casting info to has not been loaded (it is in this module), THEN we
32240  *     replace the cast->type pointer with the type pointer that has already
32241  *     been loaded.
32242  *  2) If BOTH types (the one we are adding casting info to, and the
32243  *     cast->type) are loaded, THEN the cast info has already been loaded by
32244  *     the previous module so we just ignore it.
32245  *  3) Finally, if cast->type has not already been loaded, then we add that
32246  *     swig_cast_info to the linked list (because the cast->type) pointer will
32247  *     be correct.
32248  * ----------------------------------------------------------------------------- */
32249
32250 #ifdef __cplusplus
32251 extern "C" {
32252 #if 0
32253 } /* c-mode */
32254 #endif
32255 #endif
32256
32257 #if 0
32258 #define SWIGRUNTIME_DEBUG
32259 #endif
32260
32261
32262 SWIGRUNTIME void
32263 SWIG_InitializeModule(void *clientdata) {
32264   size_t i;
32265   swig_module_info *module_head, *iter;
32266   int found;
32267
32268   clientdata = clientdata;
32269
32270   /* check to see if the circular list has been setup, if not, set it up */
32271   if (swig_module.next==0) {
32272     /* Initialize the swig_module */
32273     swig_module.type_initial = swig_type_initial;
32274     swig_module.cast_initial = swig_cast_initial;
32275     swig_module.next = &swig_module;
32276   }
32277
32278   /* Try and load any already created modules */
32279   module_head = SWIG_GetModule(clientdata);
32280   if (!module_head) {
32281     /* This is the first module loaded for this interpreter */
32282     /* so set the swig module into the interpreter */
32283     SWIG_SetModule(clientdata, &swig_module);
32284     module_head = &swig_module;
32285   } else {
32286     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
32287     found=0;
32288     iter=module_head;
32289     do {
32290       if (iter==&swig_module) {
32291         found=1;
32292         break;
32293       }
32294       iter=iter->next;
32295     } while (iter!= module_head);
32296
32297     /* if the is found in the list, then all is done and we may leave */
32298     if (found) return;
32299     /* otherwise we must add out module into the list */
32300     swig_module.next = module_head->next;
32301     module_head->next = &swig_module;
32302   }
32303
32304   /* Now work on filling in swig_module.types */
32305 #ifdef SWIGRUNTIME_DEBUG
32306   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
32307 #endif
32308   for (i = 0; i < swig_module.size; ++i) {
32309     swig_type_info *type = 0;
32310     swig_type_info *ret;
32311     swig_cast_info *cast;
32312
32313 #ifdef SWIGRUNTIME_DEBUG
32314     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
32315 #endif
32316
32317     /* if there is another module already loaded */
32318     if (swig_module.next != &swig_module) {
32319       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
32320     }
32321     if (type) {
32322       /* Overwrite clientdata field */
32323 #ifdef SWIGRUNTIME_DEBUG
32324       printf("SWIG_InitializeModule: found type %s\n", type->name);
32325 #endif
32326       if (swig_module.type_initial[i]->clientdata) {
32327         type->clientdata = swig_module.type_initial[i]->clientdata;
32328 #ifdef SWIGRUNTIME_DEBUG
32329         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
32330 #endif
32331       }
32332     } else {
32333       type = swig_module.type_initial[i];
32334     }
32335
32336     /* Insert casting types */
32337     cast = swig_module.cast_initial[i];
32338     while (cast->type) {
32339       /* Don't need to add information already in the list */
32340       ret = 0;
32341 #ifdef SWIGRUNTIME_DEBUG
32342       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
32343 #endif
32344       if (swig_module.next != &swig_module) {
32345         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
32346 #ifdef SWIGRUNTIME_DEBUG
32347         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
32348 #endif
32349       }
32350       if (ret) {
32351         if (type == swig_module.type_initial[i]) {
32352 #ifdef SWIGRUNTIME_DEBUG
32353           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
32354 #endif
32355           cast->type = ret;
32356           ret = 0;
32357         } else {
32358           /* Check for casting already in the list */
32359           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
32360 #ifdef SWIGRUNTIME_DEBUG
32361           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
32362 #endif
32363           if (!ocast) ret = 0;
32364         }
32365       }
32366
32367       if (!ret) {
32368 #ifdef SWIGRUNTIME_DEBUG
32369         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
32370 #endif
32371         if (type->cast) {
32372           type->cast->prev = cast;
32373           cast->next = type->cast;
32374         }
32375         type->cast = cast;
32376       }
32377       cast++;
32378     }
32379     /* Set entry in modules->types array equal to the type */
32380     swig_module.types[i] = type;
32381   }
32382   swig_module.types[i] = 0;
32383
32384 #ifdef SWIGRUNTIME_DEBUG
32385   printf("**** SWIG_InitializeModule: Cast List ******\n");
32386   for (i = 0; i < swig_module.size; ++i) {
32387     int j = 0;
32388     swig_cast_info *cast = swig_module.cast_initial[i];
32389     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
32390     while (cast->type) {
32391       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
32392       cast++;
32393       ++j;
32394     }
32395     printf("---- Total casts: %d\n",j);
32396   }
32397   printf("**** SWIG_InitializeModule: Cast List ******\n");
32398 #endif
32399 }
32400
32401 /* This function will propagate the clientdata field of type to
32402 * any new swig_type_info structures that have been added into the list
32403 * of equivalent types.  It is like calling
32404 * SWIG_TypeClientData(type, clientdata) a second time.
32405 */
32406 SWIGRUNTIME void
32407 SWIG_PropagateClientData(void) {
32408   size_t i;
32409   swig_cast_info *equiv;
32410   static int init_run = 0;
32411
32412   if (init_run) return;
32413   init_run = 1;
32414
32415   for (i = 0; i < swig_module.size; i++) {
32416     if (swig_module.types[i]->clientdata) {
32417       equiv = swig_module.types[i]->cast;
32418       while (equiv) {
32419         if (!equiv->converter) {
32420           if (equiv->type && !equiv->type->clientdata)
32421           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
32422         }
32423         equiv = equiv->next;
32424       }
32425     }
32426   }
32427 }
32428
32429 #ifdef __cplusplus
32430 #if 0
32431 {
32432   /* c-mode */
32433 #endif
32434 }
32435 #endif
32436
32437
32438
32439 #ifdef __cplusplus
32440 extern "C" {
32441 #endif
32442
32443   /* Python-specific SWIG API */
32444 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
32445 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32446 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
32447
32448   /* -----------------------------------------------------------------------------
32449    * global variable support code.
32450    * ----------------------------------------------------------------------------- */
32451
32452   typedef struct swig_globalvar {
32453     char       *name;                  /* Name of global variable */
32454     PyObject *(*get_attr)(void);       /* Return the current value */
32455     int       (*set_attr)(PyObject *); /* Set the value */
32456     struct swig_globalvar *next;
32457   } swig_globalvar;
32458
32459   typedef struct swig_varlinkobject {
32460     PyObject_HEAD
32461     swig_globalvar *vars;
32462   } swig_varlinkobject;
32463
32464   SWIGINTERN PyObject *
32465   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
32466     return PyString_FromString("<Swig global variables>");
32467   }
32468
32469   SWIGINTERN PyObject *
32470   swig_varlink_str(swig_varlinkobject *v) {
32471     PyObject *str = PyString_FromString("(");
32472     swig_globalvar  *var;
32473     for (var = v->vars; var; var=var->next) {
32474       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
32475       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
32476     }
32477     PyString_ConcatAndDel(&str,PyString_FromString(")"));
32478     return str;
32479   }
32480
32481   SWIGINTERN int
32482   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
32483     PyObject *str = swig_varlink_str(v);
32484     fprintf(fp,"Swig global variables ");
32485     fprintf(fp,"%s\n", PyString_AsString(str));
32486     Py_DECREF(str);
32487     return 0;
32488   }
32489
32490   SWIGINTERN void
32491   swig_varlink_dealloc(swig_varlinkobject *v) {
32492     swig_globalvar *var = v->vars;
32493     while (var) {
32494       swig_globalvar *n = var->next;
32495       free(var->name);
32496       free(var);
32497       var = n;
32498     }
32499   }
32500
32501   SWIGINTERN PyObject *
32502   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32503     PyObject *res = NULL;
32504     swig_globalvar *var = v->vars;
32505     while (var) {
32506       if (strcmp(var->name,n) == 0) {
32507         res = (*var->get_attr)();
32508         break;
32509       }
32510       var = var->next;
32511     }
32512     if (res == NULL && !PyErr_Occurred()) {
32513       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32514     }
32515     return res;
32516   }
32517
32518   SWIGINTERN int
32519   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32520     int res = 1;
32521     swig_globalvar *var = v->vars;
32522     while (var) {
32523       if (strcmp(var->name,n) == 0) {
32524         res = (*var->set_attr)(p);
32525         break;
32526       }
32527       var = var->next;
32528     }
32529     if (res == 1 && !PyErr_Occurred()) {
32530       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32531     }
32532     return res;
32533   }
32534
32535   SWIGINTERN PyTypeObject*
32536   swig_varlink_type(void) {
32537     static char varlink__doc__[] = "Swig var link object";
32538     static PyTypeObject varlink_type;
32539     static int type_init = 0;
32540     if (!type_init) {
32541       const PyTypeObject tmp
32542       = {
32543         PyObject_HEAD_INIT(NULL)
32544         0,                                  /* Number of items in variable part (ob_size) */
32545         (char *)"swigvarlink",              /* Type name (tp_name) */
32546         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
32547         0,                                  /* Itemsize (tp_itemsize) */
32548         (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */
32549         (printfunc) swig_varlink_print,     /* Print (tp_print) */
32550         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32551         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32552         0,                                  /* tp_compare */
32553         (reprfunc) swig_varlink_repr,       /* tp_repr */
32554         0,                                  /* tp_as_number */
32555         0,                                  /* tp_as_sequence */
32556         0,                                  /* tp_as_mapping */
32557         0,                                  /* tp_hash */
32558         0,                                  /* tp_call */
32559         (reprfunc)swig_varlink_str,        /* tp_str */
32560         0,                                  /* tp_getattro */
32561         0,                                  /* tp_setattro */
32562         0,                                  /* tp_as_buffer */
32563         0,                                  /* tp_flags */
32564         varlink__doc__,                     /* tp_doc */
32565         0,                                  /* tp_traverse */
32566         0,                                  /* tp_clear */
32567         0,                                  /* tp_richcompare */
32568         0,                                  /* tp_weaklistoffset */
32569 #if PY_VERSION_HEX >= 0x02020000
32570         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32571 #endif
32572 #if PY_VERSION_HEX >= 0x02030000
32573         0,                                  /* tp_del */
32574 #endif
32575 #ifdef COUNT_ALLOCS
32576         0,0,0,0                             /* tp_alloc -> tp_next */
32577 #endif
32578       };
32579       varlink_type = tmp;
32580       varlink_type.ob_type = &PyType_Type;
32581       type_init = 1;
32582     }
32583     return &varlink_type;
32584   }
32585
32586   /* Create a variable linking object for use later */
32587   SWIGINTERN PyObject *
32588   SWIG_Python_newvarlink(void) {
32589     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
32590     if (result) {
32591       result->vars = 0;
32592     }
32593     return ((PyObject*) result);
32594   }
32595
32596   SWIGINTERN void
32597   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32598     swig_varlinkobject *v = (swig_varlinkobject *) p;
32599     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32600     if (gv) {
32601       size_t size = strlen(name)+1;
32602       gv->name = (char *)malloc(size);
32603       if (gv->name) {
32604         strncpy(gv->name,name,size);
32605         gv->get_attr = get_attr;
32606         gv->set_attr = set_attr;
32607         gv->next = v->vars;
32608       }
32609     }
32610     v->vars = gv;
32611   }
32612
32613   SWIGINTERN PyObject *
32614   SWIG_globals(void) {
32615     static PyObject *_SWIG_globals = 0;
32616     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
32617     return _SWIG_globals;
32618   }
32619
32620   /* -----------------------------------------------------------------------------
32621    * constants/methods manipulation
32622    * ----------------------------------------------------------------------------- */
32623
32624   /* Install Constants */
32625   SWIGINTERN void
32626   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32627     PyObject *obj = 0;
32628     size_t i;
32629     for (i = 0; constants[i].type; ++i) {
32630       switch(constants[i].type) {
32631       case SWIG_PY_POINTER:
32632         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32633         break;
32634       case SWIG_PY_BINARY:
32635         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32636         break;
32637       default:
32638         obj = 0;
32639         break;
32640       }
32641       if (obj) {
32642         PyDict_SetItemString(d, constants[i].name, obj);
32643         Py_DECREF(obj);
32644       }
32645     }
32646   }
32647
32648   /* -----------------------------------------------------------------------------*/
32649   /* Fix SwigMethods to carry the callback ptrs when needed */
32650   /* -----------------------------------------------------------------------------*/
32651
32652   SWIGINTERN void
32653   SWIG_Python_FixMethods(PyMethodDef *methods,
32654     swig_const_info *const_table,
32655     swig_type_info **types,
32656     swig_type_info **types_initial) {
32657     size_t i;
32658     for (i = 0; methods[i].ml_name; ++i) {
32659       const char *c = methods[i].ml_doc;
32660       if (c && (c = strstr(c, "swig_ptr: "))) {
32661         int j;
32662         swig_const_info *ci = 0;
32663         const char *name = c + 10;
32664         for (j = 0; const_table[j].type; ++j) {
32665           if (strncmp(const_table[j].name, name,
32666               strlen(const_table[j].name)) == 0) {
32667             ci = &(const_table[j]);
32668             break;
32669           }
32670         }
32671         if (ci) {
32672           size_t shift = (ci->ptype) - types;
32673           swig_type_info *ty = types_initial[shift];
32674           size_t ldoc = (c - methods[i].ml_doc);
32675           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32676           char *ndoc = (char*)malloc(ldoc + lptr + 10);
32677           if (ndoc) {
32678             char *buff = ndoc;
32679             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
32680             if (ptr) {
32681               strncpy(buff, methods[i].ml_doc, ldoc);
32682               buff += ldoc;
32683               strncpy(buff, "swig_ptr: ", 10);
32684               buff += 10;
32685               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32686               methods[i].ml_doc = ndoc;
32687             }
32688           }
32689         }
32690       }
32691     }
32692   }
32693
32694 #ifdef __cplusplus
32695 }
32696 #endif
32697
32698 /* -----------------------------------------------------------------------------*
32699  *  Partial Init method
32700  * -----------------------------------------------------------------------------*/
32701
32702 #ifdef __cplusplus
32703 extern "C"
32704 #endif
32705 SWIGEXPORT void SWIG_init(void) {
32706   PyObject *m, *d;
32707
32708   /* Fix SwigMethods to carry the callback ptrs when needed */
32709   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
32710
32711   m = Py_InitModule((char *) SWIG_name, SwigMethods);
32712   d = PyModule_GetDict(m);
32713
32714   SWIG_InitializeModule(0);
32715   SWIG_InstallConstants(d,swig_const_table);
32716
32717
32718   SWIG_Python_SetConstant(d, "HOK",SWIG_From_int(static_cast< int >(0)));
32719   SWIG_Python_SetConstant(d, "HERR",SWIG_From_int(static_cast< int >(1)));
32720   SWIG_Python_SetConstant(d, "NOTHING",SWIG_From_int(static_cast< int >(-1)));
32721   SWIG_Python_SetConstant(d, "EOL",SWIG_From_char(static_cast< char >('\n')));
32722   SWIG_Python_SetConstant(d, "EOS",SWIG_From_int(static_cast< int >(0)));
32723   SWIG_Python_SetConstant(d, "CHVIDE",SWIG_FromCharPtr(""));
32724   SWIG_Python_SetConstant(d, "ZEROR",SWIG_From_double(static_cast< double >(0.0)));
32725   SWIG_Python_SetConstant(d, "UNR",SWIG_From_double(static_cast< double >(1.0)));
32726   SWIG_Python_SetConstant(d, "DEMI",SWIG_From_double(static_cast< double >(0.5)));
32727   SWIG_Python_SetConstant(d, "DIM2",SWIG_From_int(static_cast< int >(2)));
32728   SWIG_Python_SetConstant(d, "M_PI",SWIG_From_double(static_cast< double >(3.14159265358979323846)));
32729   SWIG_Python_SetConstant(d, "Degre2Radian",SWIG_From_double(static_cast< double >(3.14159265358979323846/180)));
32730   SWIG_Python_SetConstant(d, "dir_x",SWIG_From_int(static_cast< int >(Hex::dir_x)));
32731   SWIG_Python_SetConstant(d, "dir_y",SWIG_From_int(static_cast< int >(Hex::dir_y)));
32732   SWIG_Python_SetConstant(d, "dir_z",SWIG_From_int(static_cast< int >(Hex::dir_z)));
32733   SWIG_Python_SetConstant(d, "DIM3",SWIG_From_int(static_cast< int >(Hex::DIM3)));
32734   SWIG_Python_SetConstant(d, "EL_NONE",SWIG_From_int(static_cast< int >(Hex::EL_NONE)));
32735   SWIG_Python_SetConstant(d, "EL_VERTEX",SWIG_From_int(static_cast< int >(Hex::EL_VERTEX)));
32736   SWIG_Python_SetConstant(d, "EL_EDGE",SWIG_From_int(static_cast< int >(Hex::EL_EDGE)));
32737   SWIG_Python_SetConstant(d, "EL_QUAD",SWIG_From_int(static_cast< int >(Hex::EL_QUAD)));
32738   SWIG_Python_SetConstant(d, "EL_HEXA",SWIG_From_int(static_cast< int >(Hex::EL_HEXA)));
32739   SWIG_Python_SetConstant(d, "EL_VECTOR",SWIG_From_int(static_cast< int >(Hex::EL_VECTOR)));
32740   SWIG_Python_SetConstant(d, "EL_GRID",SWIG_From_int(static_cast< int >(Hex::EL_GRID)));
32741   SWIG_Python_SetConstant(d, "EL_CYLINDER",SWIG_From_int(static_cast< int >(Hex::EL_CYLINDER)));
32742   SWIG_Python_SetConstant(d, "EL_PIPE",SWIG_From_int(static_cast< int >(Hex::EL_PIPE)));
32743   SWIG_Python_SetConstant(d, "EL_GROUP",SWIG_From_int(static_cast< int >(Hex::EL_GROUP)));
32744   SWIG_Python_SetConstant(d, "EL_LAW",SWIG_From_int(static_cast< int >(Hex::EL_LAW)));
32745   SWIG_Python_SetConstant(d, "EL_SHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SHAPE)));
32746   SWIG_Python_SetConstant(d, "EL_SUBSHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SUBSHAPE)));
32747   SWIG_Python_SetConstant(d, "EL_PROPAGATION",SWIG_From_int(static_cast< int >(Hex::EL_PROPAGATION)));
32748   SWIG_Python_SetConstant(d, "EL_DOCU",SWIG_From_int(static_cast< int >(Hex::EL_DOCU)));
32749   SWIG_Python_SetConstant(d, "EL_REMOVED",SWIG_From_int(static_cast< int >(Hex::EL_REMOVED)));
32750   SWIG_Python_SetConstant(d, "EL_MAXI",SWIG_From_int(static_cast< int >(Hex::EL_MAXI)));
32751   PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
32752   SWIG_addvarlink(SWIG_globals(),(char*)"ABR_TYPES",ABR_TYPES_get, ABR_TYPES_set);
32753   SWIG_Python_SetConstant(d, "HexaCell",SWIG_From_int(static_cast< int >(Hex::HexaCell)));
32754   SWIG_Python_SetConstant(d, "QuadCell",SWIG_From_int(static_cast< int >(Hex::QuadCell)));
32755   SWIG_Python_SetConstant(d, "EdgeCell",SWIG_From_int(static_cast< int >(Hex::EdgeCell)));
32756   SWIG_Python_SetConstant(d, "HexaNode",SWIG_From_int(static_cast< int >(Hex::HexaNode)));
32757   SWIG_Python_SetConstant(d, "QuadNode",SWIG_From_int(static_cast< int >(Hex::QuadNode)));
32758   SWIG_Python_SetConstant(d, "EdgeNode",SWIG_From_int(static_cast< int >(Hex::EdgeNode)));
32759   SWIG_Python_SetConstant(d, "VertexNode",SWIG_From_int(static_cast< int >(Hex::VertexNode)));
32760   SWIG_Python_SetConstant(d, "SH_NONE",SWIG_From_int(static_cast< int >(Hex::SH_NONE)));
32761   SWIG_Python_SetConstant(d, "SH_IMPORT",SWIG_From_int(static_cast< int >(Hex::SH_IMPORT)));
32762   SWIG_Python_SetConstant(d, "SH_CYLINDER",SWIG_From_int(static_cast< int >(Hex::SH_CYLINDER)));
32763   SWIG_Python_SetConstant(d, "SH_INTER",SWIG_From_int(static_cast< int >(Hex::SH_INTER)));
32764   SWIG_Python_SetConstant(d, "SH_SPHERE",SWIG_From_int(static_cast< int >(Hex::SH_SPHERE)));
32765   SWIG_Python_SetConstant(d, "SH_CLOUD",SWIG_From_int(static_cast< int >(Hex::SH_CLOUD)));
32766   SWIG_Python_SetConstant(d, "SH_EXTRUD",SWIG_From_int(static_cast< int >(Hex::SH_EXTRUD)));
32767   SWIG_Python_SetConstant(d, "CYL_NOFILL",SWIG_From_int(static_cast< int >(Hex::CYL_NOFILL)));
32768   SWIG_Python_SetConstant(d, "CYL_CL4",SWIG_From_int(static_cast< int >(Hex::CYL_CL4)));
32769   SWIG_Python_SetConstant(d, "CYL_CL6",SWIG_From_int(static_cast< int >(Hex::CYL_CL6)));
32770   SWIG_Python_SetConstant(d, "CYL_CLOSED",SWIG_From_int(static_cast< int >(Hex::CYL_CLOSED)));
32771   SWIG_Python_SetConstant(d, "CYL_PEER",SWIG_From_int(static_cast< int >(Hex::CYL_PEER)));
32772   SWIG_Python_SetConstant(d, "CYL_ODD",SWIG_From_int(static_cast< int >(Hex::CYL_ODD)));
32773   SWIG_Python_SetConstant(d, "GR_NONE",SWIG_From_int(static_cast< int >(Hex::GR_NONE)));
32774   SWIG_Python_SetConstant(d, "GR_CARTESIAN",SWIG_From_int(static_cast< int >(Hex::GR_CARTESIAN)));
32775   SWIG_Python_SetConstant(d, "GR_CYLINDRIC",SWIG_From_int(static_cast< int >(Hex::GR_CYLINDRIC)));
32776   SWIG_Python_SetConstant(d, "GR_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_SPHERIC)));
32777   SWIG_Python_SetConstant(d, "GR_JOINT",SWIG_From_int(static_cast< int >(Hex::GR_JOINT)));
32778   SWIG_Python_SetConstant(d, "GR_BICYL",SWIG_From_int(static_cast< int >(Hex::GR_BICYL)));
32779   SWIG_Python_SetConstant(d, "GR_BIPIPE",SWIG_From_int(static_cast< int >(Hex::GR_BIPIPE)));
32780   SWIG_Python_SetConstant(d, "GR_REPLACE",SWIG_From_int(static_cast< int >(Hex::GR_REPLACE)));
32781   SWIG_Python_SetConstant(d, "GR_HEMISPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_HEMISPHERIC)));
32782   SWIG_Python_SetConstant(d, "GR_RIND",SWIG_From_int(static_cast< int >(Hex::GR_RIND)));
32783   SWIG_Python_SetConstant(d, "GR_PART_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_PART_SPHERIC)));
32784   SWIG_Python_SetConstant(d, "GR_PART_RIND",SWIG_From_int(static_cast< int >(Hex::GR_PART_RIND)));
32785   SWIG_Python_SetConstant(d, "S_E",SWIG_From_int(static_cast< int >(Hex::S_E)));
32786   SWIG_Python_SetConstant(d, "S_NE",SWIG_From_int(static_cast< int >(Hex::S_NE)));
32787   SWIG_Python_SetConstant(d, "S_N",SWIG_From_int(static_cast< int >(Hex::S_N)));
32788   SWIG_Python_SetConstant(d, "S_NW",SWIG_From_int(static_cast< int >(Hex::S_NW)));
32789   SWIG_Python_SetConstant(d, "S_W",SWIG_From_int(static_cast< int >(Hex::S_W)));
32790   SWIG_Python_SetConstant(d, "S_SW",SWIG_From_int(static_cast< int >(Hex::S_SW)));
32791   SWIG_Python_SetConstant(d, "S_S",SWIG_From_int(static_cast< int >(Hex::S_S)));
32792   SWIG_Python_SetConstant(d, "S_SE",SWIG_From_int(static_cast< int >(Hex::S_SE)));
32793   SWIG_Python_SetConstant(d, "S_MAXI",SWIG_From_int(static_cast< int >(Hex::S_MAXI)));
32794   SWIG_Python_SetConstant(d, "Uniform",SWIG_From_int(static_cast< int >(Hex::Uniform)));
32795   SWIG_Python_SetConstant(d, "Arithmetic",SWIG_From_int(static_cast< int >(Hex::Arithmetic)));
32796   SWIG_Python_SetConstant(d, "Geometric",SWIG_From_int(static_cast< int >(Hex::Geometric)));
32797   SWIG_Python_SetConstant(d, "OR_FRONT",SWIG_From_int(static_cast< int >(Hex::OR_FRONT)));
32798   SWIG_Python_SetConstant(d, "OR_LEFT",SWIG_From_int(static_cast< int >(Hex::OR_LEFT)));
32799   SWIG_Python_SetConstant(d, "OR_RIGHT",SWIG_From_int(static_cast< int >(Hex::OR_RIGHT)));
32800   SWIG_Python_SetConstant(d, "OR_BACK",SWIG_From_int(static_cast< int >(Hex::OR_BACK)));
32801   SWIG_Python_SetConstant(d, "IS_NONE",SWIG_From_int(static_cast< int >(Hex::IS_NONE)));
32802   SWIG_Python_SetConstant(d, "IS_MARRIED",SWIG_From_int(static_cast< int >(Hex::IS_MARRIED)));
32803   SWIG_Python_SetConstant(d, "NO_COUNTED",SWIG_From_int(static_cast< int >(Hex::NO_COUNTED)));
32804   SWIG_Python_SetConstant(d, "NO_USED",SWIG_From_int(static_cast< int >(Hex::NO_USED)));
32805   SWIG_Python_SetConstant(d, "IS_USED",SWIG_From_int(static_cast< int >(Hex::IS_USED)));
32806   SWIG_Python_SetConstant(d, "V_AMONT",SWIG_From_int(static_cast< int >(Hex::V_AMONT)));
32807   SWIG_Python_SetConstant(d, "V_AVAL",SWIG_From_int(static_cast< int >(Hex::V_AVAL)));
32808   SWIG_Python_SetConstant(d, "V_TWO",SWIG_From_int(static_cast< int >(Hex::V_TWO)));
32809   SWIG_Python_SetConstant(d, "E_A",SWIG_From_int(static_cast< int >(Hex::E_A)));
32810   SWIG_Python_SetConstant(d, "E_B",SWIG_From_int(static_cast< int >(Hex::E_B)));
32811   SWIG_Python_SetConstant(d, "E_C",SWIG_From_int(static_cast< int >(Hex::E_C)));
32812   SWIG_Python_SetConstant(d, "E_D",SWIG_From_int(static_cast< int >(Hex::E_D)));
32813   SWIG_Python_SetConstant(d, "QUAD4",SWIG_From_int(static_cast< int >(Hex::QUAD4)));
32814   SWIG_Python_SetConstant(d, "Q_A",SWIG_From_int(static_cast< int >(Hex::Q_A)));
32815   SWIG_Python_SetConstant(d, "Q_B",SWIG_From_int(static_cast< int >(Hex::Q_B)));
32816   SWIG_Python_SetConstant(d, "Q_C",SWIG_From_int(static_cast< int >(Hex::Q_C)));
32817   SWIG_Python_SetConstant(d, "Q_D",SWIG_From_int(static_cast< int >(Hex::Q_D)));
32818   SWIG_Python_SetConstant(d, "Q_E",SWIG_From_int(static_cast< int >(Hex::Q_E)));
32819   SWIG_Python_SetConstant(d, "Q_F",SWIG_From_int(static_cast< int >(Hex::Q_F)));
32820   SWIG_Python_SetConstant(d, "HQ_MAXI",SWIG_From_int(static_cast< int >(Hex::HQ_MAXI)));
32821   SWIG_Python_SetConstant(d, "E_AC",SWIG_From_int(static_cast< int >(Hex::E_AC)));
32822   SWIG_Python_SetConstant(d, "E_AD",SWIG_From_int(static_cast< int >(Hex::E_AD)));
32823   SWIG_Python_SetConstant(d, "E_BC",SWIG_From_int(static_cast< int >(Hex::E_BC)));
32824   SWIG_Python_SetConstant(d, "E_BD",SWIG_From_int(static_cast< int >(Hex::E_BD)));
32825   SWIG_Python_SetConstant(d, "E_AE",SWIG_From_int(static_cast< int >(Hex::E_AE)));
32826   SWIG_Python_SetConstant(d, "E_AF",SWIG_From_int(static_cast< int >(Hex::E_AF)));
32827   SWIG_Python_SetConstant(d, "E_BE",SWIG_From_int(static_cast< int >(Hex::E_BE)));
32828   SWIG_Python_SetConstant(d, "E_BF",SWIG_From_int(static_cast< int >(Hex::E_BF)));
32829   SWIG_Python_SetConstant(d, "E_CE",SWIG_From_int(static_cast< int >(Hex::E_CE)));
32830   SWIG_Python_SetConstant(d, "E_CF",SWIG_From_int(static_cast< int >(Hex::E_CF)));
32831   SWIG_Python_SetConstant(d, "E_DE",SWIG_From_int(static_cast< int >(Hex::E_DE)));
32832   SWIG_Python_SetConstant(d, "E_DF",SWIG_From_int(static_cast< int >(Hex::E_DF)));
32833   SWIG_Python_SetConstant(d, "HE_MAXI",SWIG_From_int(static_cast< int >(Hex::HE_MAXI)));
32834   SWIG_Python_SetConstant(d, "V_ACE",SWIG_From_int(static_cast< int >(Hex::V_ACE)));
32835   SWIG_Python_SetConstant(d, "V_ACF",SWIG_From_int(static_cast< int >(Hex::V_ACF)));
32836   SWIG_Python_SetConstant(d, "V_ADE",SWIG_From_int(static_cast< int >(Hex::V_ADE)));
32837   SWIG_Python_SetConstant(d, "V_ADF",SWIG_From_int(static_cast< int >(Hex::V_ADF)));
32838   SWIG_Python_SetConstant(d, "V_BCE",SWIG_From_int(static_cast< int >(Hex::V_BCE)));
32839   SWIG_Python_SetConstant(d, "V_BCF",SWIG_From_int(static_cast< int >(Hex::V_BCF)));
32840   SWIG_Python_SetConstant(d, "V_BDE",SWIG_From_int(static_cast< int >(Hex::V_BDE)));
32841   SWIG_Python_SetConstant(d, "V_BDF",SWIG_From_int(static_cast< int >(Hex::V_BDF)));
32842   SWIG_Python_SetConstant(d, "HV_MAXI",SWIG_From_int(static_cast< int >(Hex::HV_MAXI)));
32843   SWIG_Python_SetConstant(d, "Q_INSIDE",SWIG_From_int(static_cast< int >(Hex::Q_INSIDE)));
32844   SWIG_Python_SetConstant(d, "Q_DIRECT",SWIG_From_int(static_cast< int >(Hex::Q_DIRECT)));
32845   SWIG_Python_SetConstant(d, "Q_INVERSE",SWIG_From_int(static_cast< int >(Hex::Q_INVERSE)));
32846   SWIG_Python_SetConstant(d, "Q_UNDEFINED",SWIG_From_int(static_cast< int >(Hex::Q_UNDEFINED)));
32847   SWIG_Python_SetConstant(d, "Q_WAITING",SWIG_From_int(static_cast< int >(Hex::Q_WAITING)));
32848   SWIG_Python_SetConstant(d, "KS_Line",SWIG_From_int(static_cast< int >(Hex::KS_Line)));
32849   SWIG_Python_SetConstant(d, "KS_Circle",SWIG_From_int(static_cast< int >(Hex::KS_Circle)));
32850   SWIG_Python_SetConstant(d, "KS_Ellipse",SWIG_From_int(static_cast< int >(Hex::KS_Ellipse)));
32851   SWIG_Python_SetConstant(d, "KS_Hyperbola",SWIG_From_int(static_cast< int >(Hex::KS_Hyperbola)));
32852   SWIG_Python_SetConstant(d, "KS_Parabola",SWIG_From_int(static_cast< int >(Hex::KS_Parabola)));
32853   SWIG_Python_SetConstant(d, "KS_BezierCurve",SWIG_From_int(static_cast< int >(Hex::KS_BezierCurve)));
32854   SWIG_Python_SetConstant(d, "KS_BSplineCurve",SWIG_From_int(static_cast< int >(Hex::KS_BSplineCurve)));
32855   SWIG_Python_SetConstant(d, "KS_OtherCurve",SWIG_From_int(static_cast< int >(Hex::KS_OtherCurve)));
32856   SWIG_Python_SetConstant(d, "KS_None",SWIG_From_int(static_cast< int >(Hex::KS_None)));
32857   SWIG_Python_SetConstant(d, "CylSmall",SWIG_From_int(static_cast< int >(Hex::CylSmall)));
32858   SWIG_Python_SetConstant(d, "CylBig",SWIG_From_int(static_cast< int >(Hex::CylBig)));
32859   SWIG_Python_SetConstant(d, "NxInt",SWIG_From_int(static_cast< int >(Hex::NxInt)));
32860   SWIG_Python_SetConstant(d, "NxExt",SWIG_From_int(static_cast< int >(Hex::NxExt)));
32861   SWIG_addvarlink(SWIG_globals(),(char*)"Epsil",Epsil_get, Epsil_set);
32862   SWIG_addvarlink(SWIG_globals(),(char*)"UnEpsil",UnEpsil_get, UnEpsil_set);
32863   SWIG_addvarlink(SWIG_globals(),(char*)"Epsil2",Epsil2_get, Epsil2_set);
32864 }
32865